版权声明：小明酱私有，私自转载要捶你小胸口哦～ https://blog.csdn.net/alicelmx/article/details/88126902
一切为了暑期实习，一切为了暑期实习。
我就是试着去面面，实习是不可能实习的，老板是不会让我们去的。
哭！！！
以下是正题！！！
以下排序排名有先后之分，请注意复习策略～
快速排序
快排特别重要！！！
快排特别重要！！！
快排特别重要！！！
基本思想
- 首先在数组中选择一个基准点（一般选取第一个数字），
- 然后分别从数组的两端扫描数组，设两个指示标志（low指向起始位置，high指向末尾)，
( 首先从后半部分开始，如果发现有元素比该基准点的值小，就交换low和high位置的值，然后从前半部分开始扫秒，发现有元素大于基准点的值，就交换low和high位置的值，如此往复循环，直到low>=high,然后把基准点的值放到high这个位置。一次排序就完成了。) - 以后采用递归的方式分别对前半部分和后半部分排序，当前半部分和后半部分均有序时该数组就自然有序了。
代码实现
package algorithm;
public class QuickSort {
public static void main(String[] args) {
int[] arr={49,38,65,97};
int low = 0, high = arr.length-1;
quickSort(arr,low,high);
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
public static void quickSort(int[] arr, int low, int high) {
if(low >= high) return;
int index = partition(arr,low,high);
quickSort(arr,low,index-1);
quickSort(arr,index+1,high);
}
public static int partition(int[] arr, int low, int high) {
int key = arr[low];
while(low < high) {
while(low < high && arr[high] >= key) high --;
arr[low] = arr[high];
while(low < high && arr[low] <= key) low ++;
arr[high] = arr[low];
}
arr[high] = key;
return high;
}
}
冒泡排序
基本思想
相邻两节点进行比较，大的向后移一个，经过第一轮两两比较和移动，最大的元素移动到了最后，第二轮次大的位于倒数第二个，依次进行。
代码实现
package algorithm;
public class BubbleSort {
public static void main(String[] args) {
int[] arr={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51};
bubbleSort(arr);
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
public static void bubbleSort(int[] arr) {
for(int i=0;i<arr.length-1;i++) {
for(int j=0;j<arr.length-1-i;j++) {
if(arr[j]>arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
直接插入排序
基本思想
遍历数组，遍历到i时，a0,a1…ai-1是已经排好序的，取出ai，从ai-1开始向前和每个比较大小，如果小于，则将此位置元素向后移动，继续先前比较，如果不小于，则放到正在比较的元素之后。可见相等元素比较是，原来靠后的还是拍在后边，所以插入排序是稳定的。
代码实现
package algorithm;
public class InsertSort {
public static void main(String[] args) {
int[] arr={49,38,65,97,76,13,27,49,78};
insertSort(arr);
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
public static void insertSort(int[] arr) {
for(int i=1;i<arr.length;i++) {
int temp = arr[i];
int j=i-1;
while(j>=0 && arr[j]>temp) {
arr[j+1] = arr[j];
j--;
}
arr[j+1] = temp;
}
}
}
归并排序
基本思想
首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。
代码实现
package algorithm;
public class MergeSort {
public static void main(String[] args) {
int[] arr={49,38,65,97,38};
int low = 0, high = arr.length-1;
mergeSort(arr,low,high);
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
public static void mergeSort(int[] arr, int low, int high) {
if(low < high) {
int mid = (low+high)/2;
mergeSort(arr,low,mid);
mergeSort(arr,mid+1,high);
merge(arr,low,mid,high);
}
}
public static void merge(int[] arr, int low, int mid, int high) {
int[] temp = new int[high-low+1];
int k=0,i=low,j=mid+1;
while(i<=mid && j<=high) {
if(arr[i]<arr[j])
temp[k++] = arr[i++];
else
temp[k++] = arr[j++];
}
while(i<=mid)
temp[k++] = arr[i++];
while(j<=high)
temp[k++] = arr[j++];
for(k=0;k<temp.length;k++) {
arr[low+k] = temp[k];
}
}
}
简单选择排序
package algorithm;
public class SelectSort {
public static void main(String[] args) {
int[] arr={4,1,3,7};
selectSort(arr);
for(int i=0;i<arr.length;i++)
System.out.println(arr[i]);
}
public static void selectSort(int[] arr) {
for(int i=0;i<arr.length;i++) {
int index=i;
for(int j=i+1;j<arr.length;j++)
if(arr[index]>arr[j])
index = j;
int temp = arr[index];
arr[index] = arr[i];
arr[i] = temp;
}
}
}
常考问题
排序的稳定性
- 不稳定(快些选一堆)
选择排序（selection sort）— O(n2)
快速排序（quicksort）— O(nlogn) 平均时间, O(n2) 最坏情况; 对于大的、乱序串列一般认为是最快的已知排序
堆排序 （heapsort）— O(nlogn)
希尔排序 （shell sort）— O(nlogn)
基数排序（radix sort）— O(n·k); 需要 O(n) 额外存储空间 （K为特征个数）
- 稳定：
插入排序（insertion sort）— O(n2)
冒泡排序（bubble sort） — O(n2)
归并排序 （merge sort）— O(nlog n); 需要 O(n) 额外存储空间
二叉树排序（Binary tree sort） — O(nlogn); 需要 O(n) 额外存储空间
计数排序 (counting sort) — O(n+k); 需要 O(n+k) 额外存储空间，k为序列中Max-Min+1
桶排序 （bucket sort）— O(n); 需要 O(k) 额外存储空间