pandf

《Thinking in Algorithm》12.详解十一种排序算法

排序算法在算法中占着很重要的地位，很多算法的实现都是基于排序算法的（如搜索算法和合并算法）。所以排序算法也是笔试面试中必考内容。但是不管他怎么考，也就是那几种算法，一般不会超出我接下来要讲的这11种，所以只要认真的掌握着11中就足够了。

那么是哪11种呢，下面是wiki上总结的11种

1 Simple sorts
- 1.1 Insertion sort(插入排序)
- 1.2 Selection sort(选择排序)
2 Efficient sorts
- 2.1 Merge sort (归并排序)
- 2.2 Heapsort (堆排序)
- 2.3 Quicksort (快速排序)
3 Bubble sort and variants
- 3.1 Bubble sort (冒泡排序)
- 3.2 Shell sort (希尔排序)
- 3.3 Comb sort (梳排序)
4 Distribution sort
- 4.1 Counting sort(计数排序)
- 4.2 Bucket sort(桶排序)
- 4.3 Radix sort(基数排序)

下面我就对这11中算法逐个详解。

讲之前先了解几组概念。

排序算法的稳定性？

排序算法可以根据稳定性分为两种：稳定和非稳定算法。那么怎么区分它们？如果链表中存在两个相同元素，稳定排序算法可以在排序之后保持他两原来的次序，而非稳定性的则不能保证。如下图

An example of stable sorting on playing cards. When the cards are sorted by rank with a stable sort, the two 5s must remain in the same order in the sorted output that they were originally in. When they are sorted with a non-stable sort, the 5s may end up in the opposite order in the sorted output.

算法稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。

各种算法的比较

下图中是所有的比较排序算法，从图中我们可以看出比较算法的特性：比较排序有很多性能上的根本限制，如在最差情况下，任何一种比较排序至少需要O(nlogn)比较操作

Comparison sorts
Name	Best	Average	Worst	Memory	Stable	Method	Other notes
Quicksort	$n \log n$	$n \log n$	$n^2$	$\log n$ on average, worst case is $n$ ; Sedgewick variation is $\log n$ worst case	typical in-place sort is not stable; stable versions exist	Partitioning	Quicksort is usually done in place with O(log n) stack space.^{[citation needed]} Most implementations are unstable, as stable in-place partitioning is more complex. Naïve variants use an O(n) space array to store the partition.^{[citation needed]} Quicksort variant using three-way (fat) partitioning takes O(n) comparisons when sorting an array of equal keys.
Merge sort	$n \log n$	$n \log n$	$n \log n$	$n$ worst case	Yes	Merging	Highly parallelizable (up to O(log n) using the Three Hungarian's Algorithm^{[clarification needed]} or, more practically, Cole's parallel merge sort) for processing large amounts of data.
In-place merge sort	—	—	$n \log^2 n$	$1$	Yes	Merging	Can be implemented as a stable sort based on stable in-place merging.^[2]
Heapsort	$n \log n$	$n \log n$	$n \log n$	$1$	No	Selection
Insertion sort	$n$	$n^2$	$n^2$	$1$	Yes	Insertion	O(n + d),^{[clarification needed]} where d is the number ofinversions.
Introsort	$n \log n$	$n \log n$	$n \log n$	$\log n$	No	Partitioning & Selection	Used in several STL implementations.
Selection sort	$n^2$	$n^2$	$n^2$	$1$	No	Selection	Stable with O(n) extra space, for example using lists.^[3]
Timsort	$n$	$n \log n$	$n \log n$	$n$	Yes	Insertion & Merging	Makes n comparisons when the data is already sorted or reverse sorted.
Shell sort	$n$	$n \log^2 n$ or $n^{3/2}$	Depends on gap sequence; best known is $n \log^2 n$	$1$	No	Insertion	Small code size, no use of call stack, reasonably fast, useful where memory is at a premium such as embedded and older mainframe applications.
Bubble sort	$n$	$n^2$	$n^2$	$1$	Yes	Exchanging	Tiny code size.
Binary tree sort	$n$	$n \log n$	$n \log n (balanced)$	$n$	Yes	Insertion	When using a self-balancing binary search tree.
Cycle sort	—	$n^2$	$n^2$	$1$	No	Insertion	In-place with theoretically optimal number of writes.
Library sort	—	$n \log n$	$n^2$	$n$	Yes	Insertion
Patience sorting	—	—	$n \log n$	$n$	No	Insertion & Selection	Finds all the longest increasing subsequences inO(n log n).
Smoothsort	$n$	$n \log n$	$n \log n$	$1$	No	Selection	An adaptive sort: $n$ comparisons when the data is already sorted, and 0 swaps.
Strand sort	$n$	$n^2$	$n^2$	$n$	Yes	Selection
Tournament sort	—	$n \log n$	$n \log n$	$n$ ^[4]	?	Selection
Cocktail sort	$n$	$n^2$	$n^2$	$1$	Yes	Exchanging
Comb sort	$n$	$n \log n$	$n^2$	$1$	No	Exchanging	Small code size.
Gnome sort	$n$	$n^2$	$n^2$	$1$	Yes	Exchanging	Tiny code size.
UnShuffle Sort^[5]	$kN$	$kN$	$kN$	In place for linked lists. N*sizeof(link) for array.	Can be made stable by appending the input order to the key.	Distribution and Merge	No exchanges are performed. Performance is independent of data size. The constant 'k' is proportional to the entropy in the input. K = 1 for ordered or ordered by reversed input so runtime is equivalent to checking the order O(N).
Franceschini's method^[6]	—	$n \log n$	$n \log n$	$1$	Yes	?
Block sort^[7]	$n$	$n \log n$	$n \log n$	$1$	Yes	Insertion & Merging	Combine a block-based O(n) in-place merge algorithm^[8] with a bottom-up merge sort. Turns into a full-speed merge sort if additional memory is optionally provided to it.

下面是整数排序算法和其他非比较排序算法

他们并没有 $\Omega(n \log n)$ 的限制。

Non-comparison sorts
Name	Best	Average	Worst	Memory	Stable	n << 2^k	Notes
Pigeonhole sort	—	$n + 2^k$	$n + 2^k$	$2^k$	Yes	Yes
Bucket sort (uniform keys)	—	$n+k$	$n^2 \cdot k$	$n \cdot k$	Yes	No	Assumes uniform distribution of elements from the domain in the array.^[9]
Bucket sort (integer keys)	—	$n+r$	$n+r$	$n+r$	Yes	Yes	If r is O(n), then Average is O(n).^[10]
Counting sort	—	$n+r$	$n+r$	$n+r$	Yes	Yes	If r is O(n), then Average is O(n).^[9]
LSD Radix Sort	—	$n \cdot \frac{k}{d}$	$n \cdot \frac{k}{d}$	$n$	Yes	No	^[9]^[10]
MSD Radix Sort	—	$n \cdot \frac{k}{d}$	$n \cdot \frac{k}{d}$	$n + \frac{k}{d} \cdot 2^d$	Yes	No	Stable version uses an external array of size n to hold all of the bins.
MSD Radix Sort (in-place)	—	$n \cdot \frac{k}{d}$	$n \cdot \frac{k}{d}$	$\frac{k}{d} \cdot 2^d$	No	No	$\frac{k}{d}$ recursion levels, 2^d for count array.
Spreadsort	—	$n \cdot \frac{k}{d}$	$n \cdot \left( {\frac{k}{s} + d} \right)$	$\frac{k}{d} \cdot 2^d$	No	No	Asymptotics are based on the assumption that n << 2^k, but the algorithm does not require this.

对这些算法进行比较之后，我们会发现排序算法可真多，但在实际应用中也就几种。在少量数据的情况下我们一般会用到插入排序算法，但在大量数据的集合下，我们就会用到堆排序，归并排序，或者快速排序等。对于更多受限制的数据，例如固定间隔的数，则分布排序(计数排序，基数排序)被广泛用到。冒泡排序在实际中很少用到，不过在教学中倒很常见。

维基百科中将那11种算法分为了4种，1.简单排序 2.有效排序 3.冒泡和变体 4.分配排序

1. 简单排序类别
----------------------------------------------

有两种简单排序算法分别是插入排序和选择排序，两个都是数据量小时效率高。实际中插入排序一般快于选择排序，由于更少的比较和在有差不多有序的集合表现更好的性能。但是选择排序用到更少的写操作，所以当写操作是一个限制因素时它被使用到。

1.1 插入排序算法

-------------------------------------------------

Graphical illustration of insertion sort
Class	Sorting algorithm
Data structure	Array
Worst case performance	О(n²) comparisons, swaps
Best case performance	O(n) comparisons, O(1) swaps
Average case performance	О(n²) comparisons, swaps
Worst case space complexity	О(n) total, O(1) auxiliary

常常被用作为复杂算法的一部分，希尔排序是插入排序的一种变体对数据大时更有效。

优点：

