算法导论——第五章——线性时间排序

 

1.决策树模型

比较排序的过程可以被抽象地视为决策树。一棵决策树是一棵满二叉树，表示某排序算法作用于给定输入所做的所有比较。排序算法的执行对应于遍历一条从树的根到叶节点的路径。每个内结点对应一个比较ai&aj，左子树决定着ai<=aj以后的比较，右子树决定着ai>aj以后的比较。当到达一个叶节点时，排序算法就已确定。排序算法能够正确工作的的必要条件是，n个元素的n！种排列都要作为决策树的一个叶节点出现。设决策树的高度为h，叶子数目为l，那么有 2^h>=l>=n!，于是有 h>lgn! = Ω(nlgn)。 这说明比较排序的最坏时间复杂度为Ω(nlgn)。这也说明合并排序和堆排序的复杂度已经渐进最优了。

2.计数排序

假设n个输入元素的每一个都是介于0到k之间的整数，此处k为某个整数。当k=O(n)时，计数排序的运行时间为Θ(n)。 计数排序的思想就是对每一个输入元素x，确定出小于x的元素个数。有了这一信息，就可以把x直接放到最终输出数组的位置上。

假定输入是数组A[1...n], 存放排序结果的B[1...n]，以及提供计数临时存储的C[0...k]。

COUNTING-SORT(A,B,k)jk

1    for  i<- 0 to k

2        do C[i] i<- 0 //初始化临时存储数组

3    for j i<-1 to length[A]

4        do C[A[j]] =C[A[j]]+1

//到此时C[i]中数值表示A中等于i的元素个数

5    for i <-1 to k

6        do C[i] = C[i] + C[i-1]

//到此时C[i]中数值表示A中等于小鱼等于i的元素个数

7    for i <- length[A] downto 1

