【Java系列】八大排序算法

‍

今日立春，一年之计从码字开始吧~

今年一定要更加努力呀

一、前言

二、八大排序算法

三、历史文章指路

一、前言

时隔4年，我终于把八大排序算法梳理了一遍，比起大学时零零散散的学习，现在就是一个大规范，当然代码是从优秀小伙伴那里Ctrl+C过来的，就是当我复习了一遍好多年没考过的题吧，哈哈哈。

笔记里还有2018年学习的痕迹，当时还在maopao。

当然要是现杀的话，估计只能现杀maopao，菜…

二、八大排序算法

一、交换排序

1、冒泡排序

2、快速排序

二、插入排序

1、直接插入排序

2、希尔排序

三、选择排序

1、简单选择排序

2、堆排序

四、归并排序

五、基数排序

1、冒泡排序（交换排序）

/*** 冒泡排序：* 比较相邻的元素。如果第一个比第二个大，就交换他们两个。* 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。* 针对所有的元素重复以上的步骤，除了最后一个。* 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。*/
public class BubbleSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");bubbleSort(arr);System.out.printf("排序后：" + Arrays.toString(arr));}public static void bubbleSort(int[] arr) {for (int i = 0; i < arr.length - 1; i++) {for (int j = 0; j < arr.length - 1 - i; j++) {if (arr[j] > arr[j + 1]) {int temp = arr[j];arr[j] = arr[j + 1];arr[j + 1] = temp;}}}}
}

2、快速排序（交换排序）

/*** 快速排序：* 快速排序的核心思想也是分治法，分而治之。* 选取第一个数为基准，将比基准小的数交换到前面，比基准大的数交换到后面，对左右区间重复第二步，直到各区间只有一个数*/
public class QuickSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");quickSort(arr, 0, arr.length - 1);System.out.printf("排序后：" + Arrays.toString(arr));}public static void quickSort(int[] arr, int low, int high) {int i, j, temp, t;if (low > high) {return;}i = low;j = high;//temp就是基准位temp = arr[low];while (i < j) {//从右往左扫描，找到第一个比基准值小的元素while (temp <= arr[j] && i < j) {j--;}//从左往右扫描，找到第一个比基准值大的元素while (temp >= arr[i] && i < j) {i++;}//如果满足条件则交换if (i < j) {t = arr[j];arr[j] = arr[i];arr[i] = t;}}//最后将基准为与i和j相等位置的数字交换arr[low] = arr[i];arr[i] = temp;//递归调用左半数组quickSort(arr, low, j - 1);//递归调用右半数组quickSort(arr, j + 1, high);}
}

3、直接插入排序（插入排序）

/*** 插入排序：* 从第一个元素开始，该元素可以认为已经被排序* 取出下一个元素，在已经排序的元素序列中从后向前扫描* 如果该元素（已排序）大于新元素，将该元素移到下一位置* 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置* 将新元素插入到该位置后* 重复步骤2~5* 插入排序的思想和我们打扑克摸牌的时候一样，从牌堆里一张一张摸起来的牌都是乱序的，我们会把摸起来的牌插入到左手中合适的位置，让左手中的牌时刻保持一个有序的状态。*/
public class InsertSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");insertSort(arr);System.out.printf("排序后：" + Arrays.toString(arr));}public static void insertSort(int[] arr) {for (int i = 1; i < arr.length; i++) {if (arr[i] < arr[i - 1]) {int temp = arr[i];int j; //插入的位置for (j = i - 1; j >= 0 && temp < arr[j]; j--) {arr[j + 1] = arr[j]; //移动数据}arr[j + 1] = temp; //插入数据}}}
}

4、希尔排序（插入排序）

/*** 希尔排序：* 把记录按步长gap分组，对每组记录采用直接插入排序方法进行排序；* 随着步长逐渐减小，所分成的组包含的记录越来越多；* 当步长值减小到1时，整个数据合成一组，构成一组有序记录，完成排序；*/
public class ShellSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");shellSort(arr);System.out.printf("排序后：" + Arrays.toString(arr));}public static void shellSort(int[] arr) {//step:步长for (int step = arr.length / 2; step > 0; step /= 2) {System.out.printf("step：" + step + "\n");//对一个步长区间进行比较 [step,arr.length)for (int i = step; i < arr.length; i++) {int value = arr[i];int j;//对步长区间中具体的元素进行比较for (j = i - step; j >= 0 && arr[j] > value; j -= step) {//j为左区间的取值，j+step为右区间与左区间的对应值arr[j + step] = arr[j];}//此时step为一个负数，[j + step]为左区间上的初始交换值arr[j + step] = value;}}}
}

5、简单选择排序（选择排序）

