排序算法

排序算法

在这里插入图片描述

1、冒泡排序(Bubble Sort)

1.1 排序原理

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

在这里插入图片描述

1.2 算法描述

  • 比较相邻的元素。如果第一个比第二个大,就交换它们两个;
  • 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,这样在最后的元素应该会是最大的数;
  • 针对所有的元素重复以上的步骤,除了最后一个;
  • 重复步骤1~3,直到排序完成。

1.3 动图演示

在这里插入图片描述

1.4 代码实现

public class BubbleSort {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序前:" + Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    public static void bubbleSort(int[] arr) {
        int len = arr.length;
        boolean flag = true;   // 是否排好序的标志
        for (int i = 0; i < len - 1; i++) {
            for (int j = 0; j < len - 1 - i; j++) {
                flag = false;   // 说明没有排好序
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            // 如果排好序,跳出循环
            if (flag) {
                break;
            }
        }
    }
}

2、选择排序(Selection Sort)

2.1 排序原理

首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。

在这里插入图片描述

2.2 算法描述

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下:

  • 初始状态:无序区为R[1…n],有序区为空;
  • 第i趟排序(i=1,2,3…n-1)开始时,当前有序区和无序区分别为R[1…i-1]和R(i…n)。该趟排序从当前无序区中-选出关键字最小的记录 R[k],将它与无序区的第1个记录R交换,使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区;
  • n-1趟结束,数组有序化了。

2.3 动图演示

在这里插入图片描述

2.4 代码实现