8        do B[C[A[i]] = A[i]

9             C[A[i]] = C[A[i]] -1  //important

第七行，从length[A] downto 1是为了正确解决由相同元素时的排序情况，保证算法稳定。若改为for i<- 1 upto length[A]，则排序不稳定。

05	#include <vector>

06	#include <iostream>

07	using namespace std;

08	//此程序是实现计数排序算法，要特别注意指标问题

10	void counting_sort(vector<int> A, vector<int>& B, int k);

11	int main()

12

{

13	int a[]={1,4,3,2,0,4,3,5,7,5,4,6,7,8,5,9,6,4,3,4,0};

14

int k=9;

15	vector<int> A(a,a+20);

16	vector<int> B(20,0);

17	counting_sort(A, B, k);

18	vector<int>::iterator i;

19	for(i=B.begin();i!=B.end();i++)

20	cout<<*i<<"  ";

21

return 0;

22

}

23

24	void counting_sort(vector<int> A, vector<int>& B, int k)

25

{

26	vector<int> C(k+1,0);

27	//统计A中重复元素的个数，C的指标表示这个元素的值，C的值表示对应元素的个数

28	for(int j=0;j<A.size();j++)

29	C[A[j]]=C[A[j]]+1;

30	//统计这个值在数组中的放置的位置，即排在第几位

31	for(int i=1;i<=k;i++)

32	C[i]=C[i]+C[i-1];

33	//一次将A中的每个元素放到正确的位置，计入数组下标应从0开始，因此用C[A[j]]减去1

34	for(int j=A.size()-1;j>=0;j--)

35

{

36	B[C[A[j]]-1]=A[j];

37	C[A[j]]=C[A[j]]-1;

38

}

39

}

3.基数排序

基本思想：按组成关键字的各个位的值来实现排序的

基数：计算的基数就是基本的单元数。比如10进制的基数就是10，二进制的基数就2，八进制的基数是8等等。

基数排序说通俗点，就是把带排序的N个数字右对齐排成一列。然后把相同的位数互相比较，来排序

 6 #include <iostream>
 7 #include <cstring>
 8 using namespace std;
 9  
10 int arr[100], res[100], hash[10];
11 int n;
12  
13 int maxbit()
14 {
15        int _max = 0;
16        int temp[100];
17        for(int i=0; i<n; ++i)
18            temp[i] = arr[i];
19  
20        for (int i=0; i<n; ++i)
21        {
22               int tt = 1;
23               while(temp[i]/10 > 0)
24               {
25                      tt++;
26                      temp[i] /= 10;
27               }
28               if(_max < tt)
29                      _max = tt;
30        }
31        cout << "_max : " << _max << endl;
32        return _max;
33 }
34  
35 void radixSort()
36 {
37     memset(res, 0, sizeof(res));
38     int nbit = maxbit();
39     int tmp;
40     int radix = 1;
41     // 以下和计数排序一样
42     for(int i=1; i<=nbit; ++i)
43     {
44         for(int j=0; j<10; ++j)
45             hash[j] = 0;
46         for(int j=0; j<n; ++j)
47         {
48             tmp = (arr[j]/radix)%10;
49             ++hash[tmp];
50         }
51         for(int j=1; j<10; ++j)
52             hash[j] += hash[j-1];
53         for(int j=n-1; j>=0; --j)
54         {
55             tmp = (arr[j]/radix)%10;
56             --hash[tmp];
57             res[hash[tmp]] = arr[j];
58         }
59         for(int j=0; j<n; ++j)
60             arr[j] = res[j];
61         radix *= 10;
62     }
63 }
64  
65 int main()
66 {
67     freopen("input.txt", "r", stdin);
68     cout << "输入元素个数: ";
69     cin >> n;
70     cout << "输入" << n << "个元素: " << endl;
71     for(int i=0; i<n; ++i)
72         cin >> arr[i];
73     radixSort();
74     cout << "排序后结果为: " << endl;
75     for(int i=0; i<n; ++i)
76         cout << res[i] << " ";
77     cout << endl;
78 }

4.桶排序（期望时间复杂度O(n)）

桶排序算法想法类似于散列表

首先要假设待排序的元素输入符合某种均匀分布，例如数据均匀分布在[ 0,1）区间上.

则可将此区间划分为10个小区间，称为桶，每个桶存放一个链表，对散布到同一个桶

中的元素在排序。

01	// bucketsort.cpp : 定义控制台应用程序的入口点。

02	// 桶排序算法，要用到前面的堆排序算法进行桶内的排序

03	//肖成 2011/3/28

04	#include "vectorheap.h"

05	#include <iostream>

06	#include <list>

07	#include <algorithm>

08	#include <cstdlib>

09	using namespace std;

10

11	vector<vector<double>> bucket_sort(vector<double> vec);

12

13	int main()

14

{

15	double a[]={0.34,0.21,0.41,0.11,0.32,0.42,0.22,0.51,0.62,0.71};

16

17	vector<double> vec(a,a+10);

18	vector<vector<double>> lstvec;

19

20	lstvec=bucket_sort(vec);

21	vector<double>::iterator vecIter;

22	vector<vector<double>>::iterator lstIter;

23

24	for(lstIter=lstvec.begin(); lstIter!=lstvec.end();lstIter++)

25

{

26	for(vecIter=(*lstIter).begin();vecIter!=(*lstIter).end();vecIter++)

27	cout<<*vecIter<<"  ";

28

}

29	cout<<endl;

30

return 0;

31

}

32

33

//从大到小排序

34	vector<vector<double>> bucket_sort(vector<double> vec)

35

{

36	int n=vec.size();

37	vector<vector<double>> lst(n);

38	vector<vector<double>>::iterator iter;

39

40	//计算散布到桶的位置，因为是从大到小所以要倒序散布

41	for(int i=0;i<n;i++)

42	lst.at((int)(n-n*vec.at(i))).push_back(vec.at(i));

43

44	for(int i=n-1; i>=0; i--)

45

{

46	//对桶内的元素进行堆排序

47	vectorheap<double> vecheap(lst.at(i));

48	lst.at(i)=vecheap.sortHeap();

49

}

50	return lst;

51

}