排序

package Day3;

import java.util.Arrays;

public class Sort {
    public static void main (String[] args){
        int[] a={3,1,5,7,2,4,9,6};
        int[] b={6,8,7,9,0,1,3,2,4,5};
        int[] c={5,4,6,3,7,1,2,8};

        //int[] a={3,1,5,7,2,4,9,6,10,4,6};
        //bubbleSort(a);
        //selectSort(a);
        //insertSort(a);
        //shellSort(a);
        quickSort(c,0,c.length-1);
        //System.out.println(Arrays.toString(b));
        //mergeSort(a,0,a.length-1);

/*       for(int i=0;i<a.length-1;i++){
            //建堆
            buildMaxHeap(a,a.length-1-i);
            //交换堆顶和最后一个元素
            swap(a,0,a.length-1-i);
        }

        System.out.println(Arrays.toString(a));*/

    }
    /**
     * 冒泡排序
     * 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
     * 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
     * 针对所有的元素重复以上的步骤，除了最后一个。
     * 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
     */
    public static void bubbleSort(int[] a){
        int temp=0;
        for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(a[j]>a[j+1]){
                    temp=a[j];
                    a[j]=a[j+1];
                    a[j+1]=temp;
                }
            }
        }
    }
    /**
     * 选择排序算法
     * 在未排序序列中找到最小元素，存放到排序序列的起始位置
     * 再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
     * 以此类推，直到所有元素均排序完毕。
     */
    public static void selectSort(int[] a) {
        int temp=0;
        for(int i=0;i<a.length;i++){
            int k=i;//待确定的位置
            for(int j=a.length-1;j>i;j--){
                if(a[j]<a[k]){//选择出应该在第i个位置的数
                    k=j;
                }
            }//交换两个数
            temp=a[i];
            a[i]=a[k];
            a[k]=temp;
        }
    }

    /**
     * 插入排序
     *
     * 从第一个元素开始，该元素可以认为已经被排序
     * 取出下一个元素，在已经排序的元素序列中从后向前扫描
     * 如果该元素（已排序）大于新元素，将该元素移到下一位置
     * 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
     * 将新元素插入到该位置中
     * 重复步骤2
     */
    public static void insertSort(int[] a) {
        int temp = 0 ;
        int j =  0;

        for(int i = 0 ; i <a.length ; i++)
        {
            temp = a[i];
            //假如temp比前面的值小，则将前面的值后移
            for(j = i ; j > 0 && temp < a[j-1] ; j --)
            {
                a[j] = a[j-1];
            }
            a[j] = temp;
        }
    }
    /**希尔排序的原理:根据需求，如果你想要结果从大到小排列，它会首先将数组进行分组，然后将较大值移到前面，较小值
     * 移到后面，最后将整个数组进行插入排序，这样比起一开始就用插入排序减少了数据交换和移动的次数，可以说希尔排序是加强
     * 版的插入排序
     */
    public static void shellSort(int[] a) {
        int j = 0;
        int temp = 0;
        for (int gap = a.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < a.length; i++) {
                temp = a[i];
                for (j = i; j >= gap; j-=gap) {
                    if(temp<a[j-gap]){
                        a[j]=a[j-gap];
                    }else{
                        break;
                    }
                }
                a[j]=temp;
            }
        }
    }
    /**
     * 归并排序
     * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列
     * 时间复杂度为O(nlogn)
     * 稳定排序方式
     */
    public static void mergeSort(int[] a,int low,int high){
        int mid = (low + high) / 2;
        if (low < high) {
            mergeSort(a, low, mid);
            mergeSort(a, mid + 1, high);
            merge(a, low, mid, high);
        }
    }
    public static void merge(int[] a,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 (a[i] < a[j]) {
                temp[k++] = a[i++];
            } else {
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = a[j++];
        }

        // 把新数组中的数覆盖a数组
        for (int k2 = 0; k2 < temp.length; k2++) {
            a[k2 + low] = temp[k2];
        }
    }

    /**
     *
     * 堆排序
     *
     */
    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;
                }
            }
        }
    }
    //交换
    private static void swap(int[] data, int i, int j) {
        int tmp=data[i];
        data[i]=data[j];
        data[j]=tmp;
    }
    public static void quickSort(int[] a,int low,int high){
        if(low<high) {
            int pivotpos = partition(a, low, high);
            quickSort(a, low, pivotpos - 1);
            quickSort(a, pivotpos + 1, high);
        }
    }
    public static int partition(int[] a,int low,int high) {
        int pivot = a[low];
        while (low < high) {
            while (low < high && a[high] > pivot) {
                --high;
            }
            a[low]=a[high];
            while (low < high && a[low] <= pivot) {
                ++low;
            }
            a[high]=a[low];
        }
        a[low]=pivot;
        return low;
    }
    public static void quickSort2(int[] a,int low,int high){
        if (low >= high) {
            return;
        }
        int i=low,j=high;
        int temp=a[i];
        while(i<j) {
            while (i < j && a[j] > temp) {
                j--;
            }
            a[i] = a[j];
            while (i < j && a[i] < temp) {
                i++;
            }
            a[j] = a[i];
        }
        a[i]=temp;
        quickSort2(a,low,i-1);
        quickSort2(a,i+1,high);
    }

}