程序员必须掌握的排序算法

╰+哭是因爲堅強的太久メ 2024-04-17 17:11 69阅读 0赞

# 引言 #

现在的IT行业并不像以前那么好混了，从业人员过多，导致初级程序员过剩，这也间接导致了公司的招聘门槛越来越高，要求程序员掌握的知识也越来越多。  
算法也是一个争论了很久的话题，程序员到底该不该掌握算法？不同的人有不同的答案，而事实上，很多公司都对算法有一定的要求，有些公司直接在面试的时候便会要求面试者手写算法题。这就对程序员的技术要求产生了很大的考验，所以面对如今的大环境，我们必须掌握算法，才能在今后的工作中占据一席之地。  
那么接下来，我就简单介绍一下几个排序算法，希望对你们有所帮助。

### 1.冒泡排序 ###

冒泡排序（Bubble Sort），是一种较简单的排序算法。  
它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素列已经排序完成。  
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端（升序或降序排列），就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”。  
**演示：**  
![在这里插入图片描述][20190816163307192.gif]  
**代码如下：**

@Test
    public void bubbleSort() {
    	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
    	// 统计比较次数
    	int count = 0;
    	// 第一轮比较
    	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;
    			}
    			count++;
    		}
    	}
    	System.out.println(Arrays.toString(arr));
    	System.out.println("一共比较了:" + count + "次");
    }

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    一共比较了:105次

这段代码相信大家都能够写出来，一般冒泡排序也就是这样写。但是这段程序有个缺点，就是当排序过程中已经将数组元素排序完成，但此时它仍然会去比较，这就做了无用功了，所以我们可以通过一个boolean变量来优化这段代，上面的程序中我们已经得出了比较次数为105次。  
优化代码：

@Test
    public void bubbleSort() {
    	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
    	// 统计比较次数
    	int count = 0;
    	for (int i = 0; i < arr.length - 1; i++) {
    		boolean flag = true;
    		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;
    				flag = false;
    			}
    			count++;
    		}
    		if(flag) {
    			break;
    		}
    	}
    	System.out.println(Arrays.toString(arr));
    	System.out.println("一共比较了:" + count + "次");
    }

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]
    一共比较了:95次

我们首先在开始循环时定义了一个boolean变量为true，然后如果元素之间进行了交换，就将值置为false。所以，我们就可以通过这个boolean变量来判断是否有元素进行了交换。如果boolean变量为true，则证明没有元素进行交换，那么久说明此时的数组元素已经完成排序，那么跳出外层循环即可，否则就继续排序。通过结果也可以看出，比较次数确实是减少了很多。

### 2.选择排序 ###

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。  
**演示：**  
![在这里插入图片描述][2019081617014186.gif]  
**代码如下：**

@Test
    public void SelectionSort() {
    	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
    	for (int i = 0; i < arr.length - 1; i++) {
    		int index = i;
    		for (int j = 1 + i; j < arr.length; j++) {
    			if (arr[j] < arr[index]) {
    				index = j;// 保存最小元素的下标
    			}
    		}
    		// 此时已经找到最小元素的下标
    		// 将最小元素与前面的元素交换
    		int temp = arr[index];
    		arr[index] = arr[i];
    		arr[i] = temp;
    	}
    	System.out.println(Arrays.toString(arr));
    }

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

实现也非常的简单，首先在外循环里定义了一个index变量存储i的值，这是为了避免重复地比较，因为在每一轮的比较结束后，前i个元素是已经排好序的，所以无需再次比较，只需从i开始即可。后面的比较都是基于index位置的元素进行比较，倘若比较完后index位置的元素是最小值，那就无需交换，不动即可。而如果找到了比index位置的元素更小的元素，那就将该元素的索引赋值给index，然后继续比较，直到比较完成，比较完成之后得到的index即为数组中的最小值，那此时只需要将index位置的元素和i位置的元素交换即可。

### 3.插入排序 ###