/*** 选择排序：* 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置* 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾* 以此类推，直到所有元素均排序完毕*/
public class SelectSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");selectsort(arr);System.out.printf("排序后：" + Arrays.toString(arr));}public static void selectsort(int[] arr) {for (int i = 0; i < arr.length; i++) {int min = i; //最小元素的下标for (int j = i + 1; j < arr.length; j++) {if (arr[min] > arr[j]) {min = j; //找最小值}}//交换位置if (i != min) {int temp = arr[i];arr[i] = arr[min];arr[min] = temp;}}}
}

6、堆排序（选择排序）

/*** 堆排序：* 1、根据初始数组构造堆* 2、每次交换第一个和最后一个元素，然后将除最后一个元素以外的其他元素重新调整为大顶堆* 重复以上两个步骤，直到没有元素可操作，就完成排序了。*/
public class HeapSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");heapSort(arr);System.out.printf("排序后：" + Arrays.toString(arr));}/*** 转化为大顶堆* @param arr 待转化的数组* @param size 待调整的区间长度* @param index 结点下标*/public static void maxHeap(int[] arr, int size, int index) {//左子结点int leftNode = 2 * index + 1;//右子结点int rightNode = 2 * index + 2;int max = index;//和两个子结点分别对比，找出最大的结点if (leftNode < size && arr[leftNode] > arr[max]) {max = leftNode;}if (rightNode < size && arr[rightNode] > arr[max]) {max = rightNode;}//交换位置if (max != index) {int temp = arr[index];arr[index] = arr[max];arr[max] = temp;//因为交换位置后有可能使子树不满足大顶堆条件，所以要对子树进行调整maxHeap(arr, size, max);}}public static void heapSort(int[] arr) {//开始位置是最后一个非叶子结点，即最后一个结点的父结点int start = (arr.length - 1) / 2;//调整为大顶堆for (int i = start; i >= 0; i--) {HeapSort.maxHeap(arr, arr.length, i);}//先把数组中第 0 个位置的数和堆中最后一个数交换位置，再把前面的处理为大顶堆for (int i = arr.length - 1; i > 0; i--) {int temp = arr[0];arr[0] = arr[i];arr[i] = temp;maxHeap(arr, i, 0);}}
}

7、归并排序

/*** 归并排序：* 将 n 个元素分成两个各含 n/2 个元素的子序列* 借助递归，两个子序列分别继续进行第一步操作，直到不可再分为止* 此时每一层递归都有两个子序列，再将其合并，作为一个有序的子序列返回上一层，再继续合并，全部完成之后得到的就是一个有序的序列* 关键在于两个子序列应该如何合并。假设两个子序列各自都是有序的，那么合并步骤就是：* 创建一个用于存放结果的临时数组，其长度是两个子序列合并后的长度* 设定两个指针，最初位置分别为两个已经排序序列的起始位置* 比较两个指针所指向的元素，选择相对小的元素放入临时数组，并移动指针到下一位置* 重复步骤 3 直到某一指针达到序列尾* 将另一序列剩下的所有元素直接复制到合并序列尾*/
public class MergeSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");mergeSort(arr, 0, arr.length - 1);System.out.printf("排序后：" + Arrays.toString(arr));}/*** 合并数组*/public static void merge(int[] arr, int low, int middle, int high) {// 用于存储归并后的临时数组int[] temp = new int[high - low + 1];// 记录第一个数组中需要遍历的下标int i = low;// 记录第二个数组中需要遍历的下标int j = middle + 1;// 记录在临时数组中存放的下标int index = 0;// 遍历两个数组，取出小的数字，放入临时数组中while (i <= middle && j <= high) {// 第一个数组的数据更小if (arr[i] <= arr[j]) {// 把更小的数据放入临时数组中temp[index] = arr[i];// 下标向后移动一位i++;} else {temp[index] = arr[j];j++;}index++;}// 处理剩余未比较的数据while (i <= middle) {temp[index] = arr[i];i++;index++;}while (j <= high) {temp[index] = arr[j];j++;index++;}// 把临时数组中的数据重新放入原数组for (int k = 0; k < temp.length; k++) {arr[k + low] = temp[k];}}/*** 归并排序*/public static void mergeSort(int[] arr, int low, int high) {int middle = (high + low) / 2;if (low < high) {// 处理左边数组mergeSort(arr, low, middle);// 处理右边数组mergeSort(arr, middle + 1, high);// 归并merge(arr, low, middle, high);}}
}

8、基数排序

