Java 基础算法之排序算法

冒泡排序(稳定)

时间复杂度：
平均:O(n^2)
最好情况:O(n)
最坏情况:O(n^2)

public void bubbleSort(int[] array){
        /*
        冒泡排序

        比较相邻的元素。如果第一个比第二个大，就交换他们两个。

        对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

        针对所有的元素重复以上的步骤，除了最后一个。

        时间复杂度(O(n^2))
        */
        for (int i = 0; i < array.length-1; i++) {
            for (int j = 0; j < array.length-1; j++) {
                if (array[j] > array[j+1]){
                    int temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                }
            }
        }
    }

---

选择排序(不稳定)

时间复杂度：
平均:O(n^2)
最好情况:O(n^2)
最坏情况:O(n^2)

public void selectionSort(int[] array){
//        选择排序
//
//        首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
//
//        再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
//
//        重复第二步，直到所有元素均排序完毕。

        for (int i = 0; i < array.length-1; i++) {
            //min是本轮循环的最小值
            int min = i;
            for (int j = i+1; j < array.length; j++) {
                if (array[j] < array[min]){
                    //更新最小值的下标
                    min = j;
                }
            }
            //把第i位置和min位置的元素交换位置
            int temp = array[min];
            array[min] = array[i];
            array[i] = temp;
        }
    }

---

插入排序(稳定)

时间复杂度：
平均:O(n^2)
最好情况:O(n)
最坏情况:O(n^2)

public void insertSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = i; j > 0 ; j--) {
                if (array[j] < array[j-1]){
                    //交换
                    int temp = array[j];
                    array[j] = array[j-1];
                    array[j-1] = temp;
                }
            }
        }
    }

---

希尔排序(不稳定)

时间复杂度：
平均:O(n logn)
最好情况:O(n log^2n)
最坏情况:O(n log^2n)

public void shellSort(int[] array){
//        希尔排序在数组中采用跳跃式分组的策略，通过某个增量将数组元素划分为若干组
//
//        然后分组进行插入排序，随后逐步缩小增量，继续按组进行插入排序操作，直至增量为1。
//
//        希尔排序通过这种策略使得整个数组在初始阶段达到从宏观上看基本有序，小的基本在前，大的基本在后。
//
//        然后缩小增量，到增量为1时，其实多数情况下只需微调即可，不会涉及过多的数据移动。

        //按增量进行分组
        for (int gap = array.length/2; gap >= 1; gap /= 2){
            //遍历分组里的元素,进行选择排序
            for (int i = gap; i < array.length; i++) {
                int j = i;
                while (j - gap >= 0 && array[j] < array[j-gap]){
                    int temp = array[j];
                    array[j] = array[j-gap];
                    array[j-gap] = temp;
                    j -= gap;
                }
            }
        }
    }

---

归并排序(稳定)

时间复杂度：
平均:O(n logn)
最好情况:O(n logn)
最坏情况:O(n logn)

public void mergeSort(int[] array,int l,int r){
        if (l >= r)return;
        int mid = (l+r)>>1;
        //分割数组为子数组
        mergeSort(array,l,mid);
        mergeSort(array,mid+1,r);
        merge(array,l,r,mid);
    }

    public void merge(int[] array,int l,int r,int mid){
        //新建辅助空间,保存排序后的元素
        int[] tempArray = new int[r-l+1];
        //辅助空间的指针
        int index = 0;
        //左右数组的头指针
        int p1 = l,p2 = mid+1;
        while(p1 <= mid && p2 <= r){
            if (array[p1] <= array[p2]){
                tempArray[index++] = array[p1++];
            }else {
                tempArray[index++] = array[p2++];
            }
        }
        //当某一个指针已经走到边界时,说明那个指针指向的值已经是最小值了,把其他还没有放进来的值移动进数组即可
        while (p1 <= mid){
            tempArray[index++] = array[p1++];
        }
        while (p2 <= r){
            tempArray[index++] = array[p2++];
        }

        //把临时数组里的有序元素替换原数组
        for (int i = 0; i < tempArray.length; i++) {
            array[l+i] = tempArray[i];
        }
    }

---

快速排序(不稳定)

时间复杂度：
平均:O(n logn)
最好情况:O(n logn)
最坏情况:O(n^2)

public void fastSort(int array[],int l,int r){

//        快速排序是由冒泡排序改进而得到的，是一种排序执行效率很高的排序算法
//
//        它利用分治法来对待排序序列进行分治排序，它的思想主要是通过一趟排序将待排记录分隔成独立的两部分
//
//        其中的一部分比关键字小，后面一部分比关键字大
//
//        然后再对这前后的两部分分别采用这种方式进行排序，通过递归的运算最终达到整个序列有序。


        //终止条件
        if (l > r)return;
        //基准值
        int pivot = array[l];
        //从后往前找,比基准值小的元素
        int i = l,j = r;
        while (i < j){
            while (i < j && array[j] >= pivot){
                j--;
            }
            while (i < j && array[i] <= pivot){
                i++;
            }
            //交换i,j位置的元素
            if (i < j){
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }else {
                break;
            }
        }
        //完成遍历以后,此时基准值任在l的位置,应该把它移动到中间去,此时它的左边全是比它小的数,右边全是比它大的数
        //而指向中间的值就是j
        array[l] = array[j];
        array[j] = pivot;
        //继续对基准值的左右两边的数组进行交换
        //因为j已经是中间值,所以不需要把他放入数组
        fastSort(array,l,j-1);
        fastSort(array,j+1,r);
    }

---

堆排序(不稳定)

时间复杂度：
平均:O(n logn)
最好情况:O(n logn)
最坏情况:O(n logn)

public void heapSort(int[] arr) {
        int temp = 0;
        //将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
        for (int i = arr.length / 2 - 1; i >= 0; i--) {
            adjustHeap(arr,i,arr.length);
        }
        //将堆顶元素与末尾元素交换。将最大的元素沉到数组末端
        for (int j = arr.length-1; j > 0; j--) {
            temp = arr[j];
            arr[j] = arr[0];
            arr[0] = temp;
            //重新调整结构，使其满足堆定义，然后继续交换堆顶元素与当前末尾元素，反复执行调整+交换步骤，直到整个序列有序
            adjustHeap(arr,0,j);
        }
    }

    /** 将一个数组（二叉树）调整成一个大顶堆
     * 功能：完成将以i对应的非叶子节点的树调整成大顶堆
     * @param arr 待调整的数组
     * @param i 表示非叶子节点在数组中的索引
     * @param length 表示对多少个元素继续调整，length是在逐渐的减少
     */
    public void adjustHeap(int[] arr,int i, int length) {
        int temp = arr[i]; //取出当前元素的值保存在临时变量
        //k = 2 * i + 1是i节点的左子节点
        for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {
            if(k + 1 < length && arr[k] < arr[k + 1]) { //说明左子节点的值小于右子节点的值
                k++; //k指向右子节点
            }
            if(arr[k] > temp) { //如果子节点大于父节点
                arr[i] = arr[k]; //把较大的值赋给当前节点
                i = k; //i指向k继续比较
            } else {
                break;
            }
        }
        //当for循环结束后，我们已经将以i为父节点的树的最大值，放在了最顶（局部）
        arr[i] = temp; //将temp的值放到调整后的位置
    }