排序算法汇总

 public class QuickDemo {    public static void main(String[] args) {        int[] arr = {5, 2, 4, 9, 7, 564, 123, 643, 8, 64, 8, 75, 6, 7968, 4648, 46};//        sort(arr, 0, arr.length - 1);    }    /**     * 　堆排序是一种树形选择排序，是对直接选择排序的有效改进。     * <p>堆的定义下：具备n个元素的序列 （h1,h2,...,hn),当且仅当知足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）     * (i=1,2,...,n/2)时称之为堆。在这里只讨论知足前者条件的堆。由堆的定义能够看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。     * 彻底二 叉树能够很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。     * <p>思想:初始时把要排序的数的序列看做是一棵顺序存储的二叉树，调整它们的存储序，     * 使之成为一个 堆，这时堆的根节点的数最大。而后将根节点与堆的最后一个节点交换。     * 而后对前面(n-1)个数从新调整使之成为堆。依此类推，直到只有两个节点的堆，并对 它们做交换，     * 最后获得有n个节点的有序序列。从算法描述来看，堆排序须要两个过程，一是创建堆，     * 二是堆顶与堆的最后一个元素交换位置。因此堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。     *     * @param args     */    public static void mains(String[] args) {        int[] a = {49, 38, 65, 97, 76, 13, 27, 49, 78, 34, 12, 64};        int arrayLength = a.length;        //循环建堆        for (int i = 0; i < arrayLength - 1; i++) {            //建堆            buildMaxHeap(a, arrayLength - 1 - i);            //交换堆顶和最后一个元素            swap(a, 0, arrayLength - 1 - i);            System.out.println(Arrays.toString(a));        }    }    //对data数组从0到lastIndex建大顶堆    public static void buildMaxHeap(int[] data, int lastIndex) {        //从lastIndex处节点（最后一个节点）的父节点开始        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {            //k保存正在判断的节点            int k = i;            //若是当前k节点的子节点存在            while (k * 2 + 1 <= lastIndex) {                //k节点的左子节点的索引                int biggerIndex = 2 * k + 1;                //若是biggerIndex小于lastIndex，即biggerIndex+1表明的k节点的右子节点存在                if (biggerIndex < lastIndex) {                    //若果右子节点的值较大                    if (data[biggerIndex] < data[biggerIndex + 1]) {                        //biggerIndex老是记录较大子节点的索引                        biggerIndex++;                    }                }                //若是k节点的值小于其较大的子节点的值                if (data[k] < data[biggerIndex]) {                    //交换他们                    swap(data, k, biggerIndex);                    //将biggerIndex赋予k，开始while循环的下一次循环，从新保证k节点的值大于其左右子节点的值                    k = biggerIndex;                } else {                    break;                }            }        }    }    //交换    public static void swap(int[] data, int i, int j) {        int tmp = data[i];        data[i] = data[j];        data[j] = tmp;    }    /**     * 归并排序     * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，     * 每一个子序列是有序的。而后再把有序子序列合并为总体有序序列     * 时间复杂度为O(nlogn)     * 稳定排序方式     *     * @param nums 待排序数组     * @return 输出有序数组     */    public static int[] sortguibing(int[] nums, int low, int high) {        int mid = (low + high) / 2;        if (low < high) {            // 左边            sort(nums, low, mid);            // 右边            sort(nums, mid + 1, high);            // 左右归并            merge(nums, low, mid, high);        }        return nums;    }    /**     * 将数组中low到high位置的数进行排序     *     * @param nums 待排序数组     * @param low  待排的开始位置     * @param mid  待排中间位置     * @param high 待排结束位置     */    public static void merge(int[] nums, int low, int mid, int high) {        int[] temp = new int[high - low + 1];        int i = low;// 左指针        int j = mid + 1;// 右指针        int k = 0;        // 把较小的数先移到新数组中        while (i <= mid && j <= high) {            if (nums[i] < nums[j]) {                temp[k++] = nums[i++];            } else {                temp[k++] = nums[j++];            }        }        // 把左边剩余的数移入数组        while (i <= mid) {            temp[k++] = nums[i++];        }        // 把右边边剩余的数移入数组        while (j <= high) {            temp[k++] = nums[j++];        }        // 把新数组中的数覆盖nums数组        for (int k2 = 0; k2 < temp.length; k2++) {            nums[k2 + low] = temp[k2];        }    }    /**     * 希尔排序的原理:根据需求，若是你想要结果从大到小排列，它会首先将数组进行分组，而后将较大值移到前面，较小值     * 移到后面，最后将整个数组进行插入排序，这样比起一开始就用插入排序减小了数据交换和移动的次数，能够说希尔排序是增强     * 版的插入排序     * 拿数组5, 2, 8, 9, 1, 3，4来讲，数组长度为7，当increment为3时，数组分为两个序列     * 5，2，8和9，1，3，4，第一次排序，9和5比较，1和2比较，3和8比较，4和比其下标值小increment的数组值相比较     * 此例子是按照从大到小排列，因此大的会排在前面，第一次排序后数组为9, 2, 8, 5, 1, 3，4     * 第一次后increment的值变为3/2=1,此时对数组进行插入排序，     * 实现数组从大到小排     */    public static void shellSort(int[] data) {        int j = 0;        int temp = 0;        //每次将步长缩短为原来的一半        for (int increment = data.length / 2; increment > 0; increment /= 2) {            for (int i = increment; i < data.length; i++) {                temp = data[i];                for (j = i; j >= increment; j -= increment) {                    if (temp > data[j - increment])//如想从小到大排只需修改这里                    {                        data[j] = data[j - increment];                    } else {                        break;                    }                }                data[j] = temp;            }        }    }    /**     * 插入排序     * <p>     * 从第一个元素开始，该元素能够认为已经被排序     * 取出下一个元素，在已经排序的元素序列中从后向前扫描     * 若是该元素（已排序）大于新元素，将该元素移到下一位置     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置     * 将新元素插入到该位置中     * 重复步骤2     *     * @param numbers 待排序数组     */    public static void insertSort(int[] numbers) {        int size = numbers.length;        int temp = 0;        int j = 0;        for (int i = 0; i < size; i++) {            temp = numbers[i];            //假如temp比前面的值小，则将前面的值后移            for (j = i; j > 0 && temp < numbers[j - 1]; j--) {                numbers[j] = numbers[j - 1];            }            numbers[j] = temp;        }    }    /**     * 选择排序算法     * 在未排序序列中找到最小元素，存放到排序序列的起始位置     * 再从剩余未排序元素中继续寻找最小元素，而后放到排序序列末尾。     * 以此类推，直到全部元素均排序完毕。     *     * @param numbers     */    public static void selectSort(int[] numbers) {        int size = numbers.length; //数组长度        for (int i = 0; i < size; i++) {            int k = i;   //待肯定的位置            //选择出应该在第i个位置的数            for (int j = size - 1; j > i; j--) {                if (numbers[j] < numbers[k]) {                    k = j;                }            }            //交换两个数            numbers[i] ^= numbers[k];            numbers[k] ^= numbers[i];            numbers[i] ^= numbers[k];        }    }    /**     * 快速排序的基本思想：     * 经过一趟排序将待排序记录分割成独立的两部分，其中一部分记录的关键字均比另外一部分关键字小，     * 则分别对这两部分继续进行排序，直到整个序列有序。     * 快速排序的示例：     * （a）一趟排序的过程：     * （b）排序的全过程     * 把整个序列看作一个数组，把第零个位置看作中轴，和最后一个比，若是比它小交换，比它大不作任何处理；     * 交换了之后再和小的那端比，比它小不交换，比他大交换。这样循环往复，一趟排序完成，左边就是比中轴小的，     * 右边就是比中轴大的，而后再用分治法，分别对这两个独立的数组进行排序。     */    public static void sort(int arr[], int low, int high) {        int l = low;        int h = high;        int k = arr[low];        while (l < h) {            // 从后往前比较            while (l < h && arr[h] >= k) { // 若是没有比关键值小的，比较下一个，直到有比关键值小的交换位置，而后又从前日后比较                h--;// h=6            }            if (l < h) {                int temp = arr[h];                arr[h] = arr[l];                arr[l] = temp;                //进行过一次替换后，不必将替换后的两值再次比较，因此i++直接下一位与k对比                l++;            }            // 从前日后比较            while (l < h && arr[l] <= k) { // 若是没有比关键值大的，比较下一个，直到有比关键值大的交换位置                l++;            }            if (l < h) {                int temp = arr[h];                arr[h] = arr[l];                arr[l] = temp;                h--;            }            // 此时第一次循环比较结束，关键值的位置已经肯定了。左边的值都比关键值小，右边的值都比关键值大，可是两边的顺序还有多是不同的，进行下面的递归调用        }        print(arr);        System.out.print("low =" + (l + 1) + ", high = " + (h + 1) + ", k=" + k + "\n");        // 递归        if (l > low)//先判断l>low再次经行左边排序            sort(arr, low, l - 1);// 左边序列。第一个索引位置到关键值索引-1        if (h < high)//左边依次排序执行完递归后，弹栈进行右边排序            sort(arr, l + 1, high);// 右边序列。从关键值索引+1到最后一个    }    // 打印数组的方法    private static void print(int[] arr) {        System.out.print("[");        for (int i = 0; i < arr.length; i++) {            if (i != (arr.length - 1)) {                System.out.print(arr[i] + ",");            } else {                System.out.print(arr[i] + "]");                System.out.println();            }        }    }    /**     * 冒泡排序     * 比较相邻的元素。若是第一个比第二个大，就交换他们两个。     * 对每一对相邻元素做一样的工做，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。     * 针对全部的元素重复以上的步骤，除了最后一个。     * 持续每次对愈来愈少的元素重复上面的步骤，直到没有任何一对数字须要比较。     *     * @param numbers 须要排序的整型数组     */    public static void bubbleSort(int[] numbers) {        int temp = 0;        int size = numbers.length;        for (int i = 0; i < size - 1; i++) {            for (int j = 0; j < size - 1 - i; j++) {                if (numbers[j] > numbers[j + 1])  //交换两数位置                {                    temp = numbers[j];                    numbers[j] = numbers[j + 1];                    numbers[j + 1] = temp;                }            }        }    }}