实现简单
对于少量数据效率高
对于差不多已经排好顺序的集合效率高，时间复杂度为O(n+d),d是错位数字的个数
比起其他简单二次(O(n^2))算法(选择排序，冒泡排序)，他的最好的情况是O(n)(集合接近顺序排好)
稳定，不会改变相等数原有的顺序
in-place，只需要常熟O(1)的额外内存空间

关于的算法流程可以看下图

《Thinking in Algorithm》12.详解十一种排序算法_第3张图片

A graphical example of insertion sort.

从上图中可以看出，就是逐个向右给每一个元素向前面的序列排序。

又如下列数组的变化

3 7 4 9 5 2 6 1

3 4 7 9 5 2 6 1

3 4 5 7 9 2 6 1

2 3 4 5 7 9 6 1

2 3 4 5 6 7 9 1

1 2 3 4 5 6 7 9

算法伪代码实现

[html]  view plain copy print ?   
       
      
 for i ← 1 to length(A)  
     j ← i  
     while j > 0 and A[j-1] > A[j]  
         swap A[j] and A[j-1]  
         j ← j - 1  

最好，最坏，平均情况

最好：已经排好顺序的集合，这样只需要线性时间即遍历一次集合，每次只需要比较当前元素与前一个元素的大小问题，时间复杂度O(n)

最坏：即刚好与所要的顺序相反，时间复杂度为O(n^2)

平均：时间复杂度也是O(n^2)

1.2 选择排序算法

------------------------------------------------


Class	Sorting algorithm
Data structure	Array
Worst case performance	О(n²)
Best case performance	О(n²)
Average case performance	О(n²)
Worst case space complexity	О(n) total, O(1) auxiliary

插入排序最坏，最好，平均情况都是O(n^2).

算法：将数组分为两部分，一部分是已经排好顺序的，另一部分是未排序的。每次找数组后半部分中最小的一个元素排到前面的序列。如下列数组

64 25 12 22 11

11 25 12 22 64

11 12 25 22 64

11 12 22 25 64

11 12 22 25 64

代码如下

[java]  view plain copy print ?   
      
     
 int i,j;  
 int iMin;  
   
 for (j = 0; j < n-1; j++) {  
     iMin = j;  
     for ( i = j+1; i < n; i++){  
         if (a[i] < a[iMin]){  
             iMin = i;  
         }  
     }  
     if ( iMin != j ){  
         swap(a[j], a[iMin]);  
     }  
 }  

由此可知时间复杂度为(n − 1) + (n − 2) + ... + 2 + 1 = n(n − 1) / 2 ∈ Θ(n²) ，不管任何情况

2. 有效算法

----------------------------------------------

2.1 归并排序算法

算法逻辑：1. 将列表分为n个子列表，每一个列表只包含一个元素 2. 反复地归并子列表成一个新的有序列表，知道只剩下一个子列表

An example of merge sort. First divide the list into the smallest unit (1 element), then compare each element with the adjacent list to sort and merge the two adjacent lists. Finally all the elements are sorted and merged.
Class	Sorting algorithm
Data structure	Array
Worst case performance	O(n log n)
Best case performance	O(n log n) typical, O(n) natural variant
Average case performance	O(n log n)
Worst case space complexity	O(n) auxiliary

《Thinking in Algorithm》12.详解十一种排序算法_第6张图片

Merge sort animation. The sorted elements are represented by dots.

自上而下实现：

A recursive merge sort algorithm used to sort an array of 7 integer values. These are the steps a human would take to emulate merge sort (top-down).

[cpp]  view plain copy print ?   
      
     
 TopDownMergeSort(A[], B[], n)  
 {  
     TopDownSplitMerge(A, 0, n, B);  
 }  
 CopyArray(B[], iBegin, iEnd, A[])  
 {  
     for(k = iBegin; k < iEnd; k++)  
         A[k] = B[k];  
 }  
 // iBegin is inclusive; iEnd is exclusive (A[iEnd] is not in the set)  
 TopDownSplitMerge(A[], iBegin, iEnd, B[])  
 {  
     if(iEnd - iBegin < 2)                       // if run size == 1  
         return;                                 //   consider it sorted  
     // recursively split runs into two halves until run size == 1,  
     // then merge them and return back up the call chain  
     iMiddle = (iEnd + iBegin) / 2;              // iMiddle = mid point  
     TopDownSplitMerge(A, iBegin,  iMiddle, B);  // split / merge left  half  
     TopDownSplitMerge(A, iMiddle,    iEnd, B);  // split / merge right half  
     TopDownMerge(A, iBegin, iMiddle, iEnd, B);  // merge the two half runs  
     CopyArray(B, iBegin, iEnd, A);              // copy the merged runs back to A  
 }  
    
 //  left half is A[iBegin :iMiddle-1]  
 // right half is A[iMiddle:iEnd-1   ]  
 TopDownMerge(A[], iBegin, iMiddle, iEnd, B[])  
 {  
     i0 = iBegin, i1 = iMiddle;  
    
     // While there are elements in the left or right runs  
     for (j = iBegin; j < iEnd; j++) {  
         // If left run head exists and is <= existing right run head.  
         if (i0 < iMiddle && (i1 >= iEnd || A[i0] <= A[i1]))  
             B[j] = A[i0];  
             i0 = i0 + 1;  
         else  
             B[j] = A[i1];  
             i1 = i1 + 1;    }  
    
 }  

自下而上实现：

[cpp]  view plain copy print ?   
      
     
 /* array A[] has the items to sort; array B[] is a work array */  
 BottomUpSort(int n, int A[], int B[])  
 {  
   int width;  
    
   /* Each 1-element run in A is already "sorted". */  
    
   /* Make successively longer sorted runs of length 2, 4, 8, 16... until whole array is sorted. */  
   for (width = 1; width < n; width = 2 * width)  
     {  
       int i;  
       /* Array A is full of runs of length width. */  
       for (i = 0; i < n; i = i + 2 * width)  
         {  
           /* Merge two runs: A[i:i+width-1] and A[i+width:i+2*width-1] to B[] */  
           /* or copy A[i:n-1] to B[] ( if(i+width >= n) ) */  
           BottomUpMerge(A, i, min(i+width, n), min(i+2*width, n), B);  
         }  
       CopyArray(A, B, n);  
     }  
 }  
    
 BottomUpMerge(int A[], int iLeft, int iRight, int iEnd, int B[])  
 {  
   int i0 = iLeft;  
   int i1 = iRight;  
   int j;  
   for (j = iLeft; j < iEnd; j++)  
     {  
       if (i0 < iRight && (i1 >= iEnd || A[i0] <= A[i1]))  
         {  
           B[j] = A[i0];  
           i0 = i0 + 1;  
         }  
       else  
         {  
           B[j] = A[i1];  
           i1 = i1 + 1;  
         }  
     }  
 }  

2.2 堆排序算法

----------------------------------------

堆排序利用的是数据结构-堆，首先你要对堆结构熟悉，详见：数据结构--堆

堆排序是选择排序种类的一部分，相对于基本的选择算法，它的提升是用到了对数时间优先队列（即堆）而不是线性时间搜索。尽管实际中它比完美实现的快速排序慢，但它有个优点就是最坏情况下时间复杂度是O(nlogn).堆排序是一种 in-place algorithm，但不是稳定的排序。

A run of the heapsort algorithm sorting an array of randomly permuted values. In the first stage of the algorithm the array elements are reordered to satisfy the heap property. Before the actual sorting takes place, the heap tree structure is shown briefly for illustration.
Class	Sorting algorithm
Data structure	Array
Worst case performance	$O(n\text{ }\log\text{ }n)$
Best case performance	$\Omega(n), O(n\text{ }\log\text{ }n)$ ^[1]
Average case performance	$O(n\text{ }\log\text{ }n)$
Worst case space complexity	$O(1)$ auxiliary

算法流程：

1. 建立一个最大或最小堆

2. 用根元素与最后一个元素交换位置，将根元素从堆中移除，堆大小减小1。

3. 修复堆，回到上一步，直到堆中不剩元素。

[html]  view plain copy print ?   
      
     
 HEAPSORT(A)  
 1 BUILD-MAX-HEAP(A)             //讲数组A转化为堆  
 2 for i ← length[A] downto 2  
 3    do exchange A[1] ↔ A[i]           //根元素与最后一个元素交换位置  
 4       heap-size[A] ← heap-size[A] - 1     //数组大小减小1  
 5       MAX-HEAPIFY(A, 1)       //修复替换掉根元素A[1]的堆  

上面代码中用到的，BUILD-MAX-HEAP(A)和MAX-HEAPIFY(A, 1)，我前面的博客数据结构--堆有详细介绍这两算法。

我们假设数组A开始元素顺序为{ 6, 5, 3, 1, 8, 7, 2, 4 }，对它进行排序得到从小到大的顺序。

首先执行BUILD-MAX-HEAP(A)，将数组A转化为最大堆。如下图：

1. Build the heap