插入排序（Insertion sort）是一种简单直观且稳定的排序算法。如果有一个已经有序的数据序列，要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。插入算法把要排序的数组分成两部分：第一部分包含了这个数组的所有元素，但将最后一个元素除外（让数组多一个空间才有插入的位置），而第二部分就只包含这一个元素（即待插入元素）。在第一部分排序完成后，再将这个最后元素插入到已排好序的第一部分中。  
插入排序的基本思想是：每步将一个待排序的记录，按其关键码值的大小插入到前面已经排序的数组中的适当位置上，直到全部插入完为止。  
**演示：**  
![在这里插入图片描述][20190816173145537.gif]  
**代码如下：**

@Test
    public void InsertionSort() {
    	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
    	for (int i = 1; i < arr.length; i++) {
    		// 定义待插入的数
    		int insertValue = arr[i];
    		// 找到待插入数的前一个数的下标
    		int insertIndex = i - 1;
    		while (insertIndex >= 0 && insertValue < arr[insertIndex]) {
    			arr[insertIndex + 1] = arr[insertIndex];
    			insertIndex--;
    		}
    		arr[insertIndex + 1] = insertValue;
    	}
    	System.out.println(Arrays.toString(arr));
    }

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

那么在这里，因为数组元素我们并不确定，所以只能将数组的第一个元素看成是一个有序的序列，所以从数组的第二个元素开始才是我们需要去寻找插入位置的元素。所以外层循环从1开始，然后将arr\[i\]，也就是当前的第二个元素先保存起来，然后找到待插入元素的前一个元素下标，也就是i-1，此时通过一个while循环去比较。  
当insertIndex小于0时应该退出循环，因为此时已经与前面的所有元素比较完毕。在比较的过程中，如果待插入元素小于前一个元素，就将前一个元素后移，也就是将前一个元素的值直接赋值给待插入元素位置。因为在最开始已经将待插入元素进行了保存，所以只需将待插入元素的值赋值给它的前一个元素即可。因为在while循环中insertIndex执行了自减操作，所以它的前一个元素下标应为insertIndex + 1。而如果待插入的元素值大于前一个元素，那么就不会进入while循环，这样insertIndex + 1之后的位置仍然是自己所在的位置，所以赋值后值不改变，后面的操作以此类推。

### 4.希尔排序 ###

传统的插入排序算法在某些场景中存在着一些问题，例如\[2，3，4，5，1\]这样的一个数组，当我们对其进行插入排序的时候，发现要插入的数字是1，而要想将1插入到最前面，需要经过四个步骤，分别将5、4、3、2后移。所以得出结论：如果较小的数是我们需要进行插入的数，那效率就会比较低。鉴于这种场景的缺陷，希尔排序诞生了，它是插入排序的一种更高效的版本。  
**先看看希尔排序的概念：**  
希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminishing Increment Sort），是直接插入排序算法的一种更高效的改进版本。希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。  
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

**演示：**  
![在这里插入图片描述][2019081714564965.gif]  
动画如果没有看懂，我这里再贴几张静态图：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDUzMTE3_size_16_color_FFFFFF_t_70]  
**代码实现：**

@Test
    public void ShellSort() {
    	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
    	for (int gap = arr.length / 2; gap > 0; gap /= 2) {
    		// 对数组元素进行分组
    		for (int i = gap; i < arr.length; i++) {
    			// 遍历各组中的元素
    			for (int j = i - gap; j >= 0; j -= gap) {
    				// 交换元素
    				if (arr[j] > arr[j + gap]) {
    					int temp = arr[j];
    					arr[j] = arr[j + gap];
    					arr[j + gap] = temp;
    				}
    			}
    		}
    	}
    
    	System.out.println(Arrays.toString(arr));
    }

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

那么在上面的程序段中，数组长度为15，所以在第一轮，数组被分为了15 / 2 = 7个小组，然后分别对每个小组的元素进行遍历。在第一轮中小组之间的元素间隔都为7，所以分成的小组数其实也就是元素之间的间隔。接着就可以对每个小组的元素进行比较，然后进行交换，接下来以此类推。

### 5.快速排序 ###

快速排序（Quicksort）是对冒泡排序的一种改进。  
快速排序由C. A. R. Hoare在1960年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。  
**演示：**  
![在这里插入图片描述][20190823133542776.gif]  
**代码如下：**

