排序算法

冒泡排序

元素两两交换，最终选择一个最大的放到最后，完成一次冒泡；第二次在剩下的元素中再两两交换，选择一个最大的放到剩下元素的最后，以此类推..

时间复杂度,是稳定的，最好和最坏都是O(n^2)

    public static void bubbleSort(int[] arr) {
        int len = arr.length;
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {        // 相邻元素两两对比
                    int temp = arr[j+1];        // 元素交换
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }

快速排序

以第一个为基准，把比基准小的放到基准左边，大的放到基准右边，再对左边和右边的数组选择一个基准，以此类推进行排序..

时间复杂度：最坏O(n2)，平均O(n*log2n)

    public static void quickSort(int a[], int low, int hight) {
        int i, j, index;
        if (low > hight) {
            return;
        }
        i = low;
        j = hight;
        index = a[i]; // 用子表的第一个记录做基准
        while (i < j) { // 从表的两端交替向中间扫描
            while (i < j && a[j] >= index)
                j--;
            if (i < j)
                a[i++] = a[j];// 用比基准小的记录替换低位记录 相当于a[i]=a[j],i++
            while (i < j && a[i] < index)
                i++;
            if (i < j) // 用比基准大的记录替换高位记录
                a[j--] = a[i];
        }
        a[i] = index;// 将基准数值替换回 a[i]
        quickSort(a, low, i - 1); // 对低子表进行递归排序
        quickSort(a, i + 1, hight); // 对高子表进行递归排序
    }

插入排序

假设第一个是已经排好序的，往后一个个进行已经排好序的比较插入操作

时间复杂度：稳定的，是O(n2)

    public static void insertionSort(int[] arr) {
        int j; // 已排序列表下标
        int t; // 待排序元素
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                t = arr[i]; // 赋值给待排序元素
                for (j = i - 1; j >= 0 && arr[j] > t; j--) {
                    arr[j + 1] = arr[j]; // 从后往前遍历已排序列表，逐个和待排序元素比较，如果已排序元素较大，则将它后移
                }
                arr[j + 1] = t; // 将待排序元素插入到正确的位置
            }
        }
    }

希尔排序

先已数组的一半作为增量，逐步缩小增量，每次从之前基础上缩小一半，最后一个数在之前以增量组成的数组中做插入
比如10个数，增量为5，第一次让arr[0]和arr[5]/arr[1]和arr[6]...
第二次增量为2，就让arr[2]在arr[0]..arr[6]在arr[4]、arr[2]、arr[0]中做插入排序

    public static void shellSort(int[] arr) {
        int section = arr.length / 2;//5
        int j;
        int temp;
        while(section >= 1) {
            for(int i = section; i < arr.length; i++) {
                temp = arr[i];//4 7
                j = i - section;//0 1
                while(j >= 0 && arr[j] > temp) {
                    arr[j + section] = arr[j];//arr[5]=5
                    j = j - section;//j=-5
                }
                arr[j + section] = temp;//arr[0]=4
            }
            section /= 2;
        }
        System.out.print("排序后: ");
        for(int x = 0; x < arr.length; x++) {
            System.out.print(arr[x] + "  ");
        }
    }

选择排序

先找出最小的放到第一个位置，在剩下的找出最小的放到第二个位置，以此类推。。

时间复杂度：不稳定，O(n2)

    public static void selectSort(int[] a) {
        if (a == null || a.length <= 0) {
            return;
        }
        for (int i = 0; i < a.length; i++) {
            int temp = a[i];
            int flag = i; // 将当前下标定义为最小值下标
            for (int j = i + 1; j < a.length; j++) {
                if (a[j] < temp) {// a[j] < temp 从小到大排序；a[j] > temp 从大到小排序
                    temp = a[j];
                    flag = j; // 如果有小于当前最小值的关键字将此关键字的下标赋值给flag
                }
            }
            if (flag != i) {
                a[flag] = a[i];
                a[i] = temp;
            }
        }
    }

堆排序

 

private static void heapSort(int[] arr) {
        for (int i = arr.length / 2; i >= 0; i--){
            heapAdjust(arr, i, arr.length);
        }

        for (int i = arr.length - 1; i > 0; i--) {
            swap(arr, 0, i);
            heapAdjust(arr, 0, i);
        }
    }

    private static void heapAdjust(int[] arr, int i, int n) {
        int child;
        int father;
        for (father = arr[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);

            if (child != n - 1 && arr[child] < arr[child + 1]) {
                child++;
            }

            if (father < arr[child]) {
                arr[i] = arr[child];
            } else {
                break;
            }
        }
        arr[i] = father;
    }

    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    private static void swap(int[] arr, int index1, int index2) {
        int tmp = arr[index1];
        arr[index1] = arr[index2];
        arr[index2] = tmp;
    }

归并排序

分而治之，再合并

public static void mergeSort(int[] arr, int low, int high)
    {
        int mid = (low + high)/2;
        if(low < high)
        {
            mergeSort(arr, low, mid);
            mergeSort(arr, mid+1, high);
            merge(arr, low, mid, high);
        }
    }

    private static void merge(int[] arr, int low, int mid, int high)
    {
        int[] temp = new int[high - low + 1];
        int i = low;
        int j = mid+1;
        int k = 0;

        for(; i <= mid && j <= high; k++)
        {
            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(int l = 0; l < temp.length; l++)
            arr[low + l] = temp[l];
    }