数据结构排序算法

最新推荐文章于 2025-02-18 14:00:05 发布

xiaotiaoza

最新推荐文章于 2025-02-18 14:00:05 发布

阅读量606

点赞数 29

分类专栏：数据结构和算法文章标签：排序算法数据结构算法

本文链接：https://blog.youkuaiyun.com/xiaotiaoza/article/details/137955952

版权

数据结构和算法专栏收录该内容

2 篇文章

订阅专栏

一. 简单排序

1. 冒泡排序

排序原理:

1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
1. 对每一对相邻元素做同样的工作,从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。

import java.util.Arrays;

/**
 * 冒泡排序
 *  1. 比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
 *  2. 对每一对相邻元素做同样的工作,从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。
 *
 *  需求：
 *  排序前：{4,5,6,3,2,1}
 *  排序后：{1,2,3,4,5,6,}
 */
public class BubbleSort {
    public static void main(String[] args) {
        Integer[] arr = {4,5,6,3,2,1};
        bubble(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    public static void bubble(Integer[] arr){
        for (int i = arr.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (arr[j] > arr[j+1]){
                    Integer x = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = x;
                }
            }
        }
    }
}

冒泡排序的时间复杂度为O(N^2)，稳定排序算法

2. 选择排序

排序原理:

1. 每一次谝历的过程中，都假定第一个索引处的元素是最小值,和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引。
1. 交换第一个索引处和最小值所在的索引处的值。

import java.util.Arrays;

/**
 * 选择排序
 * 1. 每一次谝历的过程中，都假定第一个索引处的元素是最小值,和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引。
 * 2. 交换第一个索引处和最小值所在的索引处的值。
 *
 * 需求：
 * 排序前：{4,6,8,7,9,2,10,1}
 * 排序后：{1,2,4,6,7,8,9,10}
 */
public class SelectSort {
    public static void main(String[] args) {
        Integer[] arr = {4,6,8,7,9,2,10,1};
        select(arr);
        System.out.println(Arrays.toString(arr));
    }


    public static void select(Integer[] arr){
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;  // 假设最小索引
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[minIndex] > arr[j]){
                    minIndex = j; // 交换索引
                }
            }
            // 交换元素
            int x = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = x;
        }
    }
}

选择排序的时间复杂度为O(N^2)，不稳定排序算法

3. 插入排序

排序原理:

1. 把所有的元素分为两组，已经排序的和未排序的;
1. 找到未排序的组中的第一个元素，向已经排序的组中进行插入;
1. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素,那么就把待插入元素放到这个位置，其他的元素向后移动一位;

import java.util.Arrays;

/**
 * 插入排序
 *  - 1. 把所有的元素分为两组，已经排序的和未排序的;
 *  - 2. 找到未排序的组中的第一个元素，向已经排序的组中进行插入;
 *  - 3. 倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素,那么就把待插入元素放到这个位置，其他的元素向后移动一位;
 *
 *  需求：
 *  排序前： {4,3,2,10,12,1,5,6,3}
 *  排序后： {1,2,3,3,4,5,6,10,12}
 */