public static void quickSort(int[] arr, int left, int right) {
    		int l = left;// 左下标
    		int r = right;// 右下标
    		int pivot = arr[(left + right) / 2];// 找到中间的值
    		// 将比pivot小的值放在其左边，比pivot大的值放在其右边
    		while (l < r) {
    			// 在pivot左边寻找，直至找到大于等于pivot的值才退出
    			while (arr[l] < pivot) {
    				l += 1;// 将l右移一位
    			}
    			// 在pivot右边寻找，直至找到小于等于pivot的值才退出
    			while (arr[r] > pivot) {
    				r -= 1;// 将r左移一位
    			}
    			if (l >= r) {
    				// 左右下标重合，寻找完毕，退出循环
    				break;
    			}
    			// 交换元素
    			int temp = arr[l];
    			arr[l] = arr[r];
    			arr[r] = temp;
    
    			//倘若发现值相等的情况，则没有比较的必要，直接移动下标即可
    		
    			// 如果交换完后，发现arr[l]==pivot，此时应将r左移一位
    			if (arr[l] == pivot) {
    				r -= 1;
    			}
    			// 如果交换完后，发现arr[r]==pivot，此时应将l右移一位
    			if (arr[r] == pivot) {
    				l += 1;
    			}
    		}
    		// 如果l==r，要把这两个下标错开，否则会出现无限递归，导致栈溢出的情况
    		if (l == r) {
    			l += 1;
    			r -= 1;
    		}
    		// 向左递归
    		if (left < r) {
    			quickSort(arr, left, r);
    		}
    		// 向右递归
    		if (right > l) {
    			quickSort(arr, l, right);
    		}
    	}

**测试代码：**

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

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 44, 38, 46, 47, 48, 50]

快速排序的实现原理很简单，就是将原数组分成两部分，然后以中间值为标准，比它小的就放其左边，比它大的就放其右边，然后在左右两边又以相同的方式继续排序。  
所以在代码实现过程中，首先要创建两个移动的变量，一个从最左边开始往右移动，一个从最右边开始往左移动，通过这两个变量来遍历左右两部分的元素。当发现左边有大于中间数的元素，右边有小于中间数的元素，此时就进行交换。当两个变量重合也就是相等的时候遍历结束，然后左右两部分作递归处理。

### 6.归并排序 ###

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。  
**演示：**  
![在这里插入图片描述][20190824151132533.gif]  
归并排序使用了一种分治思想，分治思想的意思就是’分而治之"，就是把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单地直接求解。  
通过这个动图来看的话，相信很多人都一脸懵，没关系，我们通过静态图来分析一下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]  
假设现在有一个待排序的序列，\[5，2，4，7，1，3，2，2\]，那么我们就需要将该序列进行分治，先将其分成两份：\[5，2，4，7\]和\[1，3，2，2\]，再将这两份分别分成两份：\[5，2\]和\[4，7\]；\[1，3\]和\[2，2\]，最后将这四部分再次分别分为两份，最后就将整个序列分为了八份。需要注意的是，在分的过程中，不需要遵循任何规则，关键在于归并，归并的过程中便实现了元素的排序。  
**代码如下：**

