Java数据结构之基于比较的排序算法基本原理及具体实现

public static void insertSort(int[] arr){
        for(int i=1;i<arr.length;i++){//从第二个元素开始，遍历整个数组
            int j=i-1;//i之前的序列 已经有序
            int temp=arr[i];
            for(;j>=0;j--){//此循环用于寻找插入位置
                if(arr[j]>temp){//此时逐个向后移动元素
                    arr[j+1]=arr[j];
                }else break;//找到插入位置 直接break
            }
            arr[j+1]=temp;//直接插入
        }
}

public static void hell(int[] arr,int gap){//当gap=1时 其实就是直接插入排序
        for(int i=gap;i<arr.length;i++){
            int j=i-gap;
            int temp=arr[i];
            for(;j>=0;j-=gap){
                if(arr[j]>temp){
                    arr[j+gap]=arr[j];
                }else break;
            }
            arr[j+gap]=temp;
        }
}
public static void hellSort(int[] arr){
        int gap=arr.length;
        while(gap>1){
            gap=gap/2+1;
            hell(arr,gap);
        }
    }

public static void selectSort(int[] arr){
        for(int i=0;i<arr.length;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    int temp=arr[j];
                    arr[j]=arr[i];
                    arr[i]=temp;
                }
            }
      }
}

public static void heapSort(int[] arr){//排序方法
        creatHeap(arr);
        int end=arr.length-1;
    //因为是大根堆，所以根节点值为最大值，根节点与最后一个节点值交换 输出并删除此时最后一个节点，然后向下调整根节点
        while(end>0){
            int temp=arr[0];
            arr[0]=arr[end];
            arr[end]=temp;
            shiftDown(arr,0,end);
            end--;
        }

    }
public static void creatHeap(int[] arr){//建堆
        for(int parent=(arr.length-1-1)/2;parent>=0;parent--){
            shiftDown(arr,parent,arr.length);
        }
    }
public static void shiftDown(int[]arr,int root,int len){//向下调整操作
        int parent=root;
        int child=parent*2+1;
        while(child<len){
            if(child+1<len&&arr[child]<arr[child+1]){//待调整节点右子树大于左子树
                child++;
            }
            if(arr[child]>arr[parent]){//由于是大根堆，如果儿子节点值大于父亲节点就交换
                int temp=arr[parent];
                arr[parent]=arr[child];
                arr[child]=temp;
                parent=child;//继续向下调整，防止调整后不满足大根堆的条件
                child=parent*2+1;
            }else break;
        }
    }

public static void bubbleSort(int[] arr){
        for(int i=0;i<arr.length-1;i++){//外层循环控制趟数
            boolean flag=false;//一个标记进行优化
            for(int j=0;j<arr.length-1-i;j++){//内层循环控制比较次数
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                    flag=true;
                }
            }
            if(flag==false) break;//如果一趟循环走完没有交换，说明已经有序，直接break
        }
    }

//该代码参考acwing创始人yxc的快排模板
public static void quickSort(int[] arr,int l,int r){
        if(l>=r) return;//每次判断传进来左右下标
        int i=l-1,j=r+1;//因为在循环中，要先i++，j--所以i，j定义为两边界偏移1
        int x=arr[(l+r)/2];//取x为数组中间位置数
        while(i<j){
            do i++;while(arr[i]<x);
            do j--;while(arr[j]>x);
            //此时i指向的数字大于中轴数字， j指向数字小于中轴数字 交换
            if(i<j){
                int temp=arr[i];
                arr[i]=arr[j];
                arr[j]=temp;
            }
        }
        quickSort(arr,l,j);//退出循环是i==j 递归排序
        quickSort(arr,j+1,r);
    }

public static void mergerSort(int[]arr){
        mergerSortInternal(arr,0,arr.length-1);
    }
public static void mergerSortInternal(int[]arr,int l,int r) {//
        if (l >= r) return;
        int mid = (l + r) / 2;//把数组分为两个
        mergerSortInternal(arr, l, mid);//对左边数组递归排序
        mergerSortInternal(arr, mid + 1, r);//对右边数组递归排序
        merge(arr,l,mid,r);//排序完成，进行合并
    }
 public static void merge(int[]arr,int low,int mid,int high){
        int s1=low;//mid左侧数组的头和尾
        int e1=mid;
        int s2=mid+1;//mid右侧数组的头和尾
        int e2=high;
        int[]temp=new int[high-low+1];//定义一个数字，用来合并他们
        int k=0;//指示数组下标
        while(s1<=e1&&s2<=e2){//选出两侧数组最小元素 插入temp数组
            if(arr[s1]<=arr[s2]) temp[k++]=arr[s1++];
            else temp[k++]=arr[s2++];
        }
        while(s1<=e1) temp[k++]=arr[s1++];//如果一侧数组插入完毕，另一侧还有剩余，则全部插入
        while(s2<=e2) temp[k++]=arr[s2++];
        for(int i=0;i<temp.length;i++){//返还到arr数组
            arr[i+low]=temp[i];
        }
    }
}