`
easense2009
  • 浏览: 37539 次
  • 性别: Icon_minigender_1
  • 来自: 重庆
社区版块
存档分类
最新评论

常用排序算法小结（附Java实现）

Java排序算法 
阅读更多

 

常用排序算法小记

排序算法很多地方都会用到，近期又重新看了一遍算法，并自己简单地实现了一遍，特此记录下来，为以后复习留点材料。

废话不多说，下面逐一看看经典的排序算法：

 

1. 选择排序

选择排序的基本思想是遍历数组的过程中，以 i 代表当前需要排序的序号，则需要在剩余的 [i…n-1] 中找出其中的最小值，然后将找到的最小值与 i 指向的值进行交换。因为每一趟确定元素的过程中都会有一个选择最大值的子流程，所以人们形象地称之为选择排序。

举个实例来看看：

初始： [38, 17, 16, 16, 7, 31, 39, 32, 2, 11]

i = 0:  [2 , 17, 16, 16, 7, 31, 39, 32, 38 , 11] (0th [38]<->8th [2])

i = 1:  [2, 7 , 16, 16, 17 , 31, 39, 32, 38, 11] (1st [38]<->4th [17])

i = 2:  [2, 7, 11 , 16, 17, 31, 39, 32, 38, 16 ] (2nd [11]<->9th [16])

i = 3:  [2, 7, 11, 16, 17, 31, 39, 32, 38, 16] ( 无需交换 )

i = 4:  [2, 7, 11, 16, 16 , 31, 39, 32, 38, 17 ] (4th [17]<->9th [16])

i = 5:  [2, 7, 11, 16, 16, 17 , 39, 32, 38, 31 ] (5th [31]<->9th [17])

i = 6:  [2, 7, 11, 16, 16, 17, 31 , 32, 38, 39 ] (6th [39]<->9th [31])

i = 7:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

i = 8:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

i = 9:  [2, 7, 11, 16, 16, 17, 31, 32, 38, 39] ( 无需交换 )

由例子可以看出，选择排序随着排序的进行（ i 逐渐增大），比较的次数会越来越少，但是不论数组初始是否有序，选择排序都会从 i 至数组末尾进行一次选择比较，所以给定长度的数组，选择排序的比较次数是固定的： 1 + 2 + 3 + …. + n = n * (n + 1) / 2 ，而交换的次数则跟初始数组的顺序有关，如果初始数组顺序为随机，则在最坏情况下，数组元素将会交换 n 次，最好的情况下则可能 0 次（数组本身即为有序）。

由此可以推出，选择排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1) （选择排序只需要一个额外空间用于数组元素交换）。

实现代码：

 

	/**
	 * Selection Sorting
	 */
	SELECTION(new Sortable() {
		public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
			int len = array.length;
			for (int i = 0; i < len; i++) {
				int selected = i;
				for (int j = i + 1; j < len; j++) {
					int compare = array[j].compareTo(array[selected]);
					if (compare != 0 && compare < 0 == ascend) {
						selected = j;
					}
				}

				exchange(array, i, selected);
			}
		}
	})

 

 

2. 插入排序

插入排序的基本思想是在遍历数组的过程中，假设在序号 i 之前的元素即 [0..i-1] 都已经排好序，本趟需要找到 i 对应的元素 x 的正确位置 k ，并且在寻找这个位置 k 的过程中逐个将比较过的元素往后移一位，为元素 x “腾位置”，最后将 k 对应的元素值赋为 x ，插入排序也是根据排序的特性来命名的。

以下是一个实例，红色 标记的数字为插入的数字，被划掉的数字是未参与此次排序的元素，红色 标记的数字与被划掉数字之间的元素为逐个向后移动的元素，比如第二趟参与排序的元素为 [11, 31, 12] ，需要插入的元素为 12 ，但是 12 当前并没有处于正确的位置，于是我们需要依次与前面的元素 31 、 11 做比较，一边比较一边移动比较过的元素，直到找到第一个比 12 小的元素 11 时停止比较，此时 31 对应的索引 1 则是 12 需要插入的位置。

初始：    [11, 31, 12, 5, 34, 30, 26, 38, 36, 18]

第一趟： [11, 31 , 12, 5, 34, 30, 26, 38, 36, 18] （无移动的元素）

第二趟： [11, 12 , 31, 5, 34, 30, 26, 38, 36, 18] （ 31 向后移动）

第三趟： [5 , 11, 12, 31, 34, 30, 26, 38, 36, 18] （ 11, 12, 31 皆向后移动）

第四趟： [5, 11, 12, 31, 34 , 30, 26, 38, 36, 18] （无移动的元素）

第五趟： [5, 11, 12, 30 , 31, 34, 26, 38, 36, 18] （ 31, 34 向后移动）

第六趟： [5, 11, 12, 26 , 30, 31, 34, 38, 36, 18] （ 30, 31, 34 向后移动）

第七趟： [5, 11, 12, 26, 30, 31, 34, 38 , 36, 18] （无移动的元素）

第八趟： [5, 11, 12, 26, 30, 31, 34, 36 , 38, 18] （ 38 向后移动）

第九趟： [5, 11, 12, 18 , 26, 30, 31, 34, 36, 38] （ 26, 30, 31, 34, 36, 38 向后移动）

插入排序会优于选择排序，理由是它在排序过程中能够利用前部分数组元素已经排好序的一个优势，有效地减少一些比较的次数，当然这种优势得看数组的初始顺序如何，最坏的情况下（给定的数组恰好为倒序）插入排序需要比较和移动的次数将会等于 1 + 2 + 3… + n = n * (n + 1) / 2 ，这种极端情况下，插入排序的效率甚至比选择排序更差。因此插入排序是一个不稳定的排序方法，插入效率与数组初始顺序息息相关。一般情况下，插入排序的时间复杂度和空间复杂度分别为 O(n2 ) 和 O(1) 。

实现代码：

 

	/**
	 * Insertion Sorting
	 */
	INSERTION(new Sortable() {
		public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
			int len = array.length;
			for (int i = 1; i < len; i++) {
				T toInsert = array[i];
				int j = i;
				for (; j > 0; j--) {
					int compare = array[j - 1].compareTo(toInsert);
					if (compare == 0 || compare < 0 == ascend) {
						break;
					}
					array[j] = array[j - 1];
				}

				array[j] = toInsert;
			}
		}
	})

 

3. 冒泡排序

冒泡排序可以算是最经典的排序算法了，记得小弟上学时最先接触的也就是这个算法了，因为实现方法最简单，两层 for 循环，里层循环中判断相邻两个元素是否逆序，是的话将两个元素交换，外层循环一次，就能将数组中剩下的元素中最小的元素“浮”到最前面，所以称之为冒泡排序。

照例举个简单的实例吧：

初始状态：   [24, 19, 26, 39, 36, 7, 31, 29, 38, 23]

内层第一趟： [24, 19, 26, 39, 36, 7, 31, 29, 23 , 38 ] （ 9th [23]<->8th [38 ）

内层第二趟： [24, 19, 26, 39, 36, 7, 31, 23 , 29 , 38] （ 8th [23]<->7th [29] ）

内层第三趟： [24, 19, 26, 39, 36, 7, 23 , 31 , 29, 38] （ 7th [23]<->6th [31] ）

内层第四趟： [24, 19, 26, 39, 36, 7, 23, 31, 29, 38] （ 7 、 23 都位于正确的顺序，无需交换）

内层第五趟： [24, 19, 26, 39, 7 , 36 , 23, 31, 29, 38] （ 5th [7]<->4th [36] ）

内层第六趟： [24, 19, 26, 7 , 39 , 36, 23, 31, 29, 38] （ 4th [7]<->3rd [39] ）

内层第七趟： [24, 19, 7 , 26 , 39, 36, 23, 31, 29, 38] （ 3rd [7]<->2nd [26] ）

内层第八趟： [24, 7 , 19 , 26, 39, 36, 23, 31, 29, 38] （ 2nd [7]<->1st [19] ）

内层第九趟： [7 , 24 , 19, 26, 39, 36, 23, 31, 29, 38] （ 1st [7]<->0th [24] ）

…...

其实冒泡排序跟选择排序比较相像，比较次数一样，都为 n * (n + 1) / 2 ，但是冒泡排序在挑选最小值的过程中会进行额外的交换（冒泡排序在排序中只要发现相邻元素的顺序不对就会进行交换，与之对应的是选择排序，只会在内层循环比较结束之后根据情况决定是否进行交换），所以在我看来，选择排序属于冒泡排序的改进版。

实现代码：

 

	/**
	 * Bubble Sorting, it's very similar with Insertion Sorting
	 */
	BUBBLE(new Sortable() {
		public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
			int length = array.length;
			int lastExchangedIdx = 0;
			for (int i = 0; i < length; i++) {
				// mark the flag to identity whether exchange happened to false
				boolean isExchanged = false;
				// last compare and exchange happened before reaching index i
				int currOrderedIdx = lastExchangedIdx > i ? lastExchangedIdx : i;
				for (int j = length - 1; j > currOrderedIdx; j--) {
					int compare = array[j - 1].compareTo(array[j]);
					if (compare != 0 && compare > 0 == ascend) {
						exchange(array, j - 1, j);
						isExchanged = true;
						lastExchangedIdx = j;
					}
				}
				// if no exchange happen means array is already in order
				if (isExchanged == false) {
					break;
				}
			}
		}
	})

 

 

4. 希尔排序

希尔排序的诞生是由于插入排序在处理大规模数组的时候会遇到需要移动太多元素的问题。希尔排序的思想是将一个大的数组“分而治之”，划分为若干个小的数组，以 gap 来划分，比如数组 [1, 2, 3, 4, 5, 6, 7, 8] ，如果以 gap = 2 来划分，可以分为 [1, 3, 5, 7] 和 [2, 4, 6, 8] 两个数组（对应的，如 gap = 3 ，则划分的数组为： [1, 4, 7] 、 [2, 5, 8] 、 [3, 6] ）然后分别对划分出来的数组进行插入排序，待各个子数组排序完毕之后再减小 gap 值重复进行之前的步骤，直至 gap = 1 ，即对整个数组进行插入排序，此时的数组已经基本上快排好序了，所以需要移动的元素会很小很小，解决了插入排序在处理大规模数组时较多移动次数的问题。

具体实例请参照插入排序。

希尔排序是插入排序的改进版，在数据量大的时候对效率的提升帮助很大，数据量小的时候建议直接使用插入排序就好了。

实现代码：

 

	/**
	 * Shell Sorting
	 */
	SHELL(new Sortable() {
		public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
			int length = array.length;
			int gap = 1;

			// use the most next to length / 3 as the first gap
			while (gap < length / 3) {
				gap = gap * 3 + 1;
			}

			while (gap >= 1) {
				for (int i = gap; i < length; i++) {
					T next = array[i];
					int j = i;
					while (j >= gap) {
						int compare = array[j - gap].compareTo(next);
						// already find its position
						if (compare == 0 || compare < 0 == ascend) {
							break;
						}

						array[j] = array[j - gap];
						j -= gap;
					}
					if (j != i) {
						array[j] = next;
					}
				}
				gap /= 3;
			}

		}
	})

 

 

5. 归并排序

归并排序采用的是递归来实现，属于“分而治之”，将目标数组从中间一分为二，之后分别对这两个数组进行排序，排序完毕之后再将排好序的两个数组“归并”到一起，归并排序最重要的也就是这个“归并”的过程，归并的过程中需要额外的跟需要归并的两个数组长度一致的空间，比如需要规定的数组分别为： [3, 6, 8, 11] 和 [1, 3, 12, 15] （虽然逻辑上被划为为两个数组，但实际上这些元素还是位于原来数组中的，只是通过一些 index 将其划分成两个数组，原数组为 [3, 6, 8, 11, 1, 3, 12, 15 ，我们设置三个指针 lo, mid, high 分别为 0,3,7 就可以实现逻辑上的子数组划分）那么需要的额外数组的长度为 4 + 4 = 8 。归并的过程可以简要地概括为如下：

1） 将两个子数组中的元素复制到新数组 copiedArray 中，以前面提到的例子为例，则 copiedArray = [3, 6, 8, 11, 1, 3, 12, 15] ；

2） 设置两个指针分别指向原子数组中对应的第一个元素，假定这两个指针取名为 leftIdx 和 rightIdx ，则 leftIdx = 0 （对应 copiedArray 中的第一个元素 [3] ）， rightIdx = 4 （对应 copiedArray 中的第五个元素 [1] ）；

3） 比较 leftIdx 和 rightIdx 指向的数组元素值，选取其中较小的一个并将其值赋给原数组中对应的位置 i ，赋值完毕后分别对参与赋值的这两个索引做自增 1 操作，如果 leftIdx 或 rigthIdx 值已经达到对应数组的末尾，则余下只需要将剩下数组的元素按顺序 copy 到余下的位置即可。

下面给个归并的具体实例：

第一趟：

辅助数组 [21 , 28, 39 | 35, 38] （数组被拆分为左右两个子数组，以 | 分隔开）

[21 ,  ,  ,  ,  ] （第一次 21 与 35 比较 , 左边子数组胜出， leftIdx = 0 ， i = 0 ）

第二趟：

辅助数组 [21, 28 , 39 | 35, 38]

[21 , 28,  ,  ,  ] （第二次 28 与 35 比较，左边子数组胜出， leftIdx = 1 ， i = 1 ）

第三趟： [21, 28, 39 | 35 , 38]

 [21 , 28 , 35,  ,  ] （第三次 39 与 35 比较，右边子数组胜出， rightIdx = 0 ， i = 2 ）

第四趟： [21, 28, 39 | 35, 38 ]

 [21 , 28 , 35 , 38,  ] （第四次 39 与 38 比较，右边子数组胜出， rightIdx = 1 ， i = 3 ）

第五趟： [21, 28, 39 | 35, 38]

 [21 , 28 , 35 , 38 , 39] （第五次时右边子数组已复制完，无需比较 leftIdx = 2 ， i = 4 ）

以上便是一次归并的过程，我们可以将整个需要排序的数组做有限次拆分（每次一分为二）直到分为长度为 1 的小数组为止，长度为 1 时数组已经不用排序了。在这之后再逆序（由于采用递归）依次对这些数组进行归并操作，直到最后一次归并长度为 n / 2 的子数组，归并完成之后数组排序也完成。

归并排序需要的额外空间是所有排序中最多的，每次归并需要与参与归并的两个数组长度之和相同个元素（为了提供辅助数组）。则可以推断归并排序的空间复杂度为 1 + 2 + 4 + … + n = n * ( n + 2) / 4 （忽略了 n 的奇偶性的判断），时间复杂度比较难估，这里小弟也忘记是多少了（囧）。

实现代码：

 

	/**
	 * Merge sorting
	 */
	MERGE(new Sortable() {
		public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
			this.sort(array, 0, array.length - 1, ascend);
		}

		private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) {
			// OPTIMIZE ONE
			// if the substring's length is less than 20,
			// use insertion sort to reduce recursive invocation
			if (hi - lo < 20) {
				for (int i = lo + 1; i <= hi; i++) {
					T toInsert = array[i];
					int j = i;
					for (; j > lo; j--) {
						int compare = array[j - 1].compareTo(toInsert);
						if (compare == 0 || compare < 0 == ascend) {
							break;
						}
						array[j] = array[j - 1];
					}

					array[j] = toInsert;
				}

				return;
			}

			int mid = lo + (hi - lo) / 2;
			sort(array, lo, mid, ascend);
			sort(array, mid + 1, hi, ascend);
			merge(array, lo, mid, hi, ascend);
		}

		private <T extends Comparable<T>> void merge(T[] array, int lo, int mid, int hi, boolean ascend) {
			// OPTIMIZE TWO
			// if it is already in right order, skip this merge
			// since there's no need to do so
			int leftEndCompareToRigthStart = array[mid].compareTo(array[mid + 1]);
			if (leftEndCompareToRigthStart == 0 || leftEndCompareToRigthStart < 0 == ascend) {
				return;
			}

			@SuppressWarnings("unchecked")
			T[] arrayCopy = (T[]) new Comparable[hi - lo + 1];
			System.arraycopy(array, lo, arrayCopy, 0, arrayCopy.length);

			int lowIdx = 0;
			int highIdx = mid - lo + 1;

			for (int i = lo; i <= hi; i++) {
				if (lowIdx > mid - lo) {
					// left sub array exhausted
					array[i] = arrayCopy[highIdx++];
				} else if (highIdx > hi - lo) {
					// right sub array exhausted
					array[i] = arrayCopy[lowIdx++];
				} else if (arrayCopy[lowIdx].compareTo(arrayCopy[highIdx]) < 0 == ascend) {
					array[i] = arrayCopy[lowIdx++];
				} else {
					array[i] = arrayCopy[highIdx++];
				}
			}
		}
	})

 

6. 快速排序

快速排序也是用归并方法实现的一个“分而治之”的排序算法，它的魅力之处在于它能在每次partition（排序算法的核心所在）都能为一个数组元素确定其排序最终正确位置（一次就定位准，下次循环就不考虑这个元素了）。

快速排序的partition操作按以下逻辑进行，假定本次排序的数组为arr：

1） 选择一个元素（为了简单起见，就选择本次partition的第一个元素，即arr[0]）作为基准元素，接下来的步骤会为其确定排序完成后最终的位置；

2） 1）  接下来需要遍历[1…n-1]对应的数组元素以帮助找到arr[0]值（以v替代）对应的位置，定义i为当前访问数组的索引，lt为值小于v的最大索引，gt为值大于v的最小索引，那么在遍历过程中，如果发现i指向的值与v相等，则将i值加1，继续下一次比较；如果i指向的值比v小，则将i和lt对应的元素进行交换，然后分别将两个索引加1；如果i指向的值比v大，则将i与gt对应的元素进行交换，然后i自增，gt自减。循环遍历完成（i > gt时结束）之后可以保证[0…lt-1]对应的值都是比v小的，[lt..gt]之间的值都是与v相等的，[gt+1…n-1]对应的值都是比v大的。

3） 分别对[0…lt-1]和[gt+1…n-1]两个子数组进行排序，如此递归，直至子子子数组的长度为0。

 

下面举个partition的具体实例：

初始（i = 1, lt = 0, gt = 8）：

       [41, 59, 43, 26, 63, 30, 29, 26, 42]（需要确定位置的为0th[41]）

第一趟（i = 1, lt = 0, gt = 8）：

       [41, 42, 43, 26, 63, 30, 29, 26, 59]（1st[59] > 41，1st[59]<->8th[42]，gt--）

第二趟（i = 1, lt = 0, gt = 7）：

       [41, 26, 43, 26, 63, 30, 29, 42, 59]（1st[42] > 41，1st[42]<->7th[26]，gt--）

第三趟（i = 1, lt = 0, gt = 6）：

       [26, 41, 43, 26, 63, 30, 29, 42, 59]（1st[26] < 41, 1st[26]<->0st[41]，i++, lt++）

第四趟（i = 2, lt = 1, gt = 6）：

       [26, 41, 29, 26, 63, 30, 43, 42, 59]（2nd[43] > 41，2nd[43]<->6th[29]，gt--）

第五趟（i = 2, lt = 1, gt = 5）：

       [26, 29, 41, 26, 63, 30, 43, 42, 59]（2nd[29] < 41, 2nd[29]<->1st[41]，i++，lt++）

第六趟（i = 3, lt = 2, gt = 5）：    

       [26, 29, 26, 41, 63, 30, 43, 42, 59]（3rd[26] < 41，3rd[26]<->2nd[41]，i++，lt++）

第七趟（i = 4, lt = 3, gt = 5）：

       [26, 29, 26, 41, 30, 63, 43, 42, 59] （4th[63] > 41，4th[63]<->5th[30]，gt--）

第八趟（i = 4, lt = 3, gt = 4）：    

       [26, 29, 26, 30, 41, 63, 43, 42, 59]（4th[30] < 41，4th[30]<->3rd[41]，i++，lt++）

 

可以看出，在一次partition之后，以41为分割线，41左侧皆为比它小的元素，41右侧皆为比它大或相等的元素（当然这个实例比较特殊，没有出现和41相等的元素）。快速排序顾名思义就是排序速度非常快，后面我会放在我机器上跑各个排序方法的时间对比图。值得一提的是JDK中在Arrays工具内中内置的sort方法就是接合插入排序和三路快速排序实现的，有兴趣的同学可以看看JDK的源码。

 

实现代码：

 

	/**
	 * Quick Sorting
	 */
	QUICK(new Sortable() {
		public <T extends Comparable<T>> void sort(T[] array, boolean ascend) {
			this.sort(array, 0, array.length - 1, ascend);
		}

		private <T extends Comparable<T>> void sort(T[] array, int lo, int hi, boolean ascend) {
			if (lo >= hi) {
				return;
			}

			T toFinal = array[lo];
			int leftIdx = lo;
			int rightIdx = hi;

			int i = lo + 1;

			while (i <= rightIdx) {
				int compare = array[i].compareTo(toFinal);
				if (compare == 0) {
					i++;
				} else if (compare < 0 == ascend) {
					exchange(array, leftIdx++, i++);
				} else {
					exchange(array, rightIdx--, i);
				}
			}

			// partially sort left array and right array
			// no need to include the leftIdx-th to rightIdx-th elements
			// since they are already in its final position
			sort(array, lo, leftIdx - 1, ascend);
			sort(array, rightIdx + 1, hi, ascend);
		}
	})

 

 

如果你希望查看完整代码，请移驾至我的GoogleCode查看，传送门。

这里是我测试时的测试用例，利用了枚举和策略模式的优势，切换排序算法时相对会比较容易。

 

以下为经典排序算法在我机器上运行的耗时对比图（测试用的随机数组长度为50000），直接截的测试用例的图。

 

 

 

 鉴于有博友提到无法访问GoogleCode,我将项目工程以附件的方式上传了,需要的博友请下载吧.

 

 

54
顶
39
踩
分享到：
评论
33 楼 lliiqiang 2014-07-02  
好厉害算法，关键是小到一定程度就无意义，所以要分配好
32 楼 praylover 2013-05-20  
貌似不能运行哎……
31 楼 len-len 2013-05-19  
貌似这里的效率不搞啊，特别是冒泡，快速，直接插入比我测试的慢一半，然后你还没有讲堆排序吧。
30 楼 Mossad 2012-07-16  
easense2009 写道
Mossad 写道
貌似唱赞歌的比较多，我是来吐槽的，呵呵！
选择排序：
    1、第二句话：“最大值”改为“最小值”。
    这个主要得根据参数ascend的true|false来决定，我示例中是按升序排序来讲解的。
    2、比较次数应该是：1 + 2 + …… + （n-1）而不是到n，结果应该是：ｎ＊（ｎ－１）／２。
    这点确实是我马虎了。
    3、最坏情况下交换n-1次而不是n次。
    同第2点。
    4、代码里面这样写：compare != 0 && compare < 0 == ascend显然很别扭，而且cmpare < 0 自然不会等于0。
    这里是为了为了ascend能switch数组的升降序，在判断条件里多加一个compare != 0可以减少一些交换，如果ascend = true时 compare < 0 == ascend 等价于 compare < 0；而如果ascend = false时 compare < 0 == false 就等价于 compare >= 0了，这样compare = 0的情况也会进行元素交换了。不知我这样解释能否明白？
插入排序：
    1、说好的数字被划掉呢？
    文档是我先在Word中编辑的，然后paste到这里时格式被弄掉了吧。
    2、同样的问题，最坏情况下比较和移动的次数应该是：1 + 2 + …… + （n-1）。

冒泡排序：
    1、代码里头，i应该小于length-1。
    2、同样的比较次数问题。
    2、currOrderedIdx挺好，表扬一下。

归并排序：
    1、if (hi - lo < 20)，这里计算数组的长度应该用hi - lo + 1。
    在这点上兄台确实够认真了! 

最后是快速排序，我记得以前的教科书上的快速排序充分利用了你所谓的“基准元素”，将“基准元素”保存到一个变量中，然后利用这个空出的位子放置移动的元素，是不需要对“基准元素”执行交换操作的，这样子的话按照你的例子只需要六步就能够完成第一次“基准元素”定位。


恩，多谢兄台的“吐槽”，就是需要多交流，个人的思维毕竟有所局限性。对你提出的部分问题，我用绿色字体进行了回答，如有不满意或疑问请继续不吝赐教。
这个compare != 0 && compare < 0 == ascend判断条件，我知道这里是为了实现升降序（差点把“没有实现升降序”也给写进去，后来想明白了，呵呵），就是没想到“相同数字不用交换”这一点，挺好的，再次感谢楼主写了这么一篇关于排序算法的好文章，让我也重新学习了一遍，辛苦了，顶顶顶！
29 楼 easense2009 2012-07-15  
Mossad 写道
貌似唱赞歌的比较多，我是来吐槽的，呵呵！
选择排序：
    1、第二句话：“最大值”改为“最小值”。
    这个主要得根据参数ascend的true|false来决定，我示例中是按升序排序来讲解的。
    2、比较次数应该是：1 + 2 + …… + （n-1）而不是到n，结果应该是：ｎ＊（ｎ－１）／２。
    这点确实是我马虎了。
    3、最坏情况下交换n-1次而不是n次。
    同第2点。
    4、代码里面这样写：compare != 0 && compare < 0 == ascend显然很别扭，而且cmpare < 0 自然不会等于0。
    这里是为了为了ascend能switch数组的升降序，在判断条件里多加一个compare != 0可以减少一些交换，如果ascend = true时 compare < 0 == ascend 等价于 compare < 0；而如果ascend = false时 compare < 0 == false 就等价于 compare >= 0了，这样compare = 0的情况也会进行元素交换了。不知我这样解释能否明白？
插入排序：
    1、说好的数字被划掉呢？
    文档是我先在Word中编辑的，然后paste到这里时格式被弄掉了吧。
    2、同样的问题，最坏情况下比较和移动的次数应该是：1 + 2 + …… + （n-1）。

冒泡排序：
    1、代码里头，i应该小于length-1。
    2、同样的比较次数问题。
    2、currOrderedIdx挺好，表扬一下。

归并排序：
    1、if (hi - lo < 20)，这里计算数组的长度应该用hi - lo + 1。
    在这点上兄台确实够认真了! 

最后是快速排序，我记得以前的教科书上的快速排序充分利用了你所谓的“基准元素”，将“基准元素”保存到一个变量中，然后利用这个空出的位子放置移动的元素，是不需要对“基准元素”执行交换操作的，这样子的话按照你的例子只需要六步就能够完成第一次“基准元素”定位。


恩，多谢兄台的“吐槽”，就是需要多交流，个人的思维毕竟有所局限性。对你提出的部分问题，我用绿色字体进行了回答，如有不满意或疑问请继续不吝赐教。
28 楼 Mossad 2012-07-13  
貌似唱赞歌的比较多，我是来吐槽的，呵呵！
选择排序：
    1、第二句话：“最大值”改为“最小值”。
    2、比较次数应该是：1 + 2 + …… + （n-1）而不是到n，结果应该是：ｎ＊（ｎ－１）／２。
    3、最坏情况下交换n-1次而不是n次。
    4、代码里面这样写：compare != 0 && compare < 0 == ascend显然很别扭，而且cmpare < 0 自然不会等于0。

插入排序：
    1、说好的数字被划掉呢？
    2、同样的问题，最坏情况下比较和移动的次数应该是：1 + 2 + …… + （n-1）。

冒泡排序：
    1、代码里头，i应该小于length-1。
    2、同样的比较次数问题。
    2、currOrderedIdx挺好，表扬一下。

归并排序：
    1、if (hi - lo < 20)，这里计算数组的长度应该用hi - lo + 1。

最后是快速排序，我记得以前的教科书上的快速排序充分利用了你所谓的“基准元素”，将“基准元素”保存到一个变量中，然后利用这个空出的位子放置移动的元素，是不需要对“基准元素”执行交换操作的，这样子的话按照你的例子只需要六步就能够完成第一次“基准元素”定位。
27 楼 a114d 2012-06-29  
太厉害了
26 楼 j00131120 2012-06-29  
不错
25 楼 sunjunliangsunjun 2012-06-29  
afdadf a dS  AS A
24 楼 chenglnb 2012-06-28  
谢谢 学习下
23 楼 hwy584624785 2012-06-28  
markssd
22 楼 lsjinpeng 2012-06-28  
mark 了解下排序
21 楼 easense2009 2012-06-28  
lumi 写道
这个自己练兵还可以

实际开发过程中，还是用JDK内置的排序功能吧……

那是自然,咱不得了解了解其内部的原理,不能一直都"拿来主义"不是?
20 楼 lumi 2012-06-28  
这个自己练兵还可以

实际开发过程中，还是用JDK内置的排序功能吧……
19 楼 rainsilence 2012-06-28  
是enum吧
18 楼 easense2009 2012-06-27  
爪哇鱼 写道
是用伪代码实现的吗？

不是，是实际使用的Java代码，我一会儿会放出完整代码及测试用例的。
17 楼 爪哇鱼 2012-06-27  
是用伪代码实现的吗？
16 楼 easense2009 2012-06-27  
zhuzl5210798 写道
顶！ 希望待续的早点出来啊！

行,争取今晚就写出来.
15 楼 zhuzl5210798 2012-06-27  
顶！ 希望待续的早点出来啊！
14 楼 Hunk_Gou 2012-06-27  
顶个 收藏
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java排序算法小结

    对java实现排序的一些总结。对一些常见的排序算法，比如：插入，冒泡，选择这些排序的java实现

    常见排序算法小结

    在高级语言的执行速度上，c是最快的，c++其次，而java和c#是最后的。Java和c#流行，主要的一个原因是可以跨平台。

    Java常用算法手册源代码

    第4章 排序算法 第5章 查找算法 第6章 基本数学问题 第7章 数据结构问题 第8章 数论问题 第9章 算法经典趣题 **0章 游戏中的算法 **1章 密码学概述 **2章 压缩与解压缩算法 第3篇 算法面试篇 **3章 数学能力测试 **4...

    Kruskal算法和prim算法求最小生成树学习小结（JAVA）

    `Main.java`和`Main1.java`可能包含了这两种算法的实现。具体代码细节可能包括边类的定义（包含源点、终点和权重），以及Kruskal和Prim算法的函数实现。在`iteye.com`上的博文链接可能提供了更详细的解释和示例。 *...

    Java排序小结：常用的排序方法

    本篇文章将详细解析Java中常见的排序方法，结合"javaeye 收集的java排序小结"资料，旨在帮助读者理解和掌握这些排序算法。 1. 冒泡排序（Bubble Sort） 冒泡排序是最简单的排序算法之一，通过重复遍历数组，比较...

    各种排序算法的稳定性和时间复杂度小结

    【排序算法】是计算机科学中一个重要的领域，涉及到多种数据处理和组织方式。稳定性和时间复杂度是评估排序算法性能的两个关键指标。 【稳定排序算法】指的是在排序过程中，相等元素的相对顺序不会改变。例如，冒泡...

    Java数组常用排序算法实例小结

    Java数组常用排序算法实例小结 Java数组常用排序算法是每个Java开发者都需要掌握的基本技能，本文将通过实例形式总结分析Java数组常用的四种排序算法，分别是冒泡排序、数组递增排序、快速排序及选择排序。 一、...

    java实现快速排序小结

    快速排序是一种高效的排序算法，由英国计算机科学家C.A.R. Hoare在1960年提出。它的基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分记录...

    Java软件开发实战 Java基础与案例开发详解 4-4 排序算法 共13页.pdf

    ### Java排序算法详解 #### 4.4 排序算法 **排序算法**是指通过一定的规则重新排列一组数据，使其按照特定的顺序（通常是升序或降序）排列。它是计算机科学中最基本的操作之一，广泛应用于各种场景。本节重点介绍...

    数据结构与算法分析Java语言描述(第二版)

    堆6.6 左式堆6.6.1 左式堆性质6.6.2 左式堆操作6.7 斜堆6.8 二项队列6.8.1 二项队列结构6.8.2 二项队列操作6.8.3 二项队列的实现6.9 标准库中的优先队列小结练习参考文献第7章　排序7.1 预备知识7.2 插入排序7.2.1...

    数据结构与算法分析_Java语言描述(第2版)]

    堆6.6 左式堆6.6.1 左式堆性质6.6.2 左式堆操作6.7 斜堆6.8 二项队列6.8.1 二项队列结构6.8.2 二项队列操作6.8.3 二项队列的实现6.9 标准库中的优先队列小结练习参考文献第7章 排序7.1 预备知识7.2 插入排序7.2.1 ...

    C／C++常用算法手册.秦姣华(有详细书签).rar

    4.5.2 Shell排序算法示例 111 4.6 快速排序法 113 4.6.1 快速排序算法 113 4.6.2 快速排序算法示例 114 4.7 堆排序法 116 4.7.1 堆排序算法 116 4.7.2 堆排序算法示例 121 4.8 合并排序法 123 4.8.1 合并...

    Java数据结构和算法中文第二版

    Java数据结构和算法介绍了计算机编程中使用的数据结构和算法，对于在计算机应用中如何操作和管理数据以取得最优性能提供了深入浅出的讲解。全书共分为15章，分别讲述了基本概念、数组、简单排序、堆和队列、链表、...

    java String类常用方法练习小结

    在这个例子中，我们使用冒泡排序算法，通过比较相邻元素并交换位置，最终得到按字典顺序排列的字符串数组。 ```java public class StringTest_1 { // 对字符串数组进行排序 public static void stringSort(String...

    java数据结构与算法第二版

    小结 问题 第2章 数组 Array专题Applet Java中数组的基础知识 将程序划分成类 类接口 Ordered专题applet 有序数组的Java代码 对数 存储对象 大O表示法 为什么不用数组表示一切? 小结 问题 实验 编程...

    Java语言的数据结构与算法书

    排序算法，如冒泡排序、插入排序、选择排序、快速排序、归并排序和堆排序，是基础且实用的算法，它们在处理大量数据时尤其重要。搜索算法，如深度优先搜索（DFS）和广度优先搜索（BFS），在解决图和树的问题时发挥...

    数据结构与算法分析_Java_语言描述

    3．3．2 栈的实现 3．3．3 应用 3．4 队列ADT 3．4．1 队列模型 3．4．2 队列的数组实现 3．4．3 队列的应用 小结 练习 第4章 树 4．1 预备知识 4．1．1 树的实现 4．1．2 树的遍历及应用 4．2 二叉树 4．2．1 实现 ...

Magicbox
Global site tag (gtag.js) - Google Analytics