/*** 基数排序：* 基数排序的原理是将整数按位数切割成不同的数字，然后按每个位数分别比较* 为此需要将所有待比较的数值统一为同样的数位长度，数位不足的数在高位补零*/
public class RadixSort {public static void main(String[] args) {int[] arr = new int[]{3, 4, 5, 7, 1, 2, 0, 3, 6, 8};System.out.printf("排序前：" + Arrays.toString(arr) + "\n");radixSort(arr);System.out.printf("排序后：" + Arrays.toString(arr));}/*** 基数排序*/public static void radixSort(int[] arr) {// 存放数组中的最大数字int max = Integer.MIN_VALUE;for (int value : arr) {if (value > max) {max = value;}}// 计算最大数字是几位数int maxLength = (max + "").length();// 用于临时存储数据int[][] temp = new int[10][arr.length];// 用于记录在 temp 中相应的下标存放数字的数量int[] counts = new int[10];// 根据最大长度的数决定比较次数for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {// 每一个数字分别计算余数for (int j = 0; j < arr.length; j++) {// 计算余数int remainder = arr[j] / n % 10;// 把当前遍历的数据放到指定的数组中temp[remainder][counts[remainder]] = arr[j];// 记录数量counts[remainder]++;}// 记录取的元素需要放的位置int index = 0;// 把数字取出来for (int k = 0; k < counts.length; k++) {// 记录数量的数组中当前余数记录的数量不为 0if (counts[k] != 0) {// 循环取出元素for (int l = 0; l < counts[k]; l++) {arr[index] = temp[k][l];// 记录下一个位置index++;}// 把数量置空counts[k] = 0;}}}}
}

相关代码都在Learn-Java，请阅。

https://gitee.com/weimenghua/Learn-Java.git

三、历史文章指路

关注【嘎嘎软件测试】

搞测试，不迷路

呱呱大王本呱带你飞！

嘎嘎软件测试

本账号将分享个人成长、团队管理、软件测试技能知识等内容，更新频率一周两篇，做到有思想、有观点、有深度，欢迎订阅。

【Java系列】八大排序算法相关推荐

精通八大排序算法系列：二、堆排序算法
精通八大排序算法系列:二.堆排序算法作者:July .二零一一年二月二十日本文参考:Introduction To Algorithms,second edition. ------------- ...
八大排序算法的java实现
八大排序算法的java实现有时间再贴算法分析图 JDK7的Collections.sort()的算法是TimSort, 适应性的归并排序, 比较晦涩难懂, 这里没有实现 public class m ...
八大排序:Java实现八大排序及算法复杂度分析
目录 QUESTION:八大排序:Java实现八大排序及算法复杂度分析 ANSWER: 一:冒泡排序 1.算法分析 2.时间复杂度分析 3.代码二:选择排序 1.算法分析 2.时间复杂度分析 3.代 ...
【数据结构排序算法系列】数据结构八大排序算法
排序算法在计算机应用中随处可见,如Windows操作系统的文件管理中会自动对用户创建的文件按照一定的规则排序(这个规则用户可以自定义,默认按照文件名排序)因此熟练掌握各种排序算法是非常重要的,本博客将 ...
八大排序算法（java实现）冒泡排序快速排序堆排序归并排序等
八大排序算法一.直接插入 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度二.希尔排序 - 1.基本思路 - 2.代码实现 - 3.时间复杂度和空间复杂度三.简单选择 - 1. ...
图解八大排序算法——我见过的最详细的讲解（转）
一.分类 1.内部排序和外部排序内部排序:待排序记录存放在计算机随机存储器中(说简单点,就是内存)进行的排序过程. 外部排序:待排序记录的数量很大,以致于内存不能一次容纳全部记录,所以在排序过程中需 ...
C语言八大排序算法，附动图和详细代码解释！
文章来源:电子工程专辑.C语言与程序设计.竹雨听闲一.前言如果说各种编程语言是程序员的招式,那么数据结构和算法就相当于程序员的内功. 想写出精炼.优秀的代码,不通过不断的锤炼,是很难做到的. 二. ...
硬核！C语言八大排序算法，附动图和详细代码解释！
来源 :C语言与程序设计.竹雨听闲等一前言如果说各种编程语言是程序员的招式,那么数据结构和算法就相当于程序员的内功. 想写出精炼.优秀的代码,不通过不断的锤炼,是很难做到的. 二八大排序算法 ...
冒泡和快速排序的时间复杂度_java 八大排序算法冒泡排序快速排序堆排序归并排序等...
八大排序算法一.直接插入 1.基本思路在要排序的一组数中,假设前面(n-1) [n>=2] 个数已经是排好顺序的,现在要把第n个数插到前面的有序数中,使得这n个数也是排好顺序的.如此反复循环 ...
python 排序算法简书_Python---简析八大排序算法
前言 1 .排序的概念排序是计算机内经常进行的一种操作,其目的是将一组"无序"的记录序列调整为"有序"的记录序列. 排序分为内部排序和外部排序. 若整个排序过 ...

【Java系列】八大排序算法

【Java系列】八大排序算法相关推荐

最新文章

热门文章