排序算法-合集

冒泡排序

 //冒泡排序
    public static int[] optimizedBubbleSort(int[] array) {
        //参数合法性的判断
        if (array == null || array.length == 0) {
            return null;
        }
        //冒泡的趟数
        for (int i = 0; i < array.length - 1; i++) {
            boolean flag = false;
            //一趟冒泡的过程
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    int tmp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = tmp;
                    flag = true;
                }
            }
            if (!flag) {
                break;
            }
        }return array;
    }

选择排序

    //选择排序
    public static void optimizedSelectSort(int[] array){
        if(array == null || array.length == 0){
            return;
        }
        for(int i=0; i<array.length/2; i++){
            int minIndex = i;
            int maxIndex = i;
            for(int j=i+1; j<=array.length-1-i; j++){
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
                if(array[j] > array[maxIndex]){
                    maxIndex = j;
                }
            }

            //minIndex指向的最小值与第一个值进行交换
            int tmp = array[minIndex];
            array[minIndex] = array[i];
            array[i] = tmp;

            //如果最大的元素下标是i，上一步交换了min和i的值，
            //max应该是min的下标
            if(maxIndex == i){
                maxIndex = minIndex;
            }

            //maxIndex指向的最大值与最后一个值进行交换
            tmp = array[maxIndex];
            array[maxIndex] = array[array.length-1-i];
            array[array.length-1-i] = tmp;
        }
    }

插入排序

//    插入排序
    public static void insertSort(int[] array){
        if(array == null || array.length == 0){
            return;
        }
        //时间复杂度 O(N^2) 空间复杂度O(1)
        //稳定
        for(int i=1; i<array.length; i++) {
            int tmp = array[i]; //拿到的牌
            int j =i-1;
            //找数据
            for (; j>0; j--) {

                if (array[j] >tmp) {
                    break;
                }else{
                    array[j]=array[j-1];
                }
            }
        }
    }

希尔排序

 //Shell sort希尔排序
    public static void shellSort(int[] array){
        int gap=array.length;
        while (gap>=1){
        gap=gap/2;
            for(int i=gap; i<array.length; i++){
                int tmp = array[i];
                //在组内从后往前找比tmp小的数据
                int j;
                for(j=i-gap; j>=0; j-=gap){
                    if(array[j] <= tmp){
                        break;
                    }else{
                        array[j+gap] = array[j];
                    }
                }
                array[j+gap] = tmp;
            }

        }
    }

快排

 //快排
    public static void quickSort(int[] array, int low, int high){
        if(low<high){
        //完成一次划分的过程
        int mar = array[low];
        int start=low;
        int end=high;
        //一次划分的循环过程
        while(low < high){
            //从后往前找比基准小的元素
            while(low < high && array[high] >= mar){
                //1 2 3 4
                high--;
            }
            //跳出上面while循环
            //low == high 基准的右边都比大了
            if(low == high){
                break;
            }
            //array[high] < mar 此时high指向的元素就是所要找的小于基准的元素
            array[low] = array[high];
            //从前往后找比基准大的元素
            while(low < high && array[low] <= mar){
                low++;
            }
            //跳出上面while循环
            //low == high 基准的左边都比小了
            if(low == high){
                break;
            }
            //array[low] > mar 此时low指向的元素就是所要找的比基准大的元素
            array[high] = array[low];
        }
        array[low] = mar;
            quickSort(array,start,low);
            quickSort(array,low+1,end);
        }
    }

归并排序

    //归并排序
    //一次分组排序
    public static void merge(int[] arr,int left,int mid,int right,int[] arr2){
        int i=left;
        int j=mid+1;
        int z=0;
        //排序并放入arr【】中存放
        while(i<=mid&&j<=right){
            if(arr[i]<arr[j]){
                arr2[z++]=arr[i++];
            }else{
                arr2[z++]=arr[j++];
            }
        }
        //将未放入的元素放入到arr2【】中
        while (i<=mid){
            arr2[z++]=arr[i++];
        }
        while(j<=right){
            arr2[z++]=arr[j++];
        }
        for (int k=left,g = 0;k<=right;g++) {
            arr[k++]=arr2[g];
        }
    }
    //实现分组
    public static void mergeShell(int[] arr,int left,int right,int[] arr2){
        if(left<right){
            int mid=(left+right)/2;
            mergeShell(arr,left,mid,arr2);
            mergeShell(arr,mid+1,right,arr2);
            merge(arr,left,mid,right,arr2);
        }
    }

堆排序

   public static void adjust(int[] array, int start, int end){
        //start表示要调整树的根节点
        int tmp = array[start];
        //找左右 孩子的最大值
        for(int i=2*start+1; i<=end; i=2*i+1){
            //判断是否有右孩子
            if(i+1 <= end && array[i] < array[i+1]){
                i++;//i指向左右孩子的最大值
            }
            if(array[i] > tmp){
                //需要将array[i]换到start位置
                array[start] = array[i];
                start = i; //更新start，保存当前最大孩子的下标
            }else{
                break;
            }
        }
        array[start] = tmp;
    }
    public static void headSort(int[] array){
        if(array == null || array.length == 0){
            return;
        }
        //i初始化为最后一个叶子节点所在子树的根节点
        //经过for循环之后发现当前序列所对应的堆是大根堆
        for(int i=(array.length-1-1)/2; i>=0 ;i--){
            adjust(array, i, array.length-1);
        }
        for(int i=0; i<array.length; i++){
            //相当于将根节点(待排序列的最大值)换到待排序列的最后
            int tmp = array[0];
            array[0] = array[array.length-1-i];
            array[array.length-1-i] = tmp;

            adjust(array, 0, array.length-1-i-1);
        }
    }