七种常见排序算法

一、插入排序

    ——直接插入排序

private void insertSort(int[] data) {
        for(int i=1;i<data.length;i++){
            int tmp=data[i];
            int j=i-1;
            for(;j>=0&&data[j]>tmp;j--){//将大于tmp的值整体往后移一个单位
                data[j+1]=data[j];
            }
            data[j+1]=tmp;

        }
        System.out.println(Arrays.toString(data));
    }

    ——希尔排序

    public void shellSort(int[] data){
        double d1=data.length;
        while (true){
            d1= (int) Math.ceil(d1/2);
            int d= (int) d1;
            for(int i=0;i<d;i++){
                for(int j = i+d; j<data.length; j+=d){
                    int tmp=data[j];
                    int k=j-d;
                    for(;k>=0 && data[k]>tmp;k-=d){
                        data[k+d]=data[k];
                    }
                    data[k+d]=tmp;
                }
            }
            if(d==1){
                break;
            }
        }

        System.out.println(Arrays.toString(data));
    }

二、选择排序

    ——简单选择排序

private void selectSort(int[] data) {
        for(int i=0;i<data.length-1;i++){
            int tmp=data[i];//假设第i个最小，记录其值
            int position=i;//假设第i个最小，记录其下标
            for(int j=i+1;j<data.length;j++){
                if(data[j]<tmp){
                    tmp=data[j];//更新最小的数，并记录下标和值
                    position=j;
                }
            }
            data[position]=data[i];//position处放原来在i处的数
            data[i]=tmp;//第i个位置放最小的数
        }
        System.out.println(Arrays.toString(data));
    }

    ——堆排序

 public void heapSort(int[] a){
        int lastIndex=a.length-1;
        System.out.println("开始构建堆");
        for(int i=(lastIndex-1)/2;i>=0;i--){
            adjustDown(a,i,a.length-1);
        }
        System.out.println("初始最大堆"+Arrays.toString(a));
        //将堆顶元素与最后一个元素进行交换，从堆顶开始向下调整
        for(int i=0;i<a.length-1;i++){
            swap(a,0,a.length-1-i);
            System.out.println("第"+(i+1)+"次交换"+Arrays.toString(a));
            adjustDown(a,0,a.length-2-i);
            System.out.println("调整后："+Arrays.toString(a));

        }

    }
//the second method，不需要交换，只做移动和标记
    private void adjustDown(int[] a, int start, int end) {
        int tmp=a[start];
        while (2*start+1<=end){
            int biggerIndex=2*start+1;
            if(2*start+2<=end){
                if(a[biggerIndex]<a[biggerIndex+1]){
                    biggerIndex++;
                }

            }
            if(tmp>=a[biggerIndex])
                break;
            else {
                a[start]=a[biggerIndex];
                start=biggerIndex;
            }

        }
        a[start]=tmp;
    }

三、交换排序

    ——冒泡排序

public void bubbleSort(int[] data){
        for(int i=0;i<data.length-1;i++){
            for(int j=0;j<data.length-1-i;j++){
                if(data[j]>data[j+1]){
                    int tmp=data[j];
                    data[j]=data[j+1];
                    data[j+1]=tmp;
                }
            }
        }
    }

    ——快速排序

public void quickSort(int[] data,int left,int right){
        if(left<right){
            int pivotpos=partition(data,left,right);
            quickSort(data,left,pivotpos-1);
            quickSort(data,pivotpos+1,right);

        }

    }
    private int partition(int[] data, int low, int high) {
        int pivot=data[low]; //待排序的第一个元素作为基准元素
        while (low<high){
            while (low<high&&data[high]>=pivot){
                high--;//从右往左扫描，找到第一个比基准元素小的元素
            }
            data[low]=data[high];//找到这种元素arr[high]后与arr[low]交换
            while (low<high&&data[low]<=pivot){
                low++;//从左往右扫描，找到第一个比基准元素大的元素
            }
            data[high]=data[low];//找到这种元素arr[low]后，与arr[high]交换
        }
        data[low]=pivot;//基准元素归位,low/high都一样
        return low;

    }

四、归并排序

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

    }
    private void merge(int[] data, int low, int mid, int high) {
        int[] datac= Arrays.copyOf(data,data.length);
        int k=low;
        int i=low;
        int j=mid+1;
        while (i<=mid&&j<=high){
            if(datac[i]<=datac[j]){
                data[k++]=datac[i++];
            }else {
                data[k++]=datac[j++];
            }
        }
        while (i<=mid){
            data[k++]=datac[i++];
        }
        while (j<=high){
            data[k++]=datac[j++];
        }
    }