public static void mergeSort(int[] arr, int left, int right, int[] temp) {
    		// 分解
    		if (left < right) {
    			int mid = (left + right) / 2;// 中间索引
    			// 向左递归进行分解
    			mergeSort(arr, left, mid, temp);
    			// 向右递归进行分解
    			mergeSort(arr, mid + 1, right, temp);// mid + 1，中间位置的后一个位置才是右边序列的开始位置
    			// 每分解一轮便合并一轮
    			merge(arr, left, right, mid, temp);
    		}
    	}
    
    	/**
    	 * 合并的方法
    	 * 
    	 * @param arr   待排序的数组
    	 * @param left  左边有序序列的初始索引
    	 * @param right 中间索引
    	 * @param mid   右边有序序列的初始索引
    	 * @param temp  做中转的数组
    	 */
    	public static void merge(int[] arr, int left, int right, int mid, int[] temp) {
    		int i = left; // 初始化i，左边有序序列的初始索引
    		int j = mid + 1;// 初始化j，右边有序序列的初始索引(右边有序序列的初始位置即为中间位置的后一个位置)
    		int t = 0;// 指向temp数组的当前索引，初始为0
    		// 先把左右两边的数据(已经有序)按规则填充到temp数组
    		// 直到左右两边的有序序列，有一边处理完成为止
    		while (i <= mid && j <= right) {
    			// 如果左边有序序列的当前元素小于或等于右边有序序列的当前元素，就将左边的元素填充到temp数组中
    			if (arr[i] <= arr[j]) {
    				temp[t] = arr[i];
    				t++;// 索引后移
    				i++;// i后移
    			} else {
    				// 反之，将右边有序序列的当前元素填充到temp数组中
    				temp[t] = arr[j];
    				t++;// 索引后移
    				j++;// j后移
    			}
    		}
    		// 把有剩余数据的一边的元素填充到temp中
    		while (i <= mid) {
    			// 此时说明左边序列还有剩余元素
    			// 全部填充到temp数组
    			temp[t] = arr[i];
    			t++;
    			i++;
    		}
    		while (j <= right) {
    			// 此时说明左边序列还有剩余元素
    			// 全部填充到temp数组
    			temp[t] = arr[j];
    			t++;
    			j++;
    		}
    		// 将temp数组的元素复制到原数组
    		t = 0;
    		int tempLeft = left;
    		while (tempLeft <= right) {
    			arr[tempLeft] = temp[t];
    			t++;
    			tempLeft++;
    		}
    	}

关于归并排序的算法思想确实比较绕，所以我也在代码中写了很多注释。  
我们先来测试一下：

public static void main(String[] args) {
    	int[] arr = { 3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48 };
    	int[] temp = new int[arr.length];
    	mergeSort(arr, 0, arr.length - 1, temp);
    	System.out.println(Arrays.toString(arr));
    }

**运行结果：**

[2, 3, 4, 5, 15, 19, 26, 27, 36, 38, 44, 46, 47, 48, 50]

来分析一下吧，对于该排序算法，有两个部分组成，分解和合并。首先讲讲分解，在前面也说到了，我们需要将待排序的序列不停地进行分解，通过两个索引变量控制，一个初始索引，一个结尾索引。只有当两索引重合才结束分解。此时序列被分解成了十五个小份，这样分解工作就完成了。接下来是合并，合并操作也是最麻烦的，也是通过两个索引变量i，j。开始i在左边序列的第一个位置，j在右边序列的第一个位置，然后就是寻找左右两个序列中的最小值，放到新序列中，这时可能会出现一边的元素都放置完毕了，而另外一边还存在元素，此时只需将剩余的元素按顺序放进新序列即可，因为这时左右两边的序列已经是有序的了，最后将新序列复制到旧序列。这里也特别需要注意，因为合并的过程是分步的，而并非一次合并完成，所以数组的索引是在不断变化的。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]  
自己手动画了个图，左右两个箭头就是索引变量i，j，当i所指的元素也就是1和j所指的元素也就是2进行比较，发现1小，就将1放到新数组的第一个位置，此时应该将i和新数组的索引都右移一位，然后继续比较，以此类推，相信这样大家应该能理解了吧。

### 7.基数排序 ###