public class SelectionSort {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序前:" + Arrays.toString(arr));
        selectionSort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    public static void selectionSort(int[] arr) {
        int len = arr.length;
        int minIndex;
        for (int i = 0; i < len - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                    minIndex = j;                 // 将最小数的索引保存
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

2.5 算法分析

表现最稳定的排序算法之一,因为无论什么数据进去都是O(n2)的时间复杂度,所以用到它的时候,数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲,选择排序可能也是平时排序一般人想到的最多的排序方法了吧。

3、插入排序(Insertion Sort)

插入排序(Insertion-Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列(把所有的元素分为两组,已排序的和未排序的),对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

3.1 算法描述

一般来说,插入排序都采用in-place在数组上实现。具体算法描述如下:

  • 从第一个元素开始,该元素可以认为已经被排序;
  • 取出下一个元素,在已经排序的元素序列中从后向前扫描;
  • 如果该元素(已排序)大于新元素,将该元素移到下一位置;
  • 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置;
  • 将新元素插入到该位置后;
  • 重复步骤2~5。

3.2 动图演示

在这里插入图片描述

3.3 代码实现

public class InsertionSort {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序前:" + Arrays.toString(arr));
        insertionSort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    public static void insertionSort(int[] arr) {
        int len = arr.length;
        int preIndex, current;
        for (int i = 1; i < len; i++) {
            preIndex = i - 1;
            current = arr[i];
            while (preIndex >= 0 && arr[preIndex] > current) {
                arr[preIndex + 1] = arr[preIndex];
                preIndex--;
            }
            arr[preIndex + 1] = current;
        }
    }
}

3.4 算法分析

插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

4、希尔排序(Shell Sort)

1959年Shell发明,第一个突破O(n2)的排序算法,是简单插入排序的改进版。它与插入排序的不同之处在于,它会优先比较距离较远的元素。希尔排序又叫缩小增量排序

算法原理:

  1. 选定一个增量gap,按照增量 gap 作为数据分组的依据,对数据进行分组;
  2. 对分好组的每一组数据进行插入排序;
  3. 减小增量,最小减为1,重复第二步操作。

在这里插入图片描述

4.1 算法描述

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序,具体算法描述:

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

4.2 动图演示

在这里插入图片描述

4.3 代码实现

public class ShellSort {

    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序前:" + Arrays.toString(arr));
        shellSort(arr);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    public static void shellSort(int[] arr) {
        int len = arr.length;
        int gap = len / 2;
        while (gap > 0) {
            // 注意:这里和动图演示的不一样,动图是分组执行,实际操作是多个分组交替执行
            for (int i = gap; i < len; i++) {
                int j = i;
                int current = arr[i];
                // j - gap 相当于插入排序中的preIndex
                while (j - gap >= 0 && arr[j - gap] > current) {
                    arr[j] = arr[j - gap];
                    j = j - gap;
                }
                arr[j] = current;
            }
            gap = gap / 2;
        }
    }
}

4.4 算法分析

希尔排序的核心在于间隔序列的设定。既可以提前设定好间隔序列,也可以动态的定义间隔序列。动态定义间隔序列的算法是《算法(第4版)》的合著者Robert Sedgewick提出的。

5、归并排序(Merge Sort)

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

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

5.1 算法描述

  • 把长度为n的输入序列分成两个长度为n/2的子序列;
  • 对这两个子序列分别采用归并排序;
  • 将两个排序好的子序列合并成一个最终的排序序列。

5.2 动图演示

在这里插入图片描述

5.3 代码实现

public class MergeSort {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序前:" + Arrays.toString(arr));
        mergeSort(arr, 0, arr.length - 1);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    /**
     * @param arr
     * @param left  指向数组的头部
     * @param right 指向数组的尾部
     */
    public static void mergeSort(int[] arr, int left, int right) {
        if (left >= right) {
            return;
        }
        // mid 指向数组的中部
        int mid = (left + right) / 2;
        mergeSort(arr, left, mid);    // 左边归并排序,使得左子序列有序
        mergeSort(arr, mid + 1, right); // 右边归并,使得右子序列有序
        merge(arr, left, mid, right);	// 合并
    }


    public static void merge(int[] arr, int left, int mid, int right) {
        int i = left;   // 左序列指针
        int j = mid + 1;    // 右序列指针
        int t = 0;  // 临时数组指针
        int[] temp = new int[right - left + 1];
        while (i <= mid && j <= right) {
            if (arr[i] <= arr[j]) {
                // 如果当前元素左序列较小,将左序列元素放入临时数组
                temp[t++] = arr[i++];
            } else {
                // 如果当前元素右序列较小,将右序列元素放入临时数组
                temp[t++] = arr[j++];
            }
        }
        // 将左序列剩余元素填充进 temp 中
        while (i <= mid) {
            temp[t++] = arr[i++];
        }
        // 将右序列剩余元素填充进 temp 中
        while (j <= right) {
            temp[t++] = arr[j++];
        }
        t = 0;
        // 将 temp 中的元素全部拷贝到原数组中
        while (left <= right) {
            arr[left++] = temp[t++];
        }
    }
}

5.4 算法分析

归并排序是一种稳定的排序方法。和选择排序一样,归并排序的性能不受输入数据的影响,但表现比选择排序好的多,因为始终都是O(nlogn)的时间复杂度。代价是需要额外的内存空间。

6、快速排序(Quick Sort)

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

排序原理:

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

6.1 算法描述

快速排序使用分治法来把一个串(list)分为两个子串(sub-lists)。具体算法描述如下:

  • 从数列中挑出一个元素,称为 “基准”(pivot);
  • 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区退出之后,该基准就处于数列的中间位置。这个称为分区(partition)操作;
  • 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

6.2 动图演示

在这里插入图片描述

6.3 代码实现

public class QuickSort {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        System.out.println("排序前:" + Arrays.toString(arr));
        quickSort(arr, 0, arr.length - 1);
        System.out.println("排序后:" + Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) {
        int i = left;
        int j = right;
        if (i < j) {    // 划分长度大于等于2,即 i < j
            int pivot = arr[i]; // 选取左端为基准点
            while (i < j) {
                // 当 i < j 并且 右边元素大于等于基准点时,j--
                // 主要是找到右边小于基准点的元素,然后把它移到基准点左边
                while (i < j && arr[j] >= pivot) j--;
                // 发现小于基准点的元素,将其替换到右半区
                if (i < j) arr[i] = arr[j];
                // 当 i < j 并且 左边元素小于基准点时,i++
                // 主要是找到左边大于基准点的元素,然后把它移到基准点右边
                while (i < j && arr[i] < pivot) i++;
                // 发现大于基准点的元素,将其替换到右半区
                if (i < j) arr[j] = arr[i];
            }
            // 在i和j重合处放基准点
            // 数据平衡,循环里有一个数据是直接被覆盖的,就是基准,现在将其添加回数组中
            arr[i] = pivot;
            quickSort(arr, left, i);
            quickSort(arr, i + 1, right);
        }
    }
}
发布了23 篇原创文章 · 获赞 0 · 访问量 121
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 数字20 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览