基础的排序算法_JAVA【学习笔记】

---

部分素材来自网络，若不小心影响到您的利益，请联系博主删除。

---

• 学习视频：https://www.bilibili.com/video/BV1iJ411E7xW
• 课程配套资料：https://pan.baidu.com/s/1wxKSQw8exCdqFek-VDrSPg（提取码：jkg9）

---

• 写这篇博客旨在制作笔记，方便个人在线阅览，巩固知识。无他用。
• 博客的内容主要来自上述视频中的内容和其资料中提供的学习笔记。

---

---

0.自定义工具类

---

首先创建一个工具类（封装后面这些常用的方法），之后再研究排序算法

public class Utils {
    // 比较 v 元素是否大于 w 元素
    // v 元素大于 w 元素，即返回 true。否则返回 false
    static boolean greater(Comparable v, Comparable w) {
        return v.compareTo(w) > 0;
    }

	// 判断 v 是否小于 w
    static boolean less(Comparable v, Comparable w) {
        return v.compareTo(w) < 0;
    }

    // 交换 a 数组中，索引 i 和索引 j 处的值
    static void exchange(Comparable[] a, int i, int j) {
        Comparable temp;
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

---

1.冒泡排序

---

排序原理

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

---

public class BubbleSort {
	// 对数组 a 中的元素进行排序（从小到大排序）
    public static void sort(Comparable[] a) {
        for (int i = a.length - 1; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (greater(a[j], a[j + 1])) {
                    exchange(a, j, j + 1);
                }
            }
        }
    }
}

---

2.选择排序

---

排序原理

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

---

public class SelectSort {
	// 对数组 a 中的元素进行排序（从小到大排序）
    public static void sort(Comparable[] a) {
        for (int i = 0; i < a.length - 1; i++) {
            int minIndex = i;
            
            for (int j = i + 1; j < a.length; j++) {
                if (greater(a[minIndex], a[j])) {
                    minIndex = j; // 找到最小值的索引
                }
            }

            exchange(a, minIndex, i);
        }
    }
}

---

3.插入排序

---

排序原理

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

---

public class InsertSort {
    // 对数组 a 中的元素进行排序（从小到大排序）
    public static void sort(Comparable[] a) {
    	// 当前元素 a[i]，依次和 i 前面的元素比较，找到一个小于等于 a[i] 的元素
        for (int i = 1; i < a.length; i++) {
            for (int j = i; j > 0; j--) {
                if (greater(a[j - 1], a[j])) {
                    exchange(a, j - 1, j);
                } else {
                    break;
                }
            }
        }
    }
}

---

4.希尔排序

---

排序原理

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

---

间隙值 gap 的确定：间隙值 gap 遵循着固定的规则

我们这里采用以下规则

int gap = 1;

// 这里的 a 是数组，若它的长度是 10 的话
while(gap < a.length / 2){ 
	gap = 2 * gap + 1；// 3, 7
}
// 循环结束后我们就可以确定 gap 的最大值了

// gap 的减小规则如下
gap= gap / 2

---

public class ShellSort {
    public static void sort(Comparable[] a) {
        int gap = 1;
        while (gap < a.length / 2) {
            gap = gap * 2 + 1;
        }

        while (gap >= 1) {
            for (int i = gap; i < a.length; i++) {
                for (int j = i; j >= gap; j -= gap) {
                    if (greater(a[j - gap], a[j])) {
                        exchange(a, j - gap, j);
                    } else {
                        break;
                    }
                }
            }
            gap = gap / 2;
        }
    }
}

---

5.归并排序

---

归并排序是建立在归并操作上的一种有效的排序算法，该算法是采用 分治法 的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

若将两个有序表合并成一个有序表，称为二路归并。

---

排序原理

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

---

归并排序 API 设计

类名	MergeSort
成员方法	1. public static void sort(Comparable[] a)：对数组内的元素进行排序 2. private static void sort(Comparable[] a, int low, int high)：     对数组 a 中从索引 low 到索引 high 之间的元素进行排序 3. private static void merge(Comparable[] a, int low, int midth, int high)：     从索引 low 到索引 middle 为一个子组，从索引 middle + 1 到索引 high 为另一个子组，     把数组 a 中的这两个子组的数据合并成一个有序的大组（从索引 low 到索引 high）
成员变量	private static Comparable[] assist：完成归并操作需要的辅助数组

---

public class MergeSort {
    private static Comparable[] assist;

    public static void sort(Comparable[] a) {
        assist = new Comparable[a.length];
        int low = 0;
        int high = a.length - 1;
        sort(a, low, high);
    }

    private static void sort(Comparable[] a, int low, int high) {
        if (high <= low) {
            return;
        }

        int middle = (low + high) >>> 1;

        sort(a, low, middle);
        sort(a, middle + 1, high);
        merge(a, low, middle, high);
    }

    private static void merge(Comparable[] a, int low, int middle, int high) {
        int index = low, left = low, right = middle + 1;

        while (left <= middle && right <= high) {
            if (less(a[left], a[right])) {
                assist[index++] = a[left++];
            } else {
                assist[index++] = a[right++];
            }
        }

		// 下面两个循环只会执行一个循环
        while (left <= middle) {
            assist[index++] = a[left++];
        }
        while (right <= high) {
            assist[index++] = a[right++];
        }

        for (int tmp = low; tmp <= high; tmp++) {
            a[tmp] = assist[tmp];
        }
    }
}

---

6.快速排序

---

快速排序是对冒泡排序的一种改进。

---

基本思想

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

---

排序原理

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

---

快速排序API设计

类名	QuickSort
成员方法	1. public static void sort(Comparable[] a)：对数组内的元素进行排序 2. private static void sort(Comparable[] a, int low, int high)：     对数组 a 中从索引 low 到索引 high 之间的元素进行排序 3. public static int partition(Comparable[] a, int low, int high)：     对数组 a 中，从索引 low 到索引 high 之间的元素进行分组，并返回分组界限对应的索引

---

切分原理 把一个数组切分成两个子数组的基本思想：

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

---

public class QuickSort {
    public static void sort(Comparable[] a) {
        int low = 0;
        int high = a.length - 1;
        sort(a, low, high);
    }

    private static void sort(Comparable[] a, int low, int high) {
        if (high <= low) {
            return;
        }

        int partition = partition(a, low, high);
        sort(a, low, partition - 1);
        sort(a, partition + 1, high);
    }

    public static int partition(Comparable[] a, int low, int high) {
        int left = low;
        int right = high + 1;

        while (true) {
            while (less(a[low], a[--right])) {
                if (right == low) {
                    break;
                }
            }

            while (less(a[low], a[++left])) {
                if (left == high) {
                    break;
                }
            }

            if (left >= right) {
                break; // 扫描完毕，结束循环
            } else {
                exchange(a, left, right);
            }
        }
        exchange(a, low, right);
        return right;
    }
}

---

快速排序 和 归并排序 的区别：

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

---

常见排序算法的稳定性：

• 稳定的排序算法：冒泡排序、插入排序、归并排序
• 不稳定的排序算法：选择排序、希尔排序、快速排序

---