【Java】实现各种排序算法

绿丰不绿

已于 2022-08-27 16:12:25 修改

阅读量329

点赞数

分类专栏： Java 文章标签： java 排序算法算法

于 2022-08-27 11:40:19 首次发布

本文链接：https://blog.csdn.net/m0_57680308/article/details/126243154

版权

Java 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

交换函数

    public static void swap(int[] array, int index1, int index2){
        int tmp = array[index1];
        array[index1] = array[index2];
        array[index2] = tmp;
    }

直接插入排序

时间复杂度：O(n^2) ,空间复杂度O(1),稳定

    //直接插入排序 升序
    public void insertSort(int[] array){
        for(int i = 1; i < array.length ; i++){
            int tmp = array[i];
            int j = i-1;
            for(; j >= 0; j--){
                if(array[j] > tmp){
                    array[j+1] = array[j];  //将大于tmp的数后移
                }else{
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

希尔排序

缩小增量算法

时间复杂度：O(N^1.5) ,空间复杂度O(1),不稳定

    //希尔排序
    public void shellSort(int[] array){
        int gap = array.length;

        while(gap >= 1){
            for(int i = gap; i < array.length ; i++){
                int tmp = array[i];
                int j = i-gap;

                while(j >= 0){
                    if(array[j] > tmp){
                        array[j+gap] = array[j];
                    }else{
                        break;
                    }
                    j -= gap;
                }
                array[j+gap] = tmp;
            }
            gap /= 2;
        }
    }

选择排序

时间复杂度：O(N^2) ,空间复杂度O(1),不稳定

    //直接选择排序
    public void selectSort(int[] array){
        for(int i = 0; i < array.length ; i++){
            int index = i;
            for(int j = i+1 ; j < array.length; j++){
                //寻找最小值
                if(array[j] < array[index]){
                    index = j;
                }
            }
            if(array[i] != array[index]){
                swap(array,i,index);
            }
        }
    }

选择排序优化：

在遍历的时候，同时找到最小值和最大值，减少遍历次数

    //直接选择排序优化
    public void selectSort2(int[] array){
        int left = 0;
        int right = array.length-1;
        while(left < right){
            int minIndex = left;
            int maxIndex = right;
            for(int j = left+1; j < right ; j++){
                if(array[j] < array[minIndex]){
                    minIndex = j;
                }
                if(array[j] > array[maxIndex]){
                    maxIndex = j;
                }
            }
            if(array[left] != array[minIndex]){
                swap(array,minIndex,left);
            }
            if(array[right] != array[maxIndex]){
                swap(array,maxIndex,right);
            }
            left++;
            right--;
        }
    }

冒泡排序

时间复杂度：O(N^2) ,空间复杂度O(1),稳定

    //冒泡排序
    public void bubbleSort(int[] array){
        for(int i = 0 ; i < array.length ; i++){
            boolean flag = true;
            for(int j = 0;j < array.length-i-1 ; j++){
                if(array[j] > array[j+1]){
                    swap(array,j,j+1);
                    flag = false;
                }
            }
            //flag为true则说明已经有序
            if(flag){
                break;
            }
        }
    }

堆排序

时间复杂度：O(N*logN) ,空间复杂度O(1),不稳定

    /**
     * 堆排序
     * 创建大根堆，然后将堆顶元素往后放
     */
    public void heapSort(int[] array){
        createBigHeap(array);
        int last = array.length-1;

        while(last >= 0){
            swap(array,last,0);
            shiftDown(array,0,last);
            last--;
        }

    }

    //创建大根堆
    public void createBigHeap(int[] array){
        for(int parent = (array.length-1-1)/2; parent >= 0; parent--){
            shiftDown(array,parent,array.length);
        }
    }

    //向下调整
    public void shiftDown(int[] array,int root,int end){
        int child = root*2 + 1;

        while(child < end){
            if(child+1 < end && array[child+1] > array[child]){
                child++;
            }
            if(array[child] > array[root]){
                swap(array,child,root);

            }else{
                break;
            }
            root = child;
            child = root*2 + 1;
        }
    }

快速排序

时间复杂度：O(N*logN) ,空间复杂度O(log(N))~O(N),不稳定

递归：

    public void quickSort(int[] array,int left,int right){
        if(left < right){
            int pivot = partitionPointer2(array,left,right);

            quickSort(array,left,pivot-1);        //递归左边部分
            quickSort(array,pivot+1,right); //递归右边部分
        }
    }

pivot为基准值下标，partition为拆分方法