Heap	newly added element	swap elements
nil	6
6	5
6, 5	3
6, 5, 3	1
6, 5, 3, 1	8
6, 5, 3, 1, 8		5, 8
6, 8, 3, 1, 5		6, 8
8, 6, 3, 1, 5	7
8, 6, 3, 1, 5, 7		3, 7
8, 6, 7, 1, 5, 3	2
8, 6, 7, 1, 5, 3, 2	4
8, 6, 7, 1, 5, 3, 2, 4		1, 4
8, 6, 7, 4, 5, 3, 2, 1

然后我们在最大堆的基础上进行排序，执行伪代码中2-5的步骤。

2. Sorting.

Heap	swap elements	delete element	sorted array	details
8, 6, 7, 4, 5, 3, 2, 1	8, 1			swap 8 and 1 in order to delete 8 from heap
1, 6, 7, 4, 5, 3, 2, 8		8		delete 8 from heap and add to sorted array
1, 6, 7, 4, 5, 3, 2	1, 7		8	swap 1 and 7 as they are not in order in the heap
7, 6, 1, 4, 5, 3, 2	1, 3		8	swap 1 and 3 as they are not in order in the heap
7, 6, 3, 4, 5, 1, 2	7, 2		8	swap 7 and 2 in order to delete 7 from heap
2, 6, 3, 4, 5, 1, 7		7	8	delete 7 from heap and add to sorted array
2, 6, 3, 4, 5, 1	2, 6		7, 8	swap 2 and 6 as they are not in order in the heap
6, 2, 3, 4, 5, 1	2, 5		7, 8	swap 2 and 5 as they are not in order in the heap
6, 5, 3, 4, 2, 1	6, 1		7, 8	swap 6 and 1 in order to delete 6 from heap
1, 5, 3, 4, 2, 6		6	7, 8	delete 6 from heap and add to sorted array
1, 5, 3, 4, 2	1, 5		6, 7, 8	swap 1 and 5 as they are not in order in the heap
5, 1, 3, 4, 2	1, 4		6, 7, 8	swap 1 and 4 as they are not in order in the heap
5, 4, 3, 1, 2	5, 2		6, 7, 8	swap 5 and 2 in order to delete 5 from heap
2, 4, 3, 1, 5		5	6, 7, 8	delete 5 from heap and add to sorted array
2, 4, 3, 1	2, 4		5, 6, 7, 8	swap 2 and 4 as they are not in order in the heap
4, 2, 3, 1	4, 1		5, 6, 7, 8	swap 4 and 1 in order to delete 4 from heap
1, 2, 3, 4		4	5, 6, 7, 8	delete 4 from heap and add to sorted array
1, 2, 3	1, 3		4, 5, 6, 7, 8	swap 1 and 3 as they are not in order in the heap
3, 2, 1	3, 1		4, 5, 6, 7, 8	swap 3 and 1 in order to delete 3 from heap
1, 2, 3		3	4, 5, 6, 7, 8	delete 3 from heap and add to sorted array
1, 2	1, 2		3, 4, 5, 6, 7, 8	swap 1 and 2 as they are not in order in the heap
2, 1	2, 1		3, 4, 5, 6, 7, 8	swap 2 and 1 in order to delete 2 from heap
1, 2		2	3, 4, 5, 6, 7, 8	delete 2 from heap and add to sorted array
1		1	2, 3, 4, 5, 6, 7, 8	delete 1 from heap and add to sorted array
			1, 2, 3, 4, 5, 6, 7, 8	completed

如果你觉得还不够清楚的话，你可以看下列两图加深理解。

An example on heapsort.

下图中是堆最大堆进行排序的行为。

2.3 快速排序算法

--------------------------------------------------

Visualization of the quicksort algorithm. The horizontal lines are pivot values.
Class	Sorting algorithm
Worst case performance	O(n²)
Best case performance	O(n log n) (simple partition) or O(n) (three-way partition and equal keys)
Average case performance	O(n log n)
Worst case space complexity	O(n) auxiliary (naive) O(log n) auxiliary

快速排序（类似于归并算法）是一种分而治之算法。首先它将列表分为两个更小的子列表：一个大一个小。然后递归排序这些子列表。下面就用分而治之的方法来排序子数组A[p...r];

步骤：

Divide：从列表中取一个元素作为支点，将数组分为A[p‥q - 1] andA[q + 1‥r] ，A[p ‥ q - 1]中每一个元素都小于A[q] ，而A[q + 1 ‥ r]中每个元素都大于A[q].计算出支点实际存在数组中的位置，即q的值就是PARTITION操作。

Conquer：通过递归的方法对两个数组进行排序

Combine：因为子数组是原地处理的(即in-place)，所以不需要合并他们，A[p....r]已经是排好序的。

下面是快速排序的过程伪代码：

[html]  view plain copy print ?   
      
     
 <strong><span style="color:#cc33cc;">QUICKSORT(A, p, r)span>strong>  
 1 if p < r  
 2    then q ← PARTITION(A, p, r)  
 3         QUICKSORT(A, p, q - 1)  
 4         QUICKSORT(A, q + 1, r)  

对数组A进行排序，写为：QUICKSORT(A, 1, length[A])。

上面的代码中用到了PARTITION(A,p,r)操作，这个操作是快速排序的核心算法。下面我们就针对它来详解。

首先看伪代码：

[html]  view plain copy print ?   
      
     
 <strong><span style="color:#cc33cc;">PARTITION(A, p, r)span>strong>  
 1  x ← A[r]  
 2  i ← p - 1  
 3  for j ← p to r - 1  
 4       do if A[j] ≤ x  
 5             then i ← i + 1  
 6                  exchange A[i] ↔ A[j]  
 7  exchange A[i + 1] ↔ A[r]  
 8  return i + 1  

关于上面PARTITION(A,p,r)操作的流程可以看下图

简单介绍下，i是两数组分隔的位置，而j是遍历时的索引。当找到小于A[r]的数时，则执行i++.

而PARTITION算法的返回值是i+1,即支点A[r]所处位置。

这里我们了解了什么是PARTITION操作，实质上他就是找到支点所处数组中的位置。

快速排序性能：

快速排序的性能取决于PARTITION操作，它是否是平衡操作，即能否将数组分为两个大小差不多的数组。如果他分配不均的话，就变成了插入排序。

最坏情况：

最坏的情况就是每次都是不平衡分配，使得一个拥有n-1个元素，一个则含有0个元素。我们知道PARTITION操作的时间复杂度为O(n),而不平均分配的递归会是

T(n) = T(n - 1) + T(0) + Θ(n)
= T(n - 1) + Θ(n)

这样会使得时间复杂度变为O(n^2).跟插入排序一样，而且插入排序在排好序的数组运行时间复杂度为O(n).

最好情况：

每次分配都是一个大小为n/2，另一个为n/2-1。这样递归式变为了

T (n)≤ 2T (n/2) +Θ(n)

这样的话，时间复杂度就是O(nlgn)

平均情况：

时间复杂度也是O(nlgn).算法导论中有详细证明，这里我就举个例子说明下

假设每次分配都是9/10和1/10，那么递归式就是

T(n)≤T (9n/10) +T (n/10) +O(n) 由下图我们可以知道时间复杂度依然是O(nlgn)

3. 冒泡排序和变体类别

--------------------------------------------------------

这种类别的算法在实际中很少使用到，因为效率低下，但在理论教学中常常提到。

3.1 冒泡排序

----------------------------------------------------------


Class	Sorting algorithm
Data structure	Array
Worst case performance	$O(n^2)$
Best case performance	$O(n)$
Average case performance	$O(n^2)$
Worst case space complexity	$O(1)$ auxiliary

冒泡排序效率非常低，效率还不如插入排序。数据量大时效率低，对于顺序颠倒的序列效率最低。

算法流程：简单概括就是每次找到序列中最大或最小的元素排到最后面去，循环知道每个元素都处于正确位置。如下图：

An example of bubble sort. Starting from the beginning of the list, compare every adjacent pair, swap their position if they are not in the right order (the latter one is smaller than the former one). After each iteration, one less element (the last one) is needed to be compared until there are no more elements left to be compared.

代码如下

[html]  view plain copy print ?   
      
     
 for(int x=0; x<n; x++)  
 {  
     for(int y=0; y<n-1; y++)  
     {  
         if(array[y]>array[y+1])  
         {  
             int temp = array[y+1];  
             array[y+1] = array[y];  
             array[y] = temp;  
         }  
     }  
 }  

《Thinking in Algorithm》12.详解十一种排序算法_第16张图片

A bubble sort, a sorting algorithm that continuously steps through a list, swapping items until they appear in the correct order. The list was plotted in a Cartesian coordinate system, with each point (x,y) indicating that the value y is stored at index x. Then the list would be sorted by Bubble sort according to every pixel's value. Note that the largest end gets sorted first, with smaller elements taking longer to move to their correct positions.

3.2 希尔排序

-------------------------------------------------------------------

希尔排序是in-place算法，但不是稳定的。