public class InsertSort {
    public static void main(String[] args) {
        Integer[] arr = {4,3,2,10,12,1,5,6,3};
        insert(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void insert(Integer[] arr){
        for (int i = 1; i < arr.length; i++) {
            // 当前元素为a[i],依次和i前面的元素比较，找到一个小于等于a[i]的元素
            for (int j = i; j > 0; j--) {
                if (arr[j-1] > arr[j]){
                    // 交换元素
                    int x = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = x;
                }else {
                    break; // 如果当前元素大于前一个元素，直接结束循环
                }
            }
        }
    }
}

插入排序的时间复杂度为O(N^2)，稳定排序算法

二. 高级排序

1. 希尔排序

希尔排序是插入排序的一种，又称“缩小增量排序”,是插入排序算法的一种更高效的改进版本。

排序原理：

1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
1. 对分好组的每一组数据完成插入排序；
1. 减小增长量，最小减为1，重复第二步操作。

import java.util.Arrays;

/**
 * 希尔排序
 *  - 1. 选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
 *  - 2. 对分好组的每一组数据完成插入排序；
 *  - 3. 减小增长量，最小减为1，重复第二步操作。
 *
 *  需求：
 *  排序前： {9,1,2,5,7,4,8,12,6,3,5}
 *  排序后： {1,2,3,4,5,5,6,7,8,9,12}
 *
 */
public class ShellSort {
    public static void main(String[] args) {
        Integer[] arr =  {9,1,2,5,7,4,8,12,6,3,5};
        shell(arr);
        System.out.println(Arrays.toString(arr));
    }

    public static void shell(Integer[] arr){
        int length = arr.length;
        int h = 1;
        // 计算增长量h最大值
        while (h < length / 2){
            h = 2 * h + 1;
        }
        System.out.println(h);
        // 当增长量小于1，排序结束
        while (h >= 1){
            for (int i = h; i < length; i++) {
                // a[i]是待插入元素，将a[i]插入到a[i-h],a[i-2h],a[i-3h]...序列中
                for (int j = i; j >= h; j-=h) {
                    if (arr[j-h] > arr[j]){
                        int x = arr[j];
                        arr[j] = arr[j-h];
                        arr[j-h] = x;
                    }else {
                        break;
                    }
                }
            }
            h /= 2;
        }
    }
}

希尔排序是不稳定排序算法

2. 归并排序

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列:即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

排序原理:

1. 将一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止；
1. 将相邻的两个子组进行合并成一个有序的大组；
1. 不断的重复步骤2，直到最终只有一个组为止。

import java.util.Arrays;

/**
 * 归并排序
 *  - 1. 将一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子组的元素个数是1为止；
 *  - 2. 将相邻的两个子组进行合并成一个有序的大组；
 *  - 3. 不断的重复步骤2，直到最终只有一个组为止。
 *
 *  需求：
 *  排序前：{8,4,5,7,1,3,6,2}
 *  排序后：{1,2,3,4,5,6,7,8}
 */
public class MergeSort {
    public static Integer[] assist;  // 辅助数组
    public static void main(String[] args) {
        Integer[] arr = {8,4,5,7,1,3,6,2};
        assist = new Integer[arr.length];
        int start = 0;  // 起始位置
        int end = arr.length - 1; // 结束位置
        sort(arr,start,end);
        System.out.println(Arrays.toString(assist));
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 先进行排序，再进行合并
     * @param arr
     */
    public static void sort(Integer[] arr,int start, int end){
        // 如果结束位置小于等于起始位置，程序结束
        if (end <= start){
            return;
        }
        // 计算中间位置
        int middle = start + (end - start) / 2;
        // 对起始位置到中间位置的元素分组
        sort(arr,start,middle);
        // 对中间位置到结束位置的元素分组
        sort(arr,middle + 1, end);
        // 对起始位置到中间位置 和 中间位置到结束位置的 两组数据进行合并
        merge(arr,start,middle,end);
    }

    /**
     * 将 start 到 middle 这组数据和 middle+1 到 end 这组数据归并到辅助数组assist对应的索引处
     * @param arr
     * @param start
     * @param middle
     * @param end
     */
    public static void merge(Integer[] arr, int start, int middle, int end){
        System.out.println(Arrays.toString(arr));
        System.out.println(start);
        System.out.println(middle);
        System.out.println(end);
        System.out.println("===========================");
        int i = start; // 定义一个指针，指向 assist 辅助数组开始填充数据的索引处
        int p1 = start; // 定义一个指针，指向 start 到 middle 这组数据的第一个元素
        int p2 = middle+1; // 定义一个指针，指向 middle+1 到 end 这组数据的第一个元素

        // 比较两个小组的元素大小，将元素小的填充到辅助数组中
        while (p1 <= middle && p2 <= end){
            if (arr[p1] > arr[p2]){
                assist[i++] = arr[p2++];
            }else {
                assist[i++] = arr[p1++];
            }
        }

        /**
         * 上面的循环结束后，如果退出循环的条件是p1<=mid,则证明左边小组中的数据已经归并完毕，如果退出循环的条件是p2<=hi,则证明右边小组的数据已经填充完毕;
         * 所以需要把未填充完毕的数据继续填充到assist中
         */
        while (p1 <= middle){
            assist[i++] = arr[p1++];
        }
        while (p2 <= end){
            assist[i++] = arr[p2++];
        }

        // 辅助数组从 start 到 end 之间元素都是有序的，拷贝到原数组处
        for (int index = start; index <= end; index++) {
            arr[index] = assist[index];
        }
    }
}

归并排序的时间复杂度为0(nlogn)，稳定排序算法

3. 快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

排序原理:

1. 首先设定一个分界值，通过该分界值将数组分成左右两部分；
1. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值;
1. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
1. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

快速排序

切分原理: 把一个数组切分成两个子数组的基本思想
1.找一个基准值，用两个指针分别指向数组的头部和尾部;
2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置
3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置
4.交换当前左边指针位置和右边指针位置的元素
5.重复2,3,4步骤，直到左边指针的值大于右边指针的值停止。

import java.util.Arrays;

/**
 * 快速排序
 *  - 1. 首先设定一个分界值，通过该分界值将数组分成左右两部分；
 *  - 2. 将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值;
 *  - 3. 然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
 *  - 4. 重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
 *
 *  需求：
 *  排序前： {6,1,2,7,9,3,4,5,8,7}
 *  排序后： {1,2,3,4,5,6,7,7,8,9}
 */
public class QuickSort {
    public static void main(String[] args) {
        Integer[] arr = {6,1,2,7,9,3,4,5,8,7};
        int start = 0;  // 起始索引
        int end = arr.length - 1; // 结束索引
        sort(arr,start,end);
        System.out.println(Arrays.toString(arr));
    }

    public static void sort(Integer[] arr, int start, int end){
        // 如果结束索引小于等于起始索引,结束排序
        if (end <= start){
            return;
        }
        int quick = quick(arr, start, end);
        // 对左边分组的元素进行排序
        sort(arr,start,quick-1);
        // 对右边分组的元素进行排序
        sort(arr,quick+1,end);
    }

    /**
     * > 切分原理: 把一个数组切分成两个子数组的基本思想
     * 1.找一个基准值，用两个指针分别指向数组的头部和尾部;
     * 2.先从尾部向头部开始搜索一个比基准值小的元素，搜索到即停止，并记录指针的位置
     * 3.再从头部向尾部开始搜索一个比基准值大的元素，搜索到即停止，并记录指针的位置
     * 4.交换当前左边指针位置和右边指针位置的元素
     * 5.重复2,3,4步骤，直到左边指针的值大于右边指针的值停止
     * @param arr
     * @param start
     * @param end
     * @return
     */
    public static int quick(Integer[] arr, int start, int end){
        int key = arr[start]; // 把最左边的元素当基准值
        int left = start; // 定义一个左侧指针，初始指向最左边元素
        int right = end + 1; // 定义一个右侧指针，初始指向最右边的下一个元素

        while (true){
            // 先从右往左扫描，找到一个比基准小的元素
            while (key < arr[--right]){
                // 已经扫描到最左边，无需再扫描
                if (right == start){
                    break;
                }
            }

            // 再从左往右扫描，找到一个比基准大的元素
            while (key > arr[++left]){
                // 已经扫描到最右边，无需再扫描
                if (left == end){
                    break;
                }
            }

            if (left >= right){
                break; // 扫描完所有元素，结束循环
            }else {
                // 交换 left 和 right 索引处的元素
                int x = arr[right];
                arr[right] = arr[left];
                arr[left] = x;
            }
        }

        // 交换最后 right 索引处和基准值所在索引处的元素
        int x = arr[right];
        arr[right] = arr[start];
        arr[start] = x;

        return right;
    }
}

快速排序和归并排序的区别：
快速排序是另外一种分治的排序算法，它将一个数组分成两个子数组,将两部分独立的排序。快速排序和归并排序是互补的:归并排序将数组分成两个子数组分别排序，并将有序的子数组归并从而将整个数组排序，而快速排序的方式则是当两个数组都有序时，整个数组自然就有序了。在归并排序中，一个数组被等分为两半，归并调用发生在处理整个数组之前，在快速排序中，切分数组的位置取决于数组的内容,递归调用发生在处理整个数组之后。