排序
1 #include<stdio.h>
2 #include<iostream>
3 using namespace std;
4
5
6 void print(int a[], int n){
7 for(int j= 0; j<n; j++){
8 cout<<a[j] <<" ";
9 }
10 cout<<endl;
11 }
12
13
14
15 /**
16 * 已知H[s…m]除了H[s] 外均满足堆的定义
17 * 调整H[s],使其成为大顶堆.即将对第s个结点为根的子树筛选,
18 *
19 * @param H是待调整的堆数组
20 * @param s是待调整的数组元素的位置
21 * @param length是数组的长度
22 *
23 */
24 void HeapAdjust(int H[],int s, int length)
25 {
26 int tmp = H[s];
27 int child = 2*s+1; //左孩子结点的位置。(i+1 为当前调整结点的右孩子结点的位置)
28 while (child < length) {
29 if(child+1 <length && H[child]<H[child+1]) { // 如果右孩子大于左孩子(找到比当前待调整结点大的孩子结点)
30 ++child ;
31 }
32 if(H[s]<H[child]) { // 如果较大的子结点大于父结点
33 H[s] = H[child]; // 那么把较大的子结点往上移动，替换它的父结点
34 s = child; // 重新设置s ,即待调整的下一个结点的位置
35 child = 2*s+1;
36 } else { // 如果当前待调整结点大于它的左右孩子，则不需要调整，直接退出
37 break;
38 }
39 H[s] = tmp; // 当前待调整的结点放到比其大的孩子结点位置上
40 }
41 print(H,length);
42 }
43
44
45 /**
46 * 初始堆进行调整
47 * 将H[0..length-1]建成堆
48 * 调整完之后第一个元素是序列的最小的元素
49 */
50 void BuildingHeap(int H[], int length)
51 {
52 //最后一个有孩子的节点的位置 i= (length -1) / 2
53 for (int i = length/2 -1 ; i >= 0; --i)
54 HeapAdjust(H,i,length);
55 }
56 /**
57 * 堆排序算法
58 */
59 void HeapSort(int H[],int length)
60 {
61 //初始堆
62 BuildingHeap(H, length);
63 //从最后一个元素开始对序列进行调整
64 for (int i = length - 1; i > 0; --i)
65 {
66 //交换堆顶元素H[0]和堆中最后一个元素
67 int temp = H[i]; H[i] = H[0]; H[0] = temp;
68 //每次交换堆顶元素和堆中最后一个元素之后，都要对堆进行调整
69 HeapAdjust(H,0,i);
70 }
71 }
72
73 int main(){
74 int H[10] = {3,1,5,7,2,4,9,6,10,8};
75 cout<<"初始值：";
76 print(H,10);
77 HeapSort(H,10);
78 //selectSort(a, 8);
79 cout<<"结果：";
80 print(H,10);
81
82 }
基数排序
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<windows.h>
4
5 typedef struct node
6 {
7 int nValue;
8 struct node *pNext;
9 }MyRadix;
10
11 void Sort(int arr[],int nLength,int nBase)
12 {
13 int nNum = 1;
14 MyRadix **pRadix = NULL;
15 int i;
16 int nIndex;
17 MyRadix *pTemp = NULL;
18 MyRadix *pMark = NULL;
19
20 //求被除数
21 while(nBase > 1)
22 {
23 nNum*=10;
24 nBase--;
25 }
26
27 //申请桶
28 pRadix = (MyRadix**)malloc(sizeof(MyRadix*) * 10);
29 memset(pRadix,0,sizeof(MyRadix*) * 10);
30
31 for(i = 0;i<nLength;i++)
32 {
33 nIndex = arr[i]/nNum%10;
34
35 pTemp = (MyRadix*)malloc(sizeof(MyRadix));
36 pTemp->nValue = arr[i];
37 pTemp->pNext = NULL;
38
39 //尾添加
40 if(pRadix[nIndex] == NULL)
41 {
42 pRadix[nIndex] = pTemp;
43 }
44 else
45 {
46 pMark = pRadix[nIndex];
47 while(pMark->pNext != NULL)
48 {
49 pMark = pMark->pNext;
50 }
51 pMark->pNext = pTemp;
52 }
53 }
54
55 //将元素放回原数组
56 nBase = 0;
57 for(i = 0;i<10;i++)
58 {
59 pMark = pRadix[i];
60 while(pMark)
61 {
62 arr[nBase] = pMark->nValue;
63 nBase++;
64 pMark = pMark->pNext;
65 }
66 }
67
68 //释放空间
69 for(i = 0;i<10;i++)
70 {
71 pMark = pRadix[i];
72 while(pMark)
73 {
74 pTemp = pMark;
75 pMark = pMark->pNext;
76 free(pTemp);
77 pTemp = NULL;
78 }
79 }
80
81 free(pRadix);
82 pRadix = NULL;
83 }
84
85 void RadixSort(int arr[],int nLength)
86 {
87 int nMax;
88 int i;
89 int nLoopTimes;
90 if(arr == NULL || nLength <=0)return;
91
92 //找最大值
93 nMax = arr[0];
94 for(i = 1;i<nLength;i++)
95 {
96 if(arr[i] > nMax)
97 {
98 nMax = arr[i];
99 }
100 }
101 //获得入桶次数
102 nLoopTimes = 0;
103 while(nMax)
104 {
105 nMax/=10;
106 nLoopTimes++;
107 }
108
109 //各个位入桶
110 for(i = 1;i<=nLoopTimes;i++)
111 {
112 //当前位入桶
113 Sort(arr,nLength,i);
114 }
115
116 }
117
118 int main()
119 {
120 int arr[] = {24,23,34,270,18,29,110,220,19,46,32};
121 int i;
122 RadixSort(arr,sizeof(arr)/sizeof(arr[0]));
123 for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
124 {
125 printf("%d ",arr[i]);
126 }
127 return 0;
128 }
桶排序
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<windows.h>
4
5 typedef struct node
6 {
7 int nValue;
8 struct node *pPre;
9 struct node *pNext;
10 }MyBucket;
11
12 //创建桶
13 MyBucket **CreateBucket(int arr[],int nLength,int *pSize)
14 {
15 int nMax;
16 int nMin;
17 int nMaxIndex;
18 int nMinIndex;
19 int i;
20 int nNum;
21 int nIndex;
22 MyBucket *pTemp = NULL;
23 MyBucket **pBucket = NULL;
24
25 if(arr == NULL || nLength <=0)return NULL;
26
27 //查询最大值最小值
28 nMax = arr[0];
29 nMin = arr[0];
30 for(i = 1;i<nLength;i++)
31 {
32 if(arr[i] > nMax)
33 {
34 nMax = arr[i];
35 }
36 if(arr[i] < nMin)
37 {
38 nMin = arr[i];
39 }
40 }
41
42 //计算位数
43 nNum = nMax;
44 i = 0;
45 while(nNum >0)
46 {
47 i++;
48 nNum/=10;
49 }
50
51 //计算被除数
52 nNum = 1;
53 while(i >1)
54 {
55 nNum*=10;
56 i--;
57 }
58
59 //根据最大值最小值建桶
60 nMaxIndex = nMax/nNum;
61 nMinIndex = nMin/nNum;
62 *pSize = nMaxIndex-nMinIndex+1;
63
64 pBucket = (MyBucket**)malloc(sizeof(MyBucket*)*(nMaxIndex-nMinIndex+1));
65 memset(pBucket,0,sizeof(MyBucket*)*(nMaxIndex-nMinIndex+1));
66
67 for(i = 0;i<nLength;i++)
68 {
69 nIndex = arr[i]/nNum - nMinIndex;
70
71 pTemp = (MyBucket*)malloc(sizeof(MyBucket));
72 pTemp->nValue = arr[i];
73 pTemp->pPre = NULL;
74
75 //双向链表头添加
76 pTemp->pNext = pBucket[nIndex];
77
78 if(pBucket[nIndex] != NULL)
79 {
80 pBucket[nIndex]->pPre = pTemp;
81 }
82
83 pBucket[nIndex] = pTemp;
84 }
85
86 return pBucket;
87 }
88
89 void Sort(MyBucket *pHead)
90 {
91 MyBucket *pLast= NULL; //有序的最后一个
92 MyBucket *pFirst = NULL; //无序的第一个
93 int nNum;
94
95 pFirst = pHead->pNext;
96
97 while(pFirst != NULL)
98 {
99 //有序数组的最后一个 是无序数组的前一个
100 pLast = pFirst->pPre;
101
102 //标记待插入值
103 nNum = pFirst->nValue;
104
105 //将无序元素放入有序数组
106 while(pLast != NULL && pLast->nValue > nNum)
107 {
108 pLast->pNext->nValue = pLast->nValue;
109 pLast = pLast->pPre;
110 }
111
112 //到达链表头的情况
113 if(pLast == NULL)
114 {
115 pHead->nValue = nNum;
116 }
117 else
118 {
119 pLast->pNext->nValue = nNum;
120 }
121
122 pFirst = pFirst->pNext;
123 }
124 }
125 void BucketSort(int arr[],int nLength)
126 {
127 MyBucket **pBucket = NULL;
128 int i;
129 int nSize;
130 int j;
131 MyBucket *pMark = NULL;
132 MyBucket *pDel = NULL;
133
134 if(arr == NULL || nLength <=0)return;
135
136 pBucket = CreateBucket(arr,nLength,&nSize);
137
138 //各桶内进行排序
139 for(i = 0;i<nSize;i++)
140 {
141 if(pBucket[i] != NULL)
142 {
143 Sort(pBucket[i]);
144 }
145 }
146
147 //元素放回原数组
148 j = 0;
149 for(i = 0;i<nSize;i++)
150 {
151 pMark = pBucket[i];
152 while(pMark)
153 {
154 arr[j] = pMark->nValue;
155 pMark = pMark->pNext;
156 j++;
157 }
158 }
159 //空间释放
160 for(i = 0;i<nSize;i++)
161 {
162 pMark = pBucket[i];
163 while(pMark)
164 {
165 pDel = pMark;
166 pMark = pMark->pNext;
167 free(pDel);
168 pDel = NULL;
169 }
170 }
171
172 free(pBucket);
173 pBucket = NULL;
174 }
175
176
177 int main()
178 {
179 int arr[] = {150,234,343,270,128,239,110,220,119,246,342};
180 int i;
181 BucketSort(arr,sizeof(arr)/sizeof(arr[0]));
182 for(i = 0;i<sizeof(arr)/sizeof(arr[0]);i++)
183 {
184 printf("%d ",arr[i]);
185 }
186 return 0;
187 }