Shellsort with gaps 23, 10, 4, 1 in action.
Class	Sorting algorithm
Data structure	Array
Worst case performance	O(n²)
Best case performance	O(n log n)
Average case performance	depends on gap sequence
Worst case space complexity	О(n) total, O(1) auxiliary

希尔排序算法步骤：

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d2 　该方法实质上是一种分组插入方法。

$\begin{array}{rcccccccccccc} &a_1&a_2&a_3&a_4&a_5&a_6&a_7&a_8&a_9&a_{10}&a_{11}&a_{12}\\ \hbox{input data:} & 62& 83& 18& 53& 07& 17& 95& 86& 47& 69& 25& 28\\ \hbox{after 5-sorting:} & 17& 28& 18& 47& 07& 25& 83& 86& 53& 69& 62& 95\\ \hbox{after 3-sorting:} & 17& 07& 18& 47& 28& 25& 69& 62& 53& 83& 86& 95\\ \hbox{after 1-sorting:} & 07& 17& 18& 25& 28& 47& 53& 62& 69& 83& 86& 95\\\end{array}$

如上图我们去d1=5，d2=3，d3=1

d=5时，分组为 (a1, a6, a11), (a2, a7, a12), (a3, a8), (a4, a9), (a5, a10)，对组内的元素进行分别插入排序，得到第二排数组

d=3时，分组为(a1, a4, a7, a10), (a2, a5, a8, a11), (a3, a6, a9, a12)，对其分组插入排序，得到第三排数组。

d=1时，分组为 (a1,..., a12)，进行插入排序，得到结果。

d的取值

这里你可能会有疑惑，那我们写程序的时候，对于d的值应该怎样取呢？

一般情况下，第一次去n/2,第二次取b/2/2....这样做的最坏时间复杂度为O(n^2).但wikipedia上有一些更优秀的取值，可以改善最坏情况下的时间复杂度，如下表：

General term (k ≥ 1)	Concrete gaps	Worst-case time complexity	Author and year of publication
$\lfloor N / 2^k \rfloor$	$\left\lfloor\frac{N}{2}\right\rfloor, \left\lfloor\frac{N}{4}\right\rfloor, \ldots, 1$	$\Theta(N^2)$ [when N=2^p]	Shell, 1959^[2]
$2 \lfloor N / 2^{k+1} \rfloor + 1$	$2 \left\lfloor\frac{N}{4}\right\rfloor + 1, \ldots, 3, 1$	$\Theta(N^{3/2})$	Frank & Lazarus, 1960^[6]
$2^k - 1$	$1, 3, 7, 15, 31, 63, \ldots$	$\Theta(N^{3/2})$	Hibbard, 1963^[7]
$2^k + 1$ , prefixed with 1	$1, 3, 5, 9, 17, 33, 65, \ldots$	$\Theta(N^{3/2})$	Papernov & Stasevich, 1965^[8]
successive numbers of the form $2^p 3^q$	$1, 2, 3, 4, 6, 8, 9, 12, \ldots$	$\Theta(N \log^2 N)$	Pratt, 1971^[9]
$(3^k - 1) / 2$ , not greater than $\lceil N / 3 \rceil$	$1, 4, 13, 40, 121, \ldots$	$\Theta(N^{3/2})$	Knuth, 1973^[1]

还有些更复杂的取值，我这里就不列举了，平时写程序的时候，我看到大多数都是用的第一种，就是发明算法的这个人提出来的。

希尔排序的时间性能优于直接插入排序的原因：

当文件初态基本有序时直接插入排序所需的比较和移动次数均较少。
当n值较小时，n和n2的差别也较小，即直接插入排序的最好时间复杂度O(n)和最坏时间复杂度0(n2)差别不大。
在希尔排序开始时增量较大，分组较多，每组的记录数目少，故各组内直接插入较快，后来增量di逐渐缩小，分组数逐渐减少，而各组的记录数目逐渐增多，但由于已经按di-1作为距离排过序，使文件较接近于有序状态，所以新的一趟排序过程也较快。

下面就用d=N/2^k 写代码

[cpp]  view plain copy print ?   
       
      
 void shellsort2(int a[], int n)    
 {    
     int j, gap;    
         
     for (gap = n / 2; gap > 0; gap /= 2)    
         for (j = gap; j < n; j++)//从数组第gap个元素开始    
             if (a[j] < a[j - gap])//每个元素与自己组内的数据进行直接插入排序    
             {    
                 int temp = a[j];    
                 int k = j - gap;    
                 while (k >= 0 && a[k] > temp)    
                 {    
                     a[k + gap] = a[k];    
                     k -= gap;    
                 }    
                 a[k + gap] = temp;    
             }    
 }  

从代码中可以看出shell排序就是里面嵌套一个插入排序，外面是分组。

3.3 梳排序

-----------------------------------------------------------


Class	Sorting algorithm
Data structure	Array
Worst case performance	$\Omega(n^2)$ ^[1]
Best case performance	$O(n)$
Average case performance	$\Omega(n^2/2^p)$ , where $p$ is the number of increments^[1]
Worst case space complexity	$O(1)$

它是冒泡排序的一种变体，就像希尔排序一样，也是利用一个间隔值来堆其进行分组，只不过希尔排序内部嵌套的是插入排序，而梳排序嵌套的是冒泡排序。

为什么梳排序和希尔排序都可以通过分组来提高效率呢？

因为插入排序和冒泡排序有几个相似的点：1.当文件初态基本有序时时间复杂度为O(n). 2.数据量小时效率更好，因为最好情况n和最坏情况n^2相差不大。

就是因为上面两种特性，所以分组可以减少数据量，且分组的排序使得文件初态基本有序。

类似希尔排序取间隔的方法，只不过梳排序每次取间隔为n/1.3，下一次再除以1.3，知道间隔为1.看下面的例子。

假设待数组[8 4 3 7 6 5 2 1]
待排数组长度为8,而8÷1.3=6,则比较8和2,4和1,并做交换

[8 4 3 7 6 5 2 1]
[8 4 3 7 6 5 2 1]

交换后的结果为
[2 1 3 7 6 5 8 4]

第二次循环,更新间距为6÷1.3=4,比较2和6,1和5,3和8,7和4

[2 1 3 7 6 5 8 4]
[2 1 3 7 6 5 8 4]
[2 1 3 7 6 5 8 4]
[2 1 3 7 6 5 8 4]

只有7和4需要交换,交换后的结果为

[2 1 3 4 6 5 8 7]

第三次循环,更新距离为3,没有交换

第四次循环,更新距离为2,没有交换

第五次循环,更新距离为1,三处交换

[2 1 3 4 6 5 8 7]
[2 1 3 4 6 5 8 7]
[2 1 3 4 6 5 8 7]

三处交换后的结果为[1 2 3 4 5 6 7 8]
交换后排序结束,顺序输出即可得到[1 2 3 4 5 6 7 8]

实现代码：

[cpp]  view plain copy print ?   
       
      
 void comb_sort(int *input, size_t size) {  
     const float shrink = 1.3f;  
     int swap;  
     size_t i, gap = size;  
     bool swapped = false;  
    
     while ((gap > 1) || swapped) {  
         if (gap > 1) {  
             gap = (size_t)((float)gap / shrink);  
         }  
    
         swapped = false;  
    
         for (i = 0; gap + i < size; ++i) {  
             if (input[i] - input[i + gap] > 0) {  
                 swap = input[i];  
                 input[i] = input[i + gap];  
                 input[i + gap] = swap;  
                 swapped = true;  
             }  
         }  
     }  
 }  

4. 线性时间的排序

--------------------------------------------------

4.1 计数排序

---------------------------------------------

计数排序不是基于比较的排序算法，它的优势在于对一定范围内（小范围）的整数排序时，它的复杂度为O(n+k),快于任何比较算法。

算法步骤：

我们假设输入的数组A[1....n]，数组长度length[A]=n。此时我们要实现它的排序还需要两个而外的数组。

数组B[1...n]，用于存储排序后的结果

数组C[0...k]，k代表着数组A的的元素都属于0--k

配合下图理解：

(a): 数组C分别记录数组A中0,2,3,5出现的次数。

(b): 对 a图中的数组C进行c[i] = c[i] + c[i-1];得出b图中的结果。

(c): 从数组A中取元素A[8]=3,因为3在数组C中记录显示，小于等于3的元素个数为7(包含他自己)，所以将3存入有序数组B中的索引为7.

(d): 同理取出A[7]=0.

(e): 取出A[6]=3

...........

(f): 最后取出A[1]=2，存入对应的B中。得出最终结果。

实现的伪代码

[html]  view plain copy print ?   
      
     
 COUNTING-SORT(A, B, k)  
  1  for i ← 0 to k  
  2     do C[i] ← 0  
  3  for j ← 1 to length[A]  
  4     do C[A[j]] ← C[A[j]] + 1  
  5  ▹ C[i] now contains the number of elements equal to i.  
  6  for i ← 1 to k  
  7     do C[i] ← C[i] + C[i - 1]  
  8  ▹ C[i] now contains the number of elements less than or equal to i.  
  9  for j ← length[A] downto 1  
 10     do B[C[A[j]]] ← A[j]  

