复习——几种排序实现

这篇文章是复习所有排序的，参考了 http://www.cnblogs.com/huangxincheng/archive/2011/11/16/2251196.html ，在此表示感谢

一：冒泡

冒泡一般想着每一轮都会有一个数到最终的位置，可以是最大也可以是最小，性质都一样

public static void bubbleSort(List<Integer> arr){for(int i=0;i<arr.size()-1;i++){for(int j=arr.size()-1;j>i;j--){if(arr.get(j-1) > arr.get(j)){int temp = arr.get(j-1);arr.set(j-1, arr.get(j));arr.set(j, temp);}}}}

40203010501040203050102040305010203040501020304050i指向arr+i处，j指向arr+j处进行循环，共同比对n+(n-1)+...+1 = O(n^2),当本身即排序时，可以为O(n)，可以加一个flag标记，当交互次数小于等于0时即跳出

二：快排

快排的思想是：一个串，选取一个基础值base，将大于base全放在base的右侧，小于base的放在左侧，这样一轮下来base到了固定的位置上并且将一个大串分成了两个小串，用递归的思想继续做下去

延伸：这种思想可以用来选取一个数组中的前k个大的数~~

private int division(List<Integer> list,int left,int right){int base = list.get(left);while(right > left){while(right > left && list.get(right) >= base){right -= 1;}list.set(left, list.get(right));while(right > left && list.get(left) <= base){left += 1;}list.set(right, list.get(left));}list.set(left, base);return left;}public void quickSort(List<Integer> list,int left,int right){if(left < right){int i = division(list, left, right);quickSort(list, left, i-1);quickSort(list, i+1, right);}}

时间复杂度：平均O(nlogn)，最差O(n^2)

三：直接选择排序

思想：直接选择排序其实非常简单，就是从前向后遍历，每一轮都选择剩余数中最小的值放在前端

public static List<Integer> selectionSort(List<Integer> list){if(list == null)return null;for(int i=0;i<list.size()-1;i++){int minIndex = i;for(int j=i+1;j<list.size()-1;j++){if(list.get(j) < list.get(minIndex)){ minIndex = j;}}if(list.get(minIndex) < list.get(i)){int temp = list.get(minIndex);list.set(minIndex, list.get(i));list.set(i, temp);}}return list;}

40203010501020304050102030405010203040501020304050
时间复杂度是O(n^2)

四：堆排序

堆排序一般分为大堆和小堆，堆一般除了用于排序之外也用于选取top K值，上文中说了快排也是可以选取top K的

所谓大堆：指根节点比所有的子节点大的堆，小堆相反，图示如下：

static void heapAdjust(int[] arr,int parent,int length){if (arr == null) {return;}int temp = arr[parent];int child = 2*parent+1;while(child < length){if(child+1 < length && arr[child] < arr[child+1]){child += 1;}if(temp > arr[child]){break;}arr[parent] = arr[child];parent = child;child = 2*parent + 1;}arr[parent] = temp;}public static void heapSort(int[] arr,int top){if(arr == null || top > arr.length || top <0){return;}for(int i=arr.length/2-1;i>=0;i--){heapAdjust(arr, i, arr.length);}for(int i=arr.length-1;i>=arr.length-top;i--){System.out.println("arr[0] = "+arr[0]);int temp = arr[0];arr[0] = arr[i];arr[i] = temp;heapAdjust(arr, 0, i);}}

堆排序时间复杂度O(nlogn)

五：插入排序

思想，插入排序就是将一个数组分为两段，以段是有序的，另一段是无序的，然后每次从无序段里选取一个数与有序段中的数字依次比较，插入合适的位置

public static void insertSort(int[] arr){if(arr == null){return;}for(int i = 1;i < arr.length;i++){int temp = arr[i];int j;for(j = i-1;j>=0 && temp < arr[j];j--){arr[j+1] = arr[j];}arr[j+1] = temp;}}

时间复杂度：最好情况下O（n）,最坏O（n^2）

六：希尔排序

思想：希尔排序和插入排序本质是相同的，只是将一个大的数组按照一定的规则step(初始值为arr.length/2)来分割成多个小数组

随着step的逐步减小(默认为每次缩小一半)，最终step减为1的时候则对整个数组进行插入排序，不过此时的数组已经基本有序

public static void shellSort(int[] arr){int step = arr.length/2;while(step >= 1){for(int i = step;i<arr.length;i++){int j;int temp = arr[i];for(j = i-step;j>=0 && temp<arr[j];j-=step){arr[j+step] = arr[j];}arr[j+step] = temp;}step /= 2;}}

时间复杂度：平均为O(n^3/2)

七：归并排序

思想：归并排序的思想简单说起来就是大的分成小的，无限分下去，然后对小的进行排序，然后再合并这些小的

public static void mergeSort(int[] arr,int[] tempArr,int left,int right){if(left<right){//取分割的位置int middle = (left + right)/2;mergeSort(arr, tempArr, left, middle);mergeSort(arr, tempArr, middle+1, right);merge(arr, tempArr, left, middle+1, right);}}/** * * <p>Title: merge</p>* <p>Description: </p>* <p>描述：我们借用零时数组进行合并</p>* @param arr* @param left* @param middle* @param right */public static void merge(int[] arr,int[] tempArr,int left,int middle,int right){int leftEnd = middle-1;int rightStart = middle;int tempLength = right-left+1;int tempIndex = left;while(left <= leftEnd && rightStart <= right){if(arr[left] < arr[rightStart]){tempArr[tempIndex++] = arr[left++];}else {tempArr[tempIndex++] = arr[rightStart++];}}while(left <= leftEnd){tempArr[tempIndex++] = arr[left++];}while(rightStart <= right){tempArr[tempIndex++] = arr[rightStart++];}for(int i=0;i<tempLength;i++){arr[right] = tempArr[right];right--;}}

时间复杂度：O(nlogn)

空间复杂度：O(n)