基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O(nlog( r )m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法。基数排序是用空间换时间的经典算法。  
**演示：**  
![在这里插入图片描述][20190824161404812.png]  
基数排序的基本思想是：  
将所有待比较的数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序，这样从最低位排序一直到最高位排序完成以后，数列就变为了一个有序序列。  
这样说可能过于抽象，我们通过详细步骤来分析一下：  
我们假设有一个待排序数组\[53，3，542，748，14，214\]，那么如何使用基数排序对其进行排序呢？  
首先我们有这样的十个一维数组，在基数排序中也叫桶。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 2]  
那么第一轮排序开始，我们依次遍历每个元素，并得到元素的个位数。拿到的第一个元素为53，其个位数为3，所以将53放入编号为3的桶中，第二个元素3的个位数也是3，所以也放在编号为3的桶中，而第三个元素542的个位数为2，所以将542放入编号为2的桶中，以此类推。  
所以结果为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 3]  
将元素全部放入桶中之后，我们需要按照桶的顺序(也就是一维数组的下标)依次取出数据，并放回原来的数组。  
那么很简单，按顺序取出数据并放回原数组之后，原数组将变为\[542，53，3，14，214,748\]。  
这样第一轮就完成了，接下来开始第二轮。  
第二轮排序和第一轮类似，也要去遍历数组元素，但不同的是第二轮的存放顺序取决于十位数。  
取出数据的第一个元素为542，十位数为4，所以放入编号为4的桶；第二个元素53，十位数为5，所以放入编号为5的桶；第三个元素3，十位数为0，所以放入编号为0的桶，以此类推。  
所以结果为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 4]  
然后同样按照桶的顺序将数据从中取出并放入原数组，此时原数组变为\[3，14，214，542，748，53\]。  
接下来又进行第三轮排序，以元素的百位数进行区分，结果为：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 5]  
按顺序取出数据后，原数组变为\[3，14，53，214，542，748\]。这时的数组已经完成排序。  
从中我们也可以知道，基数排序的排序轮数取决于数组元素中最大位数的元素。

**代码如下：**

public static void raixSort(int[] arr) {
    		// 第一轮(针对每个元素的个位进行排序处理)
    
    		// 定义一个二维数组，模拟桶，每个桶就是一个一维数组
    		// 为了防止放入数据的时候桶溢出，我们应该尽量将桶的容量设置得大一些
    		int[][] bucket = new int[10][arr.length];
    		// 记录每个桶中实际存放的元素个数
    		// 定义一个一维数组来记录每个桶中每次放入的元素个数
    		int[] bucketElementCounts = new int[10];
    
    		for (int j = 0; j < arr.length; j++) {
    			// 取出每个元素的个位
    			int digitOfElement = arr[j] % 10;
    			// 将元素放入对应的桶中
    			// bucketElementCounts[digitOfElement]就是桶中的元素个数，初始为0，放在第一位
    			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    			// 将桶中的元素个数++
    			// 这样接下来的元素就可以排在前面的元素后面
    			bucketElementCounts[digitOfElement]++;
    		}
    		// 按照桶的顺序取出数据并放回原数组
    		int index = 0;
    		for (int k = 0; k < bucket.length; k++) {
    			// 如果桶中有数据，才取出放回原数组
    			if (bucketElementCounts[k] != 0) {
    				// 说明桶中有数据，对该桶进行遍历
    				for (int l = 0; l < bucketElementCounts[k]; l++) {
    					// 取出元素放回原数组
    					arr[index++] = bucket[k][l];
    				}
    			}
    			// 第一轮处理后，需要将每个bucketElementCounts[k]置0
    			bucketElementCounts[k] = 0;
    		}
    		System.out.println("第一轮:" + Arrays.toString(arr));
    
    		// ----------------------------
    
    		// 第二轮(针对每个元素的十位进行排序处理)
    		for (int j = 0; j < arr.length; j++) {
    			// 取出每个元素的十位
    			int digitOfElement = arr[j] / 10 % 10;
    			// 将元素放入对应的桶中
    			// bucketElementCounts[digitOfElement]就是桶中的元素个数，初始为0，放在第一位
    			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    			// 将桶中的元素个数++
    			// 这样接下来的元素就可以排在前面的元素后面
    			bucketElementCounts[digitOfElement]++;
    		}
    		// 按照桶的顺序取出数据并放回原数组
    		index = 0;
    		for (int k = 0; k < bucket.length; k++) {
    			// 如果桶中有数据，才取出放回原数组
    			if (bucketElementCounts[k] != 0) {
    				// 说明桶中有数据，对该桶进行遍历
    				for (int l = 0; l < bucketElementCounts[k]; l++) {
    					// 取出元素放回原数组
    					arr[index++] = bucket[k][l];
    				}
    			}
    			// 第二轮处理后，需要将每个bucketElementCounts[k]置0
    			bucketElementCounts[k] = 0;
    		}
    		System.out.println("第二轮:" + Arrays.toString(arr));
    
    		// ----------------------------
    
    		// 第三轮(针对每个元素的百位进行排序处理)
    		for (int j = 0; j < arr.length; j++) {
    			// 取出每个元素的百位
    			int digitOfElement = arr[j] / 100 % 10;
    			// 将元素放入对应的桶中
    			// bucketElementCounts[digitOfElement]就是桶中的元素个数，初始为0，放在第一位
    			bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    			// 将桶中的元素个数++
    			// 这样接下来的元素就可以排在前面的元素后面
    			bucketElementCounts[digitOfElement]++;
    		}
    		// 按照桶的顺序取出数据并放回原数组
    		index = 0;
    		for (int k = 0; k < bucket.length; k++) {
    			// 如果桶中有数据，才取出放回原数组
    			if (bucketElementCounts[k] != 0) {
    				// 说明桶中有数据，对该桶进行遍历
    				for (int l = 0; l < bucketElementCounts[k]; l++) {
    					// 取出元素放回原数组
    					arr[index++] = bucket[k][l];
    				}
    			}
    			// 第三轮处理后，需要将每个bucketElementCounts[k]置0
    			bucketElementCounts[k] = 0;
    		}
    		System.out.println("第三轮:" + Arrays.toString(arr));
    	}