下面用java实现，是对上面的代码进行优化后的，就是减小了数组C的大小，原来的k<=max,而下面的代码是k

[java]  view plain copy print ?   
      
     
 public class CountSort{  
     public static void main(String []args){  
         //排序的数组  
         int a[] = {100, 93, 97, 92, 96, 99, 92, 89, 93, 97, 90, 94, 92, 95};  
         int b[] = countSort(a);  
         for(int i : b){  
             System.out.print(i + "  ");  
         }  
         System.out.println();  
     }  
     public static int[] countSort(int []a){  
         int b[] = new int[a.length];  
         int max = a[0], min = a[0];  
         for(int i : a){  
             if(i > max){  
                 max = i;  
             }  
             if(i < min){  
                 min = i;  
             }  
         }  
         //这里k的大小是要排序的数组中，元素大小的极值差+1  
         int k = max - min + 1;  
         int c[] = new int[k];  
         for(int i = 0; i < a.length; ++i){  
             c[a[i]-min] += 1;//优化过的地方，减小了数组c的大小  
         }  
         for(int i = 1; i < c.length; ++i){  
             c[i] = c[i] + c[i-1];  
         }  
         for(int i = a.length-1; i >= 0; --i){  
             b[--c[a[i]-min]] = a[i];//按存取的方式取出c的元素  
         }  
         return b;  
     }  
 }  

4.2 桶排序

-----------------------------------------------------

Class	Sorting algorithm
Data structure	Array
Worst case performance	$O(n^2)$
Average case performance	$O(n+k)$
Worst case space complexity	$O(n\cdot k)$

算法步骤：

桶排序假设待排序的一组数统一的分布在一个范围中，并将这一范围划分成几个子范围，也就是桶。
将待排序的一组数，分档规入这些子桶。并将桶中的数据进行排序。
将各个桶中的数据有序的合并起来。

仔细想一想，这是不是一种“分治”策略呢？再仔细想一想，计数排序是不是桶排序的一种特化呢？

下面假设数组范围为（0,1）,则利用桶排序的步骤如下图

《Thinking in Algorithm》12.详解十一种排序算法_第20张图片

伪代码：

[html]  view plain copy print ?   
       
      
 BUCKET-SORT(A)  
 1  n ← length[A]  
 2  for i ← 1 to n  
 3     do insert A[i] into list B[⌊n A[i]⌋]  
 4  for i ← 0 to n - 1  
 5     do sort list B[i] with insertion sort  
 6  concatenate the lists B[0], B[1], . . ., B[n - 1] together in order  

4.3 基数排序

---------------------------------------------------------

Class	Sorting algorithm
Data structure	Array
Worst case performance	$O(kN)$
Worst case space complexity	$O(k + N)$

1 最低位优先(Least Significant Digit first)法，简称LSD法

算法流程：

Take the least significant digit (or group of bits, both being examples of radices) of each key.
Group the keys based on that digit, but otherwise keep the original order of keys. (This is what makes the LSD radix sort a stable sort).
Repeat the grouping process with each more significant digit.

The sort in step 2 is usually done using bucket sort or counting sort, which are efficient in this case since there are usually only a small number of digits.

这里我就不翻译了(英语比较捉急)，直接用wikipedia上面的，怕翻译的捉急。因为我发现很多人民间版的定义都有错，不得不承认wiki是个好东西。我就简单说下大致意思：

1. 得到最低位的数值，即个位数的数值

2. 对提取出来的数值进行排序。（可以用计数排序或桶排序）

3. 重复上面的操作，知道遍历每一个数位。

实例：例如个位，个位都是[0-10)范围内的。先对他进行归类，把小的放上面，大的放下面，然后个位排好了，在来看10位，我们也这样把小的放上面，大的放下面，依次内推，直到最高位排好。那么不就排好了吗？我们只需要做d(基数个数)的循环就可以了。时间复杂度相当于O(d * n) 因为d为常量，例如5位数，d就是5.所以近似为O(n)的时间复杂度。这次自己写个案例：

最初的数据	排好个位的数据	排好十位的数据	排好百位的数据
981	981	725	129
387	753	129	387
753	955	753	456
129	725	955	725
955	456	456	753
725	387	981	955
456	129	387	981

又如下图：

c代码：

[cpp]  view plain copy print ?   
      
     
 #include   
 #define MAX 20  
 #define SHOWPASS  
 #define BASE 10  
 void print(int *a, int n)  
 {  
   int i;  
   for (i = 0; i < n; i++)  
     printf("%d\t", a[i]);  
 }  
    
 void radixsort(int *a, int n)  
 {  
   int i, b[MAX], m = a[0], exp = 1;  
    
   //Get the greatest value in the array a and assign it to m  
   for (i = 1; i < n; i++)  
   {  
     if (a[i] > m)  
       m = a[i];  
   }  
    
   //Loop until exp is bigger than the largest number  
   while (m / exp > 0)  
   {  
     int bucket[BASE] = { 0 };  
    
     //Count the number of keys that will go into each bucket  
     for (i = 0; i < n; i++)  
       bucket[(a[i] / exp) % BASE]++;  
    
     //Add the count of the previous buckets to acquire the indexes after the end of each bucket location in the array  
     for (i = 1; i < BASE; i++)  
       bucket[i] += bucket[i - 1];  
    
     //Starting at the end of the list, get the index corresponding to the a[i]'s key, decrement it, and use it to place a[i] into array b.  
     for (i = n - 1; i >= 0; i--)  
       b[--bucket[(a[i] / exp) % BASE]] = a[i];  
    
     //Copy array b to array a  
     for (i = 0; i < n; i++)  
       a[i] = b[i];  
    
     //Multiply exp by the BASE to get the next group of keys  
     exp *= BASE;  
    
     #ifdef SHOWPASS  
       printf("\nPASS   : ");  
       print(a, n);  
     #endif  
   }  
 }  
    
 int main()  
 {  
   int arr[MAX];  
   int i, n;  
   printf("Enter total elements (n <= %d) : ", MAX);  
   scanf("%d", &n);  
   n = n < MAX ? n : MAX;  
    
   printf("Enter %d Elements : ", n);  
   for (i = 0; i < n; i++)  
     scanf("%d", &arr[i]);  
    
   printf("\nARRAY  : ");  
   print(&arr[0], n);  
    
   radixsort(&arr[0], n);  
    
   printf("\nSORTED : ");  
   print(&arr[0], n);  
   printf("\n");  
    
   return 0;  
 }  

最高位优先(Most significant digital)法，简称MSD法
算法步骤：

A recursively subdividing MSD radix sort algorithm works as follows:

Take the most significant digit of each key.
Sort the list of elements based on that digit, grouping elements with the same digit into one bucket.
Recursively sort each bucket, starting with the next digit to the right.
Concatenate the buckets together in order.

前第三步是遍历桶，这里我们换成处理桶。什么意思呢？如果从最高位开始，实际上已经能保证大体上是从小到大的递增序列了！但是位数相同时，就不一定了！实际上就是：桶外有序，而桶类无序！
这时候，就是递归的思想起作用了！既然桶外有序，我们就不管桶外了，关注处理桶内的数据。从次高位开始，再建立10个桶，然后把数据放到桶里，按第一次的方式来处理，直到处理到最低位！
MSL的代码稍微有点复杂，要用到递归！

