LeetCode前置课-2-八大排序算法

1、冒泡

//，冒泡
    public static void sortMaopao(){
        int[] arr = {3,9,-1,10,20,1};
        System.out.println("排序前："+ Arrays.toString(arr));
        int temp;
        for(int j=0 ;j<arr.length-1; j++){
            for(int i=0 ; i<arr.length-1; i++){
                if(arr[i]>arr[i+1]){
                    temp=arr[i];
                    arr[i]=arr[i+1];
                    arr[i+1]=temp;
                }
            }
        }
        System.out.println("排序后："+ Arrays.toString(arr));
    }

2、选择排序

//选择排序
    public static  void selectSort(){
        int[] arr = {3,9,-1,10,20,1};
        System.out.println("排序前："+ Arrays.toString(arr));

        for(int i=0; i<arr.length-1; i++){
            int min = arr[i];//假设为最小数
            int minIndex = i;
            for(int j=i+1 ;j<arr.length;j++){//i+1
                if(min>arr[j]){
                    min=arr[j];//最小数
                    minIndex=j;//最小数的下标
                }
            }
            if(minIndex!=i){
                arr[minIndex]=arr[i];
                arr[i]=min;
            }
        }
        System.out.println("排序前："+ Arrays.toString(arr));
    }

3、插入排序

//插入排序
    public static  void insertSort(){
        int[] arr = {3,9,-1,10,20,1};
        System.out.println("排序前："+ Arrays.toString(arr));
        int insertVal;
        int insertIndex;
        for(int i=1 ; i<arr.length; i++){
            insertVal=arr[i];
            insertIndex=i-1;
            //insertIndex>=0保障不越界，等于-1表示找到了最前边,
            //跳出while;insertVal<arr[insertIndex]说明还没有找到合适的位置
            while(insertIndex>=0 && insertVal<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            if(insertIndex+1!=i){
                arr[insertIndex+1]=insertVal;
            }
        }
        System.out.println("排序后："+ Arrays.toString(arr));
    }

4、希尔排序

//希尔排序(一种插入排序，简单增量排序)
    public static void shellSort(){
        int[] arr = {3,9,-1,10,20,1,7,2,0};
        System.out.println("排序前："+ Arrays.toString(arr));
        int size = arr.length;
        for(int gap =size/2 ; gap>0; gap = gap/2){
            for(int i=gap;i<arr.length;i++){//根据gap可以分为多段，比较每一段
                int j= i;
                int temp=arr[j];//暂存第一个要比较的数
                while (j-gap>=0 && temp<arr[j-gap]){//因为每个分组可能有多个值，要依次比较并判断进行交换
                    arr[j]=arr[j-gap];
                    j=j-gap;
                }
                arr[j]=temp;
            }
        }
        System.out.println("排序后："+ Arrays.toString(arr));
    }

5、快速排序

 //快速排序(递归方式)
    public static  void quictSort(int[] arr,int left ,int right){
        int l = left;
        int r = right;
        int pivot = arr[(left+right)/2];
        int temp =0;
        while (l<r){
            while (arr[l]<pivot){//在pivot左边一直找，找到大于pivot的值才退出
                l=l+1;
            }
            while (arr[r]>pivot){
                r=r-1;
            }
            if(l>=r){//说明已经按照左小右大的顺序排列了
                break;
            }
            temp=arr[l];//找到了，进行冒泡交换排序
            arr[l]=arr[r];
            arr[r]=temp;
        }
        if(l==r){//如果l==r,必须l++,r--否则栈溢出
            l=l+1;
            r=r-1;
        }
        if(left<r){
            quictSort(arr,left,r);
        }
        if(right>l){
            quictSort(arr,l,right);
        }
    }

6、归并排序

//归并排序（又叫分治排序）
    public static void mergeSort(int arr[] ,int left, int right , int[] temp){
        if(left<right){
            //分
            int mind = (right+left)/2;
            mergeSort(arr, left, mind, temp);
            mergeSort(arr, mind+1, right, temp);
            //合
            merge(arr, left,mind, right, temp);
        }
    }

 private static void merge(int[] arr, int left, int mind, int right, int[] temp) {
        int i =left;//左边有序序列的初始化索引
        int j = mind+1;//右边有序序列的初始索引
        int t =0;//temp数组当前索引
        //1、左右两个有序序列考进temp
        while (i<=mind && j<=right){
            if(arr[i]<arr[j]){
                temp[t]=arr[i];
                i++;
                t++;
            }else {
                temp[t]=arr[j];
                j++;
                t++;
            }
        }
        //2、左右两个有一个走完了，则把另一个拷进temp
        while (i<=mind){
            temp[t]=arr[i];
            i++;
            t++;
        }
        while (j<=right){
            temp[t]=arr[j];
            j++;
            t++;
        }
        //3将temp数组的元素拷贝到array，注意并不是每次都拷贝所有,
        // 如果有八个，第一次tempLeft=0，right=1;
        //tempLeft=2,right=3;tempLeft0,right3,最后一次tempLeft=0,right=7
        t=0;
        int tempLeft = left;
        while (tempLeft<=right){
            arr[tempLeft]=temp[t];
            t++;
            tempLeft++;
        }
    }

7、基数排序

//基数排序（对桶排序的优化）
    public  static void radixSort(int[] array){
        int max = array[0];//找出最大数
        for(int i=0; i<array.length;i++){
            if(max<array[i]){
                max= array[i];
            }
        }
        int maxLength = (max+"").length();//计算最大数的长度位数
        int bucket[][] = new int[10][array.length];//声明10个桶
        int bucketCount[] = new int[10];//表示每个桶中存放多少个数
        for(int i=0,n=1;i<maxLength;i++,n=n*10){//每一位进行放桶和放回操作
            //放入桶
            for(int j=0;j<array.length;j++){
                int num = array[j]/n%10;//取当前循环位数的数字
                bucket[num][bucketCount[num]]=array[j];
                bucketCount[num]=bucketCount[num]+1;
            }
            //放回数组
            int index =0;
            for(int k=0;k<bucketCount.length;k++){
                if(bucketCount[k]>0){//表示查出有数的桶
                    for(int L =0;L<bucketCount[k];L++){
                        array[index] = bucket[k][L];
                        index++;
                    }
                }
                bucketCount[k]=0;//将拷贝完的重新记为0
            }
        }
    }

8、堆排序，堆排序依赖树

移步查看树部分文章

排序总结：