算法面试必备-----排序算法
算法面试必备-----排序算法
- 算法面试必备-----排序算法
-
- 冒泡排序
-
- Python实现（n2）
- Java实现（n2）
- 选择排序（不稳定）
-
- Python实现（n2）
- Java实现（n2）
- 插入排序（稳定）
-
- Python实现（n2）
- Java实现（n2）
- 希尔排序（不稳定）
-
- Python实现（nlog(n)）
- Java实现（nlog(n)）
- 归并排序（不稳定）
-
- 基本概念
- Python实现（nlogn）
- Java实现（nlogn）
- 快速排序（不稳定）
-
- Python实现（nlogn）
- Java实现（nlogn）
- 堆排序（不稳定）
-
- python实现（nlogn）
算法面试必备-----排序算法
冒泡排序
冒泡排序，类似于水中冒泡，较大的数沉下去，较小的数慢慢冒起来，假设从小到大，即为较大的数慢慢往后排，较小的数慢慢往前排。
Python实现（n2）
def bubble_sort(a_list):
for i in range(0,len(a_list)-1):
for j in range(0,len(a_list)-1-i):
if a_list[j] > a_list[j+1]:
a_list[j],a_list[j+1] = a_list[j+1],a_list[j]
return a_list
Java实现（n2）
public class BubbleSort{
public static int[] bubbleSort(int[] a_list){
for(int i = 0;i<a_list.length-1;i++){
for(int j = 0;j<a_list.length-1-i;j++){
if(a_list[j]>a_list[j+1]){
int temp = a_list[j];
a_list[j] = a_list[j+1];
a_list[j+1] = temp;
}
}
}
return a_list;
}
public static void main(String[] args){
int[] arr = {
8,7,6,5,4,3,2,1};
bubbleSort(arr);
for(int x :arr){
System.out.println(x);
}
}
}
选择排序（不稳定）
选择排序的基本思想：比较+交换
在待排序的一组数据中，选出最小(最大)的一个数与第一个位置的数交换，然后在剩下的数中，再找最小（最大）的数与第二个位置的数交换位置，
依次类推，直到第N-1个元素与第N个元素交换位置，选择排序结束。
Python实现（n2）
def select_sort(a_list):
for i in range(len(a_list)-1):
min_index = i
for j in range(i+1,len(a_list)):
if a_list[j] < a_list[min_index]:
min_index = j
a_list[i],a_list[min_index] = a_list[min_index],a_list[i]
return a_list
arr2 = [76,65,24,23,3]
print(select_sort(arr2))
Java实现（n2）
public class SelectSort{
public static int[] selectSort(int[] a_list){
for(int i = 0;i<a_list.length-1;i++){
int min_index = i;
for (int j=i+1;j<a_list.length;j++){
if(a_list[j]<a_list[min_index]){
min_index = j;
}
}
int temp = a_list[i];
a_list[i] = a_list[min_index];
a_list[min_index] = temp;
}
return a_list;
}
public static void main(String[] args){
int[] arr = {
8,7,6,5,4,3,2,1};
int[] res = selectSort(arr);
for(int x:res){
System.out.println(x);
}
}
}
插入排序（稳定）
Python实现（n2）
def insert_sort(a_list):
for i in range(1,len(a_list)):
temp = a_list[i]
#从temp的位置开始，从后向前逐渐后移，为temp找到合适的位置
j = i
while j > 0 and temp < a_list[j-1]:
a_list[j] = a_list[j-1]
j-=1
a_list[j] = temp
return a_list
Java实现（n2）
public class InsertSort {
public static int[] insertSort(int[] a_list){
for(int i = 1 ; i < a_list.length;i++){
int temp = a_list[i];
int j = i;
for (j=i;j> 0 && temp < a_list[j-1];j--){
a_list[j] = a_list[j-1];
}
a_list[j] = temp;
}
return a_list;
}
public static void main(String[] args){
int[] arr = {
98,65,43,32,12,2};
int[] res = insertSort(arr);
for (int x:res){
System.out.println(x);
}
}
}
希尔排序（不稳定）
希尔排序的实质就是分组插入排序，又称缩小增量法。
将整个无序序列分割成若干个子序列（由相隔某个“增量”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序时，再对全体元素进行一次直接插入排序。
因为直接插入排序在元素基本有序的情况下，效率是很高的，因此希尔排序在时间效率上有很大提高。
时间复杂度（最差 平均） （nlog(n) nlog(n)）
由于多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以，Shell排序是不稳定的。
Python实现（nlog(n)）
def gap_insertion_sort(a_list,start,gap):
for i in range(start+gap,len(a_list),gap):
currentValue = a_list[i]
position = i
while position >= gap and a_list[position-gap] > currentValue:
a_list[position] = a_list[position-gap]
position = position - gap
a_list[position] = currentValue
def shell_sort(a_list):
sublistcount = len(a_list)//2
while sublistcount > 0:
for startposition in range(sublistcount):
gap_insertion_sort(a_list,startposition,sublistcount)
sublistcount = sublistcount//2
return a_list
arr = [54,26,93,17,77,31,44,55,20]
shell_sort(arr)
Java实现（nlog(n)）
public class ShellSort {
public static int[] shellSort(int[] a_list){
int sublistcurrent = a_list.length/2;
while (sublistcurrent > 0){
for(int startposition = 0;startposition < sublistcurrent;startposition++){
gapInsertSort(a_list,startposition,sublistcurrent);
}
sublistcurrent /= 2;
}
return a_list;
}
public static void gapInsertSort(int[] a_list,int start,int gap){
for(int i = start+gap;i < a_list.length;i+=gap){
int currnetValue = a_list[i];
int position = i;
while (position >= gap && currnetValue < a_list[position-gap]){
a_list[position] = a_list[position-gap];
position -= gap;
}
a_list[position] = currnetValue;
}
}
public static void main(String[] args){
int[] arr = {
54,26,93,17,77,31,44,55,2};
int[] res = shellSort(arr);
for (int x :res){
System.out.println(x);
}
}
}
归并排序（不稳定）
基本概念
(1) 归并排序的流程
(2) 合并两个有序数组的流程
Python实现（nlogn）
def merge_sort(a_list):
if len(a_list) > 1:
mid = len(a_list) //2
lefthalf = a_list[:mid]
righthalf = a_list[mid:]
merge_sort(lefthalf)
merge_sort(righthalf)
i,j,k = 0,0,0
while i < len(lefthalf) and j < len(righthalf):
if lefthalf[i] < righthalf[j]:
a_list[k] = lefthalf[i]
i += 1
else:
a_list[k] = righthalf[j]
j += 1
k += 1
while i < len(lefthalf):
a_list[k] = lefthalf[i]
i += 1
k += 1
while j < len(righthalf):
a_list[k] = righthalf[j]
j += 1
k += 1
return a_list
Java实现（nlogn）
在这里插入代码片
快速排序（不稳定）
Python实现（nlogn）
def quick_sort(a_list):
recursive(a_list,0,len(a_list)-1)
return a_list
def recursive(a_list,low,high):
if low < high:
base_index = partition(a_list,low,high)
recursive(a_list,low,base_index)
recursive(a_list,base_index+1,high)
def partition(a_list,low,high):
base = a_list[low]
while low < high and a_list[high] > base:
high -= 1
if low < high:
a_list[low] = a_list[high]
while low < high and a_list[low] < base:
low += 1
if low < high:
a_list[high] = a_list[low]
a_list[low] = base
return low
Java实现（nlogn）
public class QuickSort {
public static int[] quickSort(int[] a_list){
recursive(a_list,0,a_list.length-1);
return a_list;
}
public static void recursive(int[] a_list,int low,int high){
if (low < high){
int base_index = partition(a_list,low,high);
recursive(a_list,low,base_index);
recursive(a_list,base_index+1,high);
}
}
public static int partition(int[] a_list,int low,int high){
int base = a_list[low];
while (low < high && a_list[high] > base){
high --;
}
if(low < high){
a_list[low] = a_list[high];
}
while (low < high && a_list[low] < base){
low ++;
}
if (low < high){
a_list[high] = a_list[low];
}
a_list[low] = base;
return low;
}
public static void main(String[] args){
int[] arr = {
87,65,65,4237,45,432};
int[] res = quickSort(arr);
for (int x:res){
System.out.println(x);
}
}
}
堆排序（不稳定）
python实现（nlogn）
def swap(a_list, i, j):
a_list[i], a_list[j] = a_list[j], a_list[i]
def heapify(a_list, i):
left = 2 * i + 1
right = 2 * i + 2
largest = i
if left < arrLen and a_list[left] > a_list[largest]:
largest = left
if right < arrLen and a_list[right] > a_list[largest]:
largest = right
if largest != i:
swap(a_list, i, largest)
heapify(a_list, largest)
def buildMaxHeap(a_list):
for i in range(len(a_list) // 2, -1, -1):
heapify(a_list, i)
def heapSort(a_list):
global arrLen
arrLen = len(a_list)
buildMaxHeap(a_list)
for i in range(len(a_list) - 1, 0, -1):
swap(a_list, 0, i)
arrLen -= 1
heapify(a_list, 0)
return a_list
在这里插入代码片