数据结构之排序算法快速入门

最新推荐文章于 2024-05-22 10:59:33 发布

Zzz禧

最新推荐文章于 2024-05-22 10:59:33 发布

阅读量134

点赞数

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

本文链接：https://blog.csdn.net/weixin_40550892/article/details/105376508

版权

数据结构专栏收录该内容

0 篇文章 0 订阅

订阅专栏

排序算法总结

冒泡排序

1、百度百科介绍

冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。

2、算法描述

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

3、代码演示

/**
 * 冒泡排序
 *
 * @author: Mr.Z
 * @create: 2020-04-08 10:43
 */
public class BubbleSort {

    public static void main(String[] args) {
        int[] arrays = {9, 5, 7, 6, 3, 4, 2, 1, 8};
        System.out.println("排序前--->" + Arrays.toString(arrays));
        arrays = sort(arrays);
        System.out.println("排序后--->" + Arrays.toString(arrays));
    }

    static int[] sort(int[] arrays) {
        //装载临时变量
        int temp;

        //记录是否发生了置换，0 表示没有发生置换、1 表示发生了置换
        int isChange;

        //记录执行了多少趟
        int num = 0;

        //外层循环是排序的趟数
        for (int i = 0; i < arrays.length - 1; i++) {

            //每比较一趟就重新初始化为0
            isChange = 0;

            //内层循环是当前趟数需要比较的次数
            for (int j = 0; j < arrays.length - i - 1; j++) {
                if (arrays[j] > arrays[j + 1]) {
                    temp = arrays[j];
                    arrays[j] = arrays[j + 1];
                    arrays[j + 1] = temp;

                    //如果进到这里面了，说明发生了置换
                    isChange = 1;
                }
            }
            //如果比较完一趟没有发生置换，那么说明已经排好序了，不需要再执行下去了
            if (isChange == 0) {
                break;
            }
            num++;
        }
        System.out.println("执行了 " + num + " 次");
        return arrays;
    }
}

选择排序

1、百度百科介绍

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

2、算法描述

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾
重复第二步，直到所有元素均排序完毕

3、代码演示

/**
 * 选择排序
 *
 * @author: Mr.Z
 * @create: 2020-04-08 11:01
 */
public class SelectionSort {

    public static void main(String[] args) {
        int[] arr = {5, 3, 6, 8, 1, 7, 9, 4, 2};
        System.out.println("排序前--->" + Arrays.toString(arr));
        arr = sort(arr);
        System.out.println("排序后--->" + Arrays.toString(arr));
    }

    static int[] sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            //假设最小值的下标从i开始
            int minPos = i;
            //将 arr[minPos] 与后面的值进行比较，若小于 arr[minPos]，将j赋予minPos
            for (int j = i + 1; j < arr.length; j++) {
                minPos = arr[j] < arr[minPos] ? j : minPos;
            }
            //交换
            if (minPos != i) {
                int temp = arr[i];
                arr[i] = arr[minPos];
                arr[minPos] = temp;
            }
        }
        return arr;
    }
}

插入排序

1、百度百科介绍

插入排序，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。
插入排序是一种最简单的排序方法，它的基本思想是将一个记录插入到已经排好序的有序表中，从而一个新的、记录数增1的有序表。在其实现过程使用双层循环，外层循环对除了第一个元素之外的所有元素，内层循环对当前元素前面有序表进行待插入位置查找，并进行移动。

2、算法描述

将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面

3、代码演示

/**
 * 插入排序
 *
 * @author: Mr.Z
 * @create: 2020-04-08 11:41
 */
public class InsertionSort {

    public static void main(String[] args) {
        int[] arr = {9, 3, 1, 4, 6, 8, 7, 5, 2};
        System.out.println("排序前--->" + Arrays.toString(arr));
        arr = sort(arr);
        System.out.println("排序后--->" + Arrays.toString(arr));
    }

    static int[] sort(int[] arr) {
        int temp;
        //假定第一个有序，从第二个开始，后面的与前面进行比较，若小于，交换位置往前插入
        for (int i = 1; i < arr.length; i++) {
            for (int j = i; j > 0; j--) {
                if (arr[j] < arr[j - 1]) {
                    temp = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = temp;
                }
            }
        }
        return arr;
    }
}

希尔排序

1、百度百科介绍

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

2、算法描述

选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1
按增量序列个数 k，对序列进行 k 趟排序
每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度

3、代码演示

/**
 * 希尔排序
 *
 * @author: Mr.Z
 * @create: 2020-04-08 14:16
 */
public class ShellSort {