[cpp]  view plain copy print ?   
      
     
 #include   
 #include   
 #include   
 using namespace std;   
 struct Node{   
     int key;   
     struct Node *next;   
     Node(int _key){   
         key=_key;next=NULL;   
     }   
 };   
    
 void sort(int *a,int s,int n,int high){//把数组a中的数据[s,e)进行排序   
     Node *ibuck[10],*itail[10],*p;   
     int i,kth,low,num;   
    
     if(high==1)return;   
     low=high/10;   
     memset(ibuck,0,sizeof(ibuck));   
     for(i=s;i//往桶里扔   
         kth=(a[i]%high)/low;//取出序列中的数，根据位数放置到对应的桶中   
         p=new Node(a[i]);//创建新结点   
         //把数放到对应的桶中 这里一定要接到末尾，而不能从头结点插入   
         ibuck[kth]!=NULL ? itail[kth]->next=p,itail[kth]=p:ibuck[kth]=p,itail[kth]=p;   
     }   
     for(i=0;s//把桶中的数据放回数组中   
         num=0;   
         while(ibuck[i]!=NULL){   
             a[s++]=ibuck[i]->key;   
             num++;  
             p=ibuck[i],ibuck[i]=ibuck[i]->next,delete p;//收回动态开辟的空间   
         }   
         if(num>1)   
             sort(a,s-num,num,high/10); //这个地方我处理了好久  
     }   
 }   
 void base_sort_MSD(int *a,int n){   
     int Max,high,i;   
     for(Max=a[0],i=1;i
     for(high=1;Max/high>0;high*=10);   
     sort(a,0,n,high);   
 }   
 int main(){   
     int n=10;   
     int data[]={1000,50,80000,81000,3,26,467,6987,10953,2354};   
     base_sort_MSD(data,n);   
     for(int i=0;i
         printf("%d ",data[i]);   
 }  

我觉得这个人总结的不错，我后面也借鉴了一点他的。 http://sbp810050504.blog.51cto.com/2799422/1039725 。

留下一个问题：一个文件中存着大量的值在0-1精确到小数点后10位的书然后怎么排好？

好吧，这11种排序算法终于弄完了，不过还有很多没知识点没总结，如他们之间的区别等。这个我之后肯定会补上。现在感觉还理解的不透彻。毕竟刚刚深入的去研究，如果文中又发现错误的地方，希望提出来。

这篇博客中我尽量找的伪代码实现，除非那些比较难理解的伪代码，因为我觉得这是个理论系列，看完之后必须自己去实现一遍，不然等于白看，如果你觉得有些根据伪代码实现不了的，可以到网上找各种语言的代码。

最后推荐一个人的算法专栏：白话经典算法。里面虽然讲的东西不多，但很多作者独到的见解，而且写的比较容易理解，不像我的。。嗨，以后努力改进。

你可能感兴趣的:(算法导论)

时间复杂度分析-大O表示法 ꧁꫞ND꫞꧂ 算法与数据结构
开篇词|从今天起，跨过“数据结构与算法”这道坎你好，我是王争，毕业于西安交通大学计算机专业。现在回想起来，本科毕业的时候，我的编程水平其实是很差的。直到读研究生的时候，一个师兄给了我一本《算法导论》，说你可以看看，对你的编程会很有帮助。没想到，从此我对算法的“迷恋”便一发不可收拾。之后，我如饥似渴地把图书馆里几乎所有数据结构和算法书籍都读了一遍。我常常边读边练。没多久，我就发现，写代码的时候，我会
2025年6月文章一览 python
2025年6月编程人总共更新了3篇文章：1.2025年5月文章一览2.《算法导论(第4版)》阅读笔记：p175-p1813.《BuildingRESTAPIswithFlask》读后感本月在读3本，阅读完一本——《BuildingRESTAPIswithFlask》。读完《BuildingRESTAPIswithFlask》，有两点感受最深：一、学有所用是效果最好的。其实在2019年就接触了Mar
算法导论：动态规划-钢条切割 tttoff 算法动态规划
一、动态规划定义区别于分治法，动态规划（dynamicprogramming）的子问题是有重叠的。常用于最优化问题（optimizationproblem）。二、钢条切割问题2.1步骤分解（1）刻画最优解的结构特征如何得到最大的收益->切割or不切割->则最大收益可以由两个子方案组成，即最大收益=max（不切割的收益，切割的收益）（2）递归地定义最优解的值不切割的收益的已知，则需定义切割的收益。由
算法导论第十四章 B树与B+树：海量数据的守护者 W说编程算法导论数据结构与算法算法 b树 c语言数据结构性能优化
第十四章B树与B+树：海量数据的守护者“数据不是信息，信息不是知识，知识不是理解。”——CliffordStoll在信息爆炸的时代，我们需要高效管理海量数据的能力。B树家族作为数据库和文件系统的基石，完美平衡了磁盘I/O效率和内存利用率，成为处理大规模数据的首选数据结构。14.1B树的诞生背景14.1.1磁盘与内存的速度鸿沟现代计算机系统中，磁盘访问速度比内存慢10万倍以上。当数据量超过内存容量时
算法导论第十八章计算几何：算法中的空间艺术
第十八章计算几何：算法中的空间艺术“几何学是描绘宇宙秩序的永恒诗篇。”——约翰内斯·开普勒计算几何将数学的优雅与算法的实用性完美结合，在计算机图形学、机器人导航和地理信息系统中扮演着关键角色。本章将带您探索几何问题的算法解决方案，从基础的点线关系到复杂的空间剖分，揭示算法如何理解和操纵我们的几何世界。18.1几何基础：点、线和多边形18.1.1几何对象的表示在计算几何中，我们使用简洁的数学结构表示
算法导论第十六章 van Emde Boas树：对数对数的奇迹 W说编程算法导论数据结构与算法算法数据结构 c语言性能优化全文检索数据库
第十六章vanEmdeBoas树：对数对数的奇迹“在数据结构的宇宙中，有些星星的光芒需要特殊工具才能看见。”vanEmdeBoas树（vEB树）是计算机科学中最优雅的数据结构之一，它将整数集合操作的时间复杂度从O(logn)降到了惊人的O(loglogU)。本章将揭开这种神奇结构的面纱，展示它如何在小整数集合处理中实现近乎即时的操作。16.1vEB树的诞生：解决整数集合的瓶颈16.1.1整数集合操
算法导论第十三章红黑树：平衡的艺术 W说编程算法导论数据结构与算法算法 c语言数据结构性能优化 b树排序算法
第十三章红黑树：平衡的艺术“平衡不是静止，而是动态的和谐。”——达芬奇在二叉搜索树的世界中，红黑树如同一位优雅的舞者，在动态操作中保持着完美的平衡。本章将揭开这种高效数据结构的神秘面纱，探索它如何在插入和删除操作中保持优雅姿态。13.1红黑树的诞生：解决BST的致命缺陷13.1.1BST的退化问题在第十二章中，我们看到二叉搜索树在极端情况下会退化为链表，操作复杂度从O(logn)恶化为O(n)。1
算法导论第四章：分治策略的艺术与科学 W说编程算法导论数据结构与算法算法数据结构 c语言性能优化
算法导论第四章：分治策略的艺术与科学本文是《算法导论》精讲专栏第四章，通过问题分解可视化、递归树分析和数学证明，结合完整C语言实现，深入解析分治策略的精髓。包含最大子数组、矩阵乘法、最近点对等经典问题的完整实现与优化技巧。1.分治策略：化繁为简的智慧1.1分治法核心思想原问题分解子问题1子问题2子问题n解决合并最终解分治三步曲：分解：将问题划分为规模更小的子问题解决：递归解决子问题（基线条件直接求
算法导论第五章：概率分析与随机算法的艺术 W说编程算法导论数据结构与算法算法数据结构 c语言概率论
算法导论第五章：概率分析与随机算法的艺术本文是《算法导论》精讲专栏第五章，通过概率模型可视化、随机实验模拟和数学证明，结合完整C语言实现，深入解析概率分析与随机算法的精髓。包含生日悖论、赠券收集、随机快速排序、蓄水池抽样等经典问题的完整实现与数学分析。1.概率分析基础：从直觉到数学1.1生日悖论：违反直觉的概率问题：一个房间需要多少人，才能使其中两人生日相同的概率超过50%？#includedou
《算法导论(第4版)》阅读笔记：p175-p181 算法
《算法导论(第4版)》学习第31天，p175-p181总结，总计7页。一、技术总结无。二、英语总结(生词：1)1.amortize(1)amortize:a-("to")+mortus("dead")vt.amortizeoriginallymeans"tokilloff",overtime,itevolvestomean"topayoffgraduallybyperiodicpaymentsof
[算法导论] 48.旋转图像（原地顺时针旋转90度）心心喵算法导论算法
0.题目1.两次翻转替代旋转classSolution:defrotate(self,matrix]):n=len(matrix)#水平翻转foriinrange(n//2):forjinrange(n):matrix[i][j],matrix[n-i-1][j]=matrix[n-i-1][j],matrix[i][j]#主对角线翻转foriinrange(n):forjinrange(i):m
材料力学优化算法：形状优化：形状优化算法导论_2024-08-08_11-42-05.Tex chenjj4003 材料力学算法人工智能机器学习制造 python 开发语言性能优化
材料力学优化算法：形状优化：形状优化算法导论材料力学与优化的关系在工程设计中，材料力学是理解结构行为和性能的基础。它研究材料在不同载荷下的应力、应变和位移，为设计安全、高效和经济的结构提供理论依据。然而，传统的设计方法往往基于经验或初步假设，可能无法达到最优的设计方案。这时，优化算法，尤其是形状优化算法，就显得尤为重要。形状优化算法通过数学模型和计算方法，自动调整结构的形状，以满足特定的性能目标，
《算法导论(第4版)》阅读笔记：p162-p163 算法
《算法导论(第4版)》学习第28天，p162-p163总结，总计2页。一、技术总结1.heapsort(1)(binary)heap(堆/二叉堆)(2)completebinarytree(完全二叉树)(3)max-heap(最大堆)定义：A[PARENT(i)]≥A[i]。看了很多定义，不得不说还是这个定义最简洁，准确。(4)min-heap(最小堆)定义：A[PARENT(i)]≤A[i]。2
《算法导论(第4版)》阅读笔记：p134-p155 算法
《算法导论(第4版)》学习第26天，p134-p155总结，总计22页。一、技术总结无。二、英语总结(生词：1)1.paradox(1)paradox:para-("contraryto")+doxa("opinion")c/u.asituationthatcontainstwooppositefacts(悖论)。(2)示例"Thisstatementisfalse."isaparadox——If
《算法导论(第4版)》阅读笔记：p127-p133 codists 读书笔记算法
《算法导论(第4版)》学习第24天，p127-p133总结，总计7页。一、技术总结1.probabilisticanalysis(概率分析)(1)定义Probabilisticanalysisistheuseofprobabilityintheanalysisofproblems.2.randomizedalgorithm(1)定义Moregenerally,wecallanalgorithmra
《算法导论(第4版)》阅读笔记：p1178-p1212 算法
《算法导论(第4版)》学习第25天，p1178-p1212总结，总计35页。一、技术总结1.AppendixC:CountingandProbability附录C介绍了计数理论(如：和规则，积规则，串，排列，组合，二项式系数，二项式界等)，概率理论(如：样本空间，事件，概率论公理，离散概率分布，连续均匀概率分布，贝叶斯定理等)，几何分布与二项分布，二项分布的尾部探究。第5章会时不时的涉及这些内容，
《算法导论(第4版)》阅读笔记：p115-p126 算法
《算法导论(第4版)》学习第23天，p101-p114总结，总计14页。一、技术总结无。二、英语总结(生词：1)1.vagary(1)vagary:vagus("roving,wandering(闲逛)")c.originally,vagarymeansphysicalwandering,overtime,itevolvestodescribeunpredictablechanges(变幻莫测)。
[算法导论] 73. 矩阵置零心心喵算法导论算法矩阵动态规划
0.题目矩阵中为0的元素，行列都置0。1.使用标记数组o(mn)o(m+n)classSolution:defsetZeroes(self,matrix):"""Donotreturnanything,modifymatrixin-placeinstead."""rows=[False]*(len(matrix))columns=[False]*(len(matrix[0]))#False：该行没
《算法导论(第4版)》阅读笔记：p101-p114 算法
《算法导论(第4版)》学习第22天，p101-p114总结，总计14页。一、技术总结1.themastertheorem(主定理)二、英语总结(生词：1)1.encompass(1)compass:com-("with,together")+passus("astep")compassliterallymeans"tosteptogether",reflectingtheideaofencircl
《算法导论(第4版)》阅读笔记：p95-p100 算法
《算法导论(第4版)》学习第21天，p95-p100总结，总计6页。一、技术总结无。二、英语总结(生词：1)1.intuition(1)intuit:in-("into")+tueri("tolookat,whatover,看")vt.tounderstandsomethingimmediatelybasedonyourfeelingratherthanfacts(凭直觉知道)。(2)intuit
《算法导论(第4版)》阅读笔记：p91-p94 算法
《算法导论(第4版)》学习第20天，p91-p94总结，总计4页。一、技术总结1.recursiontreeIngraphtheory,arecursivetree(i.e.,unorderedtree)isalabeled,rootedtree.Asize-nrecursivetree'sverticesarelabeledbydistinctpositiveintegers1,2,…,n,wh
《算法导论(第4版)》阅读笔记：p86-p90 算法
《算法导论(第4版)》学习第19天，p83-p85总结，总计3页。一、技术总结无。二、英语总结(生词：2)1.inkling(1)inkling:inclen("utterinanundertone，低声说话")c.ahint(提示)；aslightknowledge(一点点知识，浅薄的认知，强调程度轻微，有限。翻译的时候转成动词翻译较好)。(2)示例Togetaninklinghowthenum
《算法导论(第4版)》阅读笔记：p59-p75 codists 读书笔记算法
《算法导论(第4版)》学习第15天，p59-p75总结，总计17页。一、技术总结1.floor(向下取整)andceiling(向上取整)Foranyrealnumberx,wedenotethegreatestintegerlessthanorequaltoxby⌊x⌋(read‘thefloorofx’)andtheleastintegergreaterthanorequaltoxby⌈x⌉(
《算法导论(第4版)》阅读笔记：p76-p81 codists 读书笔记算法
《算法导论(第4版)》学习第16天，p76-p81总结，总计7页。一、技术总结1.densematrix(密集矩阵)&sparsematrix(稀疏矩阵)、(1)定义Generally,we’llassumethatthematricesaredense,meaningthatmostofthen²entriesarenot0,asopposedtosparse,wheremostofthen²e
《算法导论(第4版)》阅读笔记：p82-p82 codists 读书笔记算法
《算法导论(第4版)》学习第17天，p82-p82总结，总计1页。一、技术总结1.MatrixMatrices(矩阵)(1)教材因为第4章涉及到矩阵，矩阵属于线性代数(linearalgebra)范畴，如果不熟悉，可以看一下作者推荐的两本教材：GilbertStrang的《IntroductiontoAppliedMathematics》和《LinearAlgebraandItsApplicati
《算法导论(第4版)》阅读笔记：p83-p85 算法
《算法导论(第4版)》学习第18天，p83-p85总结，总计3页。一、技术总结1.Strassenalgorithm(施特拉森算法)2.矩阵(1)矩阵表示法Ifwewishtorefertomatriceswithoutspecificallywritingoutalltheirentries,wewilluseuppercaseA,B,C,andsoon.Ingeneral,aᵢⱼwillden
《算法导论(第4版)》阅读笔记：p76-p81 算法
《算法导论(第4版)》学习第16天，p76-p81总结，总计7页。一、技术总结1.densematrix(密集矩阵)&sparsematrix(稀疏矩阵)、(1)定义Generally,we’llassumethatthematricesaredense,meaningthatmostofthen²entriesarenot0,asopposedtosparse,wheremostofthen²e
《算法导论(第4版)》阅读笔记：p59-p75 算法
《算法导论(第4版)》学习第15天，p59-p75总结，总计17页。一、技术总结1.floor(向下取整)andceiling(向上取整)Foranyrealnumberx,wedenotethegreatestintegerlessthanorequaltoxby⌊x⌋(read'thefloorofx')andtheleastintegergreaterthanorequaltoxby⌈x⌉(
《算法导论(第4版)》阅读笔记：p49-p58 算法
《算法导论(第4版)》学习第14天，p49-p58总结，总计10页。一、技术总结1.O-notation,Ω-notation,and‚Θ-notation(1)O-notationO-notationdescribesanasymptoticupperbound.(2)Ω-notationΩ-notationdescribesanasymptoticlowerbound.(3)Θ-notatio
《算法导论(第4版)》阅读笔记：p39-p48 算法
《算法导论(第4版)》学习第13天，p39-p48总结，总计10页。一、技术总结1.recurrence/recurrenceequation书里面recurrence(递归式)和recurrenceequation(递归方程)指的是同一个东西。二、英语总结(生词：2)1.squint(1)squintvi.lookaskance(斜视)；lookatthingswitheyespartlyclo
312个免费高速HTTP代理IP（能隐藏自己真实IP地址） yangshangchuan 高速免费 superword HTTP代理
124.88.67.20:843 190.36.223.93:8080 117.147.221.38:8123 122.228.92.103:3128 183.247.211.159:8123 124.88.67.35:81 112.18.51.167:8123 218.28.96.39:3128 49.94.160.198:3128 183.20
pull解析和json编码百合不是茶 android pull解析 json
n.json文件: [{name:java,lan:c++,age:17},{name:android,lan:java,age:8}] pull.xml文件 <?xml version="1.0" encoding="utf-8"?> <stu> <name>java
[能源与矿产]石油与地球生态系统 comsci 能源
按照苏联的科学界的说法,石油并非是远古的生物残骸的演变产物,而是一种可以由某些特殊地质结构和物理条件生产出来的东西,也就是说,石油是可以自增长的.... 那么我们做一个猜想: 石油好像是地球的体液,我们地球具有自动产生石油的某种机制,只要我们不过量开采石油,并保护好
类与对象浅谈沐刃青蛟 java 基础
类，字面理解，便是同一种事物的总称，比如人类，是对世界上所有人的一个总称。而对象，便是类的具体化，实例化，是一个具体事物，比如张飞这个人，就是人类的一个对象。但要注意的是：张飞这个人是对象，而不是张飞，张飞只是他这个人的名字，是他的属性而已。而一个类中包含了属性和方法这两兄弟，他们分别用来描述对象的行为和性质（感觉应该是
新站开始被收录后，我们应该做什么？ IT独行者 PHP seo
新站开始被收录后，我们应该做什么？百度终于开始收录自己的网站了，作为站长，你是不是觉得那一刻很有成就感呢，同时，你是不是又很茫然，不知道下一步该做什么了？至少我当初就是这样，在这里和大家一份分享一下新站收录后，我们要做哪些工作。至于如何让百度快速收录自己的网站，可以参考我之前的帖子《新站让百
oracle 连接碰到的问题文强chu oracle
Unable to find a java Virtual Machine－－安装64位版Oracle11gR2后无法启动SQLDeveloper的解决方案作者：草根IT网来源：未知人气：813标签：导读：安装64位版Oracle11gR2后发现启动SQLDeveloper时弹出配置java.exe的路径，找到Oracle自带java.exe后产生的路径“C:\app\用户名\prod
Swing中按ctrl键同时移动鼠标拖动组件（类中多借口共享同一数据）小桔子 java 继承 swing 接口监听
都知道java中类只能单继承，但可以实现多个接口，但我发现实现多个接口之后，多个接口却不能共享同一个数据，应用开发中想实现：当用户按着ctrl键时，可以用鼠标点击拖动组件，比如说文本框。编写一个监听实现KeyListener,NouseListener,MouseMotionListener三个接口，重写方法。定义一个全局变量boolea
linux常用的命令 aichenglong linux 常用命令
1 startx切换到图形化界面 2 man命令:查看帮助信息 man 需要查看的命令,man命令提供了大量的帮助信息,一般可以分成4个部分 name:对命令的简单说明 synopsis:命令的使用格式说明 description:命令的详细说明信息 options:命令的各项说明 3 date:显示时间语法：date [OPTION]... [+FORMAT]
eclipse内存优化 AILIKES java eclipse jvm jdk
一基本说明在JVM中，总体上分2块内存区,默认空余堆内存小于 40%时，JVM就会增大堆直到-Xmx的最大限制；空余堆内存大于70%时，JVM会减少堆直到-Xms的最小限制。 1)堆内存(Heap memory):堆是运行时数据区域，所有类实例和数组的内存均从此处分配,是Java代码可及的内存，是留给开发人
关键字的使用探讨百合不是茶关键字
//关键字的使用探讨/*访问关键词private 只能在本类中访问public 只能在本工程中访问protected 只能在包中和子类中访问默认的只能在包中访问*//*final 类方法变量 final 类不能被继承 final 方法不能被子类覆盖，但可以继承 final 变量只能有一次赋值，赋值后不能改变 final 不能用来修饰构造方法*///this()
JS中定义对象的几种方式 bijian1013 js
1. 基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)： <html> <head> <title>基于已有对象扩充其对象和方法(只适合于临时的生成一个对象)</title> </head> <script> var obj = new Object();
表驱动法实例 bijian1013 java 表驱动法 TDD
获得月的天数是典型的直接访问驱动表方式的实例，下面我们来展示一下： MonthDaysTest.java package com.study.test; import org.junit.Assert; import org.junit.Test; import com.study.MonthDays; public class MonthDaysTest { @T
LInux启停重启常用服务器的脚本 bit1129 linux
启动，停止和重启常用服务器的Bash脚本，对于每个服务器，需要根据实际的安装路径做相应的修改 #! /bin/bash Servers=(Apache2, Nginx, Resin, Tomcat, Couchbase, SVN, ActiveMQ, Mongo); Ops=(Start, Stop, Restart); currentDir=$(pwd); echo
【HBase六】REST操作HBase bit1129 hbase
HBase提供了REST风格的服务方便查看HBase集群的信息，以及执行增删改查操作 1. 启动和停止HBase REST 服务 1.1 启动REST服务前台启动（默认端口号8080） [hadoop@hadoop bin]$ ./hbase rest start 后台启动 hbase-daemon.sh start rest 启动时指定
大话zabbix 3.0设计假设 ronin47
What’s new in Zabbix 2.0? 去年开始使用Zabbix的时候，是1.8.X的版本，今年Zabbix已经跨入了2.0的时代。看了2.0的release notes，和performance相关的有下面几个： :: Performance improvements::Trigger related da
http错误码大全 byalias http协议 javaweb
响应码由三位十进制数字组成，它们出现在由HTTP服务器发送的响应的第一行。响应码分五种类型，由它们的第一位数字表示： 1）1xx：信息，请求收到，继续处理 2）2xx：成功，行为被成功地接受、理解和采纳 3）3xx：重定向，为了完成请求，必须进一步执行的动作 4）4xx：客户端错误，请求包含语法错误或者请求无法实现 5）5xx：服务器错误，服务器不能实现一种明显无效的请求
J2EE设计模式-Intercepting Filter bylijinnan java 设计模式数据结构
Intercepting Filter类似于职责链模式有两种实现其中一种是Filter之间没有联系，全部Filter都存放在FilterChain中，由FilterChain来有序或无序地把把所有Filter调用一遍。没有用到链表这种数据结构。示例如下： package com.ljn.filter.custom; import java.util.ArrayList;
修改jboss端口 chicony jboss
修改jboss端口 %JBOSS_HOME%\server\{服务实例名}\conf\bindingservice.beans\META-INF\bindings-jboss-beans.xml 中找到 <!-- The ports-default bindings are obtained by taking the base bindin
c++ 用类模版实现数组类 CrazyMizzz C++
最近c++学到数组类，写了代码将他实现，基本具有vector类的功能 #include<iostream> #include<string> #include<cassert> using namespace std; template<class T> class Array { public: //构造函数
hadoop dfs.datanode.du.reserved 预留空间配置方法 daizj hadoop 预留空间
对于datanode配置预留空间的方法为：在hdfs-site.xml添加如下配置 <property> <name>dfs.datanode.du.reserved</name> <value>10737418240</value>
mysql远程访问的设置 dcj3sjt126com mysql 防火墙
第一步: 激活网络设置你需要编辑mysql配置文件my.cnf. 通常状况，my.cnf放置于在以下目录： /etc/mysql/my.cnf (Debian linux) /etc/my.cnf （Red Hat Linux/Fedora Linux) /var/db/mysql/my.cnf (FreeBSD) 然后用vi编辑my.cnf，修改内容从以下行： [mysqld] 你所需要: 1
ios 使用特定的popToViewController返回到相应的Controller dcj3sjt126com controller
1、取navigationCtroller中的Controllers NSArray * ctrlArray = self.navigationController.viewControllers; 2、取出后，执行， [self.navigationController popToViewController:[ctrlArray objectAtIndex:0] animated:YES
Linux正则表达式和通配符的区别 eksliang 正则表达式通配符和正则表达式的区别通配符
转载请出自出处：http://eksliang.iteye.com/blog/1976579 首先得明白二者是截然不同的通配符只能用在shell命令中,用来处理字符串的的匹配。判断一个命令是否为bash shell(linux 默认的shell)的内置命令 type -t commad 返回结果含义 file 表示为外部命令 alias 表示该
Ubuntu Mysql Install and CONF gengzg Install
http://www.navicat.com.cn/download/navicat-for-mysql Step1: 下载Navicat ，网址：http://www.navicat.com/en/download/download.html Step2：进入下载目录，解压压缩包：tar -zxvf navicat11_mysql_en.tar.gz
批处理，删除文件bat huqiji windows dos
@echo off ::演示：删除指定路径下指定天数之前（以文件名中包含的日期字符串为准）的文件。 ::如果演示结果无误，把del前面的echo去掉，即可实现真正删除。 ::本例假设文件名中包含的日期字符串（比如：bak-2009-12-25.log） rem 指定待删除文件的存放路径 set SrcDir=C:/Test/BatHome rem 指定天数 set DaysAgo=1
跨浏览器兼容的HTML5视频音频播放器天梯梦 html5
HTML5的video和audio标签是用来在网页中加入视频和音频的标签，在支持html5的浏览器中不需要预先加载Adobe Flash浏览器插件就能轻松快速的播放视频和音频文件。而html5media.js可以在不支持html5的浏览器上使video和audio标签生效。 How to enable <video> and <audio> tags in
Bundle自定义数据传递 hm4123660 android Serializable 自定义数据传递 Bundle Parcelable
我们都知道Bundle可能过put****()方法添加各种基本类型的数据，Intent也可以通过putExtras(Bundle)将数据添加进去，然后通过startActivity()跳到下一下Activity的时候就把数据也传到下一个Activity了。如传递一个字符串到下一个Activity 把数据放到Intent
C＃：异步编程和线程的使用（.NET 4.5 ） powertoolsteam .net 线程 C#异步编程
异步编程和线程处理是并发或并行编程非常重要的功能特征。为了实现异步编程，可使用线程也可以不用。将异步与线程同时讲，将有助于我们更好的理解它们的特征。本文中涉及关键知识点 1. 异步编程 2. 线程的使用 3. 基于任务的异步模式 4. 并行编程 5. 总结异步编程什么是异步操作？异步操作是指某些操作能够独立运行，不依赖主流程或主其他处理流程。通常情况下，C＃程序
spark 查看 job history 日志 Stark_Summer 日志 spark history job
SPARK_HOME/conf 下: spark-defaults.conf 增加如下内容 spark.eventLog.enabled true spark.eventLog.dir hdfs://master:8020/var/log/spark spark.eventLog.compress true spark-env.sh 增加如下内容 export SP
SSH框架搭建 wangxiukai2015eye spring Hibernate struts
MyEclipse搭建SSH框架 Struts Spring Hibernate 1、new一个web project。 2、右键项目，为项目添加Struts支持。选择Struts2 Core Libraries -<MyEclipes-Library> 点击Finish。src目录下多了struts