排序总结（java）

总结

名称	最好时间复杂度	最坏时间复杂度	平均时间复杂度	空间复杂度	稳定性	稳定性
简单选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定	n小时较好
直接插入排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定	大部分已有序时较好
冒泡排序	O(n)	O(n^2)	O(n^2)	O(1)	稳定	n小时较好
快速排序	O(nlogn)	O(n^2)	O(nlogn)	O(logn)	不稳定	n大时较好
堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定	n大时较好
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定	n大时较好
桶排序
基数排序
希尔排序
拓扑排序
计数排序

import java.util.Random;

class Sort {
    /**
     * 直接插入排序
     * 外层循环运行arr.length-1次，每次把第i个元素插入到已有序的[0,i-1]中，并使[0,i]继续保持从小到大有序
     * while循环是将比第i个元素大的元素放到后面，并且寻找第i个元素的合适位置
     * @param arr
     */
    public void insertionSort(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;
        }
    }

    /**
     * 简单选择排序
     * 外层循环进行arr.length-2次，每次从[i,arr.length)中选择出最小的元素放到i的位置
     * 
     * @param arr
     */
    public void simpleSelectSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[min] > arr[j]) {
                    min = j;
                }
            }
            if (i != min) {
                swap(arr, i, min);
            }
        }
    }

    /**
     * 冒泡排序
     * 外层循环需要进行arr.length-2次，每次把[0,arr.length-i)中最大的元素冒泡到最后面
     * 内层循环是相邻的两个元素，如果前面的比较大，就与后面的交换
     * 在全部有序的情况下，最好时间复杂度为O(n)
     *
     * @param arr
     */
    public void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
        	boolean didSwap = false;
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    swap(arr, j, j + 1);
                    didSwap = true;
                }
            }
            if (!didSwap) {
            	break;
            }
        }
    }
    
    /**
     * 交换数组两个下标内的值
     *
     * @param arr
     * @param i
     * @param j
     */
    public void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

快速排序

import java.util.Random;

class Solution {
    /**
     * 快速排序
     *
     * @param arr
     */
    public void quickSort(int[] arr, int low, int high) {
        if (low >= high) {
            return;
        }
        int p = quickSortPartition(arr, low, high);
        quickSort(arr, low, p - 1);
        quickSort(arr, p + 1, high);
    }

    /**
     * 快速排序中一个基准值归位划分区间
     *
     * @param arr
     * @param low
     * @param high
     * @return
     */
    public int quickSortPartition(int[] arr, int low, int high) {
        swap(arr, new Random().nextInt(high - low + 1) + low, low);
        int base = arr[low], i = low, j = high;
        while (i < j) {
            //基准值在最左边，应该从右边先开始，即j先开始
            while (i < j && base <= arr[j]) {
                j--;
            }
            while (i < j && base >= arr[i]) {
                i++;
            }
            swap(arr, i, j);
        }
        arr[low] = arr[i];
        arr[i] = base;
        return i;
    }

    /**
     * 交换数组两个下标内的值
     *
     * @param arr
     * @param i
     * @param j
     */
    public void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

二路归并排序

class Solution {
    /**
     * 二路归并排序
     * 
     * @param nums
     * @param low
     * @param high
     */
    public void mergeSort(int[] nums, int low, int high) {
        if (low >= high) {
            return;
        }
        int mid = low + (high - low) / 2;
        mergeSort(nums, low, mid);
        mergeSort(nums, mid + 1, high);
        mergeTwoPartition(nums, low, mid, high);
    }
    /**
     * 归并两个相邻有序的区间
     * 
     * @param nums
     * @param low
     * @param mid
     * @param high
     */
    public void mergeTwoPartition(int[] nums, int low, int mid, int high) {
        int[] copy = nums.clone();
        int k = low, i = low, j = mid + 1;
        while (i < mid + 1 && j < high + 1) {
            if (copy[i] >= copy[j]) {
                nums[k++] = copy[j++];
            } else {
                nums[k++] = copy[i++];
            }
        }
        while (i < mid + 1) {
            nums[k++] = copy[i++];
        }
        while (j < high + 1) {
            nums[k++] = copy[j++];
        }
    }
}

堆排序

public class HeapSort {

    /**
     * 将k下标位置及以下整理成堆
     * 
     * @param tree
     * @param k
     * @param end
     */
    public void siftDown(int[] tree, int k, int end) {
        for (int i = k, j = 2 * i + 1; j <= end; ) {
            if (j + 1 <= end) {
                j = tree[j] < tree[j + 1] ? j : j + 1;
            }
            if (tree[i] <= tree[j]) {
                break;
            }
            swap(tree, i, j);
            i = j;
            j = 2 * i + 1;
        }
    }

    /**
     * 建立堆
     * 
     * @param tree
     */
    public void buildHeap(int[] tree) {
        for (int i = tree.length /2 - 1; i >= 0; i--) {
            siftDown(tree, i, tree.length - 1);
        }
    }

    /**
     * 堆排序，注意小顶堆使用堆排序后变成从大到小排序
     * 
     * @param tree
     */
    public void heapSort(int[] tree) {
        buildHeap(tree);
        for (int i = tree.length - 1; i >= 0; i--) {
            swap(tree, i, 0);
            siftDown(tree, 0, i - 1);
        }
    }

    /**
     * 交换数组两个不同下标的值
     * 
     * @param nums
     * @param i
     * @param j
     */
    public void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}