为了方便大家理解，这里我并没有使用循环处理，而是详细写出了每一轮的步骤，代码注释也很详细。  
接下来编写测试代码：

public static void main(String[] args) {
    	int[] arr = { 53, 3, 542, 748, 14, 214 };
    	raixSort(arr);
    }

**运行结果：**

第一轮:[542, 53, 3, 14, 214, 748]
    第二轮:[3, 14, 214, 542, 748, 53]
    第三轮:[3, 14, 53, 214, 542, 748]

如果你能够看懂上面的代码，那么接下来就是整合了，通过循环对上面的代码进行优化。  
**代码如下：**

public static void raixSort(int[] arr) {
    		// 得到数组中最大的数
    		int max = arr[0];// 假设第一个数就是数组中的最大数
    		for (int i = 1; i < arr.length; i++) {
    			if (arr[i] > max) {
    				max = arr[i];
    			}
    		}
    		// 得到最大数是几位数
    		// 通过拼接一个空串将其变为字符串进而求得字符串的长度，即为位数
    		int maxLength = (max + "").length();
    
    		// 定义一个二维数组，模拟桶，每个桶就是一个一维数组
    		// 为了防止放入数据的时候桶溢出，我们应该尽量将桶的容量设置得大一些
    		int[][] bucket = new int[10][arr.length];
    		// 记录每个桶中实际存放的元素个数
    		// 定义一个一维数组来记录每个桶中每次放入的元素个数
    		int[] bucketElementCounts = new int[10];
    
    		// 通过变量n帮助取出元素位数上的数
    		for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
    			for (int j = 0; j < arr.length; j++) {
    				// 针对每个元素的位数进行处理
    				int digitOfElement = arr[j] / n % 10;
    				// 将元素放入对应的桶中
    				// bucketElementCounts[digitOfElement]就是桶中的元素个数，初始为0，放在第一位
    				bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
    				// 将桶中的元素个数++
    				// 这样接下来的元素就可以排在前面的元素后面
    				bucketElementCounts[digitOfElement]++;
    			}
    			// 按照桶的顺序取出数据并放回原数组
    			int index = 0;
    			for (int k = 0; k < bucket.length; k++) {
    				// 如果桶中有数据，才取出放回原数组
    				if (bucketElementCounts[k] != 0) {
    					// 说明桶中有数据，对该桶进行遍历
    					for (int l = 0; l < bucketElementCounts[k]; l++) {
    						// 取出元素放回原数组
    						arr[index++] = bucket[k][l];
    					}
    				}
    				// 每轮处理后，需要将每个bucketElementCounts[k]置0
    				bucketElementCounts[k] = 0;
    			}
    		}
    	}

**测试代码：**

public static void main(String[] args) {
    	int[] arr = { 53, 3, 542, 748, 14, 214 };
    	raixSort(arr);
    	System.out.println(Arrays.toString(arr));
    }

**运行结果：**

[3, 14, 53, 214, 542, 748]