    public static void main(String[] args) {
        int[] arr = {9, 6, 11, 3, 5, 12, 8, 7, 10, 15, 14, 4, 1, 13, 2};
        System.out.println("排序前--->" + Arrays.toString(arr));
        arr = sort(arr);
        System.out.println("排序后--->" + Arrays.toString(arr));
    }

    static int[] sort(int[] arr) {
        int temp = 0;
        //Knuth序列比/2效率要高
        /**
         * h=1
         * h=3*h+1
         */
        int h = 1;
        while (h <= arr.length / 3) {
            h = h * 3 + 1;
        }
        for (int gap = h; gap > 0; gap = (gap - 1) / 3) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i; j > gap - 1; j -= gap) {
                    if (arr[j] < arr[j - gap]) {
                        temp = arr[j];
                        arr[j] = arr[j - gap];
                        arr[j - gap] = temp;
                    }
                }
            }
        }
        return arr;
    }
}

归并排序

1、百度百科介绍

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。归并排序是一种稳定的排序方法。

2、算法描述

申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
设定两个指针，最初位置分别为两个已经排序序列的起始位置
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
重复步骤3直到某一指针达到序列尾
将另一序列剩下的所有元素直接复制到合并序列尾

3、代码演示

/**
 * 归并排序
 *
 * @author: Mr.Z
 * @create: 2020-04-08 14:59
 */
public class MergeSort {

    public static void main(String[] args) {
        int[] arr = {1, 4, 7, 8, 3, 6, 9};
        System.out.println("排序前--->" + Arrays.toString(arr));
        arr = sort(arr, 0, arr.length - 1);
        System.out.println("排序后--->" + Arrays.toString(arr));
    }

    static int[] sort(int[] arr, int left, int right) {
        //如果只有一个元素，就不用排序
        if (left == right) return arr;
        //分成两半，去中间的数
        int mid = left + (right - left) / 2;//避免 left+right 越界
        //左边排序
        sort(arr, left, mid);
        //右边排序，right指最后一个元素
        sort(arr, mid + 1, right);
        arr = merge(arr, left, mid + 1, right);
        return arr;
    }

    static int[] merge(int[] arr, int leftPtr, int rightPtr, int rightBound) {
        int mid = rightPtr - 1;

        //开辟新数组的空间
        int[] temp = new int[rightBound - leftPtr + 1];

        int i = leftPtr;//左指针
        int j = rightPtr;//右指针
        int k = 0;

        //满足条件，进行比较并插入到temp中
        while (i <= mid && j <= rightBound) {
            temp[k++] = arr[i] <= arr[j] ? arr[i++] : arr[j++];
        }

        //当左右两边有一边已经排完时，将剩下的插入到temp数组中
        while (i <= mid) temp[k++] = arr[i++];
        while (j <= rightBound) temp[k++] = arr[j++];

        for (int m = 0; m < temp.length; m++) arr[leftPtr + m] = temp[m];
        return arr;
    }
}

快速排序

1、百度百科介绍

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

2、算法描述

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

3、代码演示

/**
 * 快速排序
 *
 * @author: Mr.Z
 * @create: 2020-04-08 16:14
 */
public class QuickSort {

    public static void main(String[] args) {
        int[] arr = {9, 6, 11, 3, 5, 12, 8, 7, 10, 15, 14, 4, 1, 13, 2};
        System.out.println("排序前--->" + Arrays.toString(arr));
        sort(arr, 0, arr.length - 1);
        System.out.println("排序后--->" + Arrays.toString(arr));
    }

    static void sort(int[] arr, int leftBound, int rightBound) {
        if (leftBound >= rightBound) return;
        int mid = partition(arr, leftBound, rightBound);
        sort(arr, leftBound, mid - 1);
        sort(arr, mid + 1, rightBound);
    }

    static int partition(int[] arr, int leftBound, int rightBound) {
        int temp;

        int pivot = arr[rightBound];
        int left = leftBound;
        int right = rightBound - 1;

        while (left <= right) {
            while (left <= right && arr[left] <= pivot) left++;
            while (left <= right && arr[right] > pivot) right--;

//            System.out.println("before swap: left->" + left + " right->" + right);

            //交换
            if (left < right) {
                temp = arr[left];
                arr[left] = arr[right];
                arr[right] = temp;
            }

//            System.out.println("--" + Arrays.toString(arr));
//            System.out.println();
        }

        temp = arr[left];
        arr[left] = arr[rightBound];
        arr[rightBound] = temp;

        return left;
    }
}

Zzz禧

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
数据结构之排序算法快速入门

冒泡排序1、百度百科介绍冒泡排序（Bubble Sort），是一种计算机科学领域的较简单的排序算法。它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小、首字母从Z到A）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳...
复制链接

扫一扫