这样，基数排序就完成了。大家不要看到代码很多就怕了、烦了，觉得好难，其实也不能说一点难度都没有吧，只是要去理解这个过程，所以对于排序过程的分析我写了很多，也是为了能让你们更加理解，掌握了过程之后，相信理解这些代码也不是难事了。  
**其它：**  
这里说一说基数排序的一些其它内容，为什么单独只说基数排序呢？我们在前面提到了，基数排序是用空间换时间的经典算法，所以基数排序对于元素排序是非常快的。不信我们可以测试一下(先测试八十万个数据的排序时间)：

public static void main(String[] args) {
    		int[] arr = new int[800000];
    		for (int i = 0; i < arr.length; i++) {
    			arr[i] = (int) (Math.random() * 8000000);
    		}
    		Date date = new Date();
    		SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
    		String dateStr = format.format(date);
    		System.out.println("排序前的时间是:" + dateStr);
    		raixSort(arr);
    		Date date2 = new Date();
    		String dateStr2 = format.format(date2);
    		System.out.println("排序前的时间是:" + dateStr2);
    	}

**运行结果：**

排序前的时间是:17:37:21
    排序前的时间是:17:37:21

一秒钟时间不到就完成排序了。  
我们再测试一下八百万个数据的排序：

public static void main(String[] args) {
    		int[] arr = new int[8000000];
    		for (int i = 0; i < arr.length; i++) {
    			arr[i] = (int) (Math.random() * 8000000);
    		}
    		Date date = new Date();
    		SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
    		String dateStr = format.format(date);
    		System.out.println("排序前的时间是:" + dateStr);
    		raixSort(arr);
    		Date date2 = new Date();
    		String dateStr2 = format.format(date2);
    		System.out.println("排序前的时间是:" + dateStr2);
    	}

**运行结果：**

排序前的时间是:17:38:04
    排序前的时间是:17:38:05

只需要一秒钟即完成了排序。  
我们再测试一下八千万个数据的排序：

public static void main(String[] args) {
    		int[] arr = new int[80000000];
    		for (int i = 0; i < arr.length; i++) {
    			arr[i] = (int) (Math.random() * 8000000);
    		}
    		Date date = new Date();
    		SimpleDateFormat format = new SimpleDateFormat("HH:mm:ss");
    		String dateStr = format.format(date);
    		System.out.println("排序前的时间是:" + dateStr);
    		raixSort(arr);
    		Date date2 = new Date();
    		String dateStr2 = format.format(date2);
    		System.out.println("排序前的时间是:" + dateStr2);
    	}

**运行结果：**

排序前的时间是:17:41:07
    Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
    	at com.itcast.sort.RadixSortDemo.raixSort(RadixSortDemo.java:42)
    	at com.itcast.sort.RadixSortDemo.main(RadixSortDemo.java:22)

结果为堆内存溢出，所以在对大量数据进行排序的时候，基数排序显然不是一个好的选择，因为提升排序效率的条件是牺牲大量的内存空间，当数据足够多时，内存空间就不够用了。

### 8.堆排序 ###

待续............

[20190816163307192.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1ab5e161bafd4b14884a8495927ef398.gif
[2019081617014186.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/34d1948612274afe8b72dc4b4940015b.gif
[20190816173145537.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/beffb86c75c543268dc0b64e2edfaf5e.gif
[2019081714564965.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/7d802fe4ec614df9b1c63c49e2d452a5.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQyNDUzMTE3_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/e44e899e68cd4e289a3833db2cd1245f.jpeg
[20190823133542776.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/634740432e7540ea863abbe54b30a807.gif
[20190824151132533.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/f002684360fa4f9ab94d3935ce434e34.gif
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/57ababacf73a4fe0b3be96c2a3183449.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/8f9cd50d6e41499baa3a41477bb7bb0e.png
[20190824161404812.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/1d48f9f16fa64c03a2b76d898fb3c8ff.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/53b4739bd953497294fef32028af311e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/bc86571af3ee4bbdaf2976205ec43eae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/0ebb734d745e455ca5223ca4dc0715bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibGl6emF3YW5nLmJsb2cuY3Nkbi5uZXQ_size_16_color_FFFFFF_t_70 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/17/78283ec7d88047bb8d9d7b5300893107.png