冒泡法、选择法、快速、归并、堆排序算法实现

  1 #include <iostream>
  2 #include <string.h>
  3
  4 using namespace std;
  5
  6 #define ARRAY_SIZE 10
  7
  8 int g_bubble_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
  9 int g_selection_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
 10 int g_quick_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
 11 int g_merge_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
 12 int g_heap_sort[ARRAY_SIZE] = {3, 1, 5, 9, 12, 7, 8, 13, 4, 2};
 13 int g_binary_search[ARRAY_SIZE] = {1, 2, 3, 4, 5, 7, 8, 9, 12, 13};
 14
 15 int binary_search(int arr[], int startIdx, int endIdx, int ele);
 16 void bubble_sort(int arr[], int startIdx, int endIdx);
 17 void selection_sort(int arr[], int startIdx, int endIdx);
 18 int partion(int arr[], int startIdx, int endIdx);
 19 int partion2(int arr[], int startIdx, int endIdx);
 20 void quick_sort(int arr[], int startIdx, int endIdx);
 21 void merge_sort(int arr[], int startIdx, int endIdx);
 22 void merge(int arr[], int startIdx, int mid, int endIdx);
 23 void heap_sort(int arr[], int startIdx, int endIdx);
 24 void build_max_heap(int arr[], int len);
 25 void max_heapify(int arr[], int len, int root);
 26
 27
 28 int main()
 29 {
 30     cout << "bubble_sort: \t";
 31     bubble_sort(g_bubble_sort, 0, ARRAY_SIZE - 1);
 32     for(int i=0; i<ARRAY_SIZE; i++)
 33     {
 34         cout<<g_bubble_sort[i] << "\t";
 35     }
 36     cout << "\n";
 37
 38     cout << "selction_sort: \t";
 39     selection_sort(g_selection_sort, 0, ARRAY_SIZE - 1);
 40     for(int i=0; i<ARRAY_SIZE; i++)
 41     {
 42         cout<<g_selection_sort[i] << "\t";
 43     }
 44     cout << "\n";
 45
 46     cout << "quick_sort: \t";
 47     quick_sort(g_quick_sort, 0, ARRAY_SIZE - 1);
 48     for(int i=0; i<ARRAY_SIZE; i++)
 49     {
 50         cout<<g_quick_sort[i] << "\t";
 51     }
 52     cout << "\n";
 53
 54     cout << "merge_sort: \t";
 55     merge_sort(g_merge_sort, 0, ARRAY_SIZE - 1);
 56     for(int i=0; i<ARRAY_SIZE; i++)
 57     {
 58         cout<<g_merge_sort[i] << "\t";
 59     }
 60     cout << "\n";
 61
 62     cout << "heap_sort: \t";
 63     heap_sort(g_heap_sort, 0, ARRAY_SIZE - 1);
 64     for(int i=0; i<ARRAY_SIZE; i++)
 65     {
 66         cout<<g_heap_sort[i] << "\t";
 67     }
 68
 69     cout << "\n";
 70     cout << binary_search(g_bubble_sort, 0, ARRAY_SIZE - 1, 8) << endl;
 71     cout << binary_search(g_selection_sort, 0, ARRAY_SIZE - 1, 8) << endl;
 72     cout << binary_search(g_quick_sort, 0, ARRAY_SIZE - 1, 8) << endl;
 73     cout << binary_search(g_merge_sort, 0, ARRAY_SIZE - 1, 8) << endl;
 74     cout << binary_search(g_heap_sort, 0, ARRAY_SIZE - 1, 8) << endl;
 75     return 0;
 76 }
 77
 78
 79 void bubble_sort(int arr[], int startIdx, int endIdx)
 80 {
 81     int len = endIdx - startIdx + 1;
 82     int i, j;
 83     int tmp;
 84     for(i=1; i<len; ++i)
 85     {
 86         for(j=startIdx; j<startIdx + len - i; ++j)
 87         {
 88             if(arr[j] > arr[j+1])
 89             {
 90                 tmp = arr[j];
 91                 arr[j] = arr[j+1];
 92                 arr[j+1] = tmp;
 93             }
 94         }
 95     }
 96 }
 97
 98 void selection_sort(int arr[], int startIdx, int endIdx)
 99 {
100     int len = endIdx - startIdx + 1;
101     int i, j;
102     int max, idx, tmp;
103
104     for(i=1; i<len; ++i)
105     {
106         idx = startIdx;
107         max = arr[idx];
108         for (j = startIdx+1; j <= startIdx + len - i; ++j)
109         {
110               if (arr[j] >= max)
111               {
112                   max = arr[j];
113                  idx = j;
114              }
115          }
116          tmp = arr[startIdx + len - i];
117          arr[startIdx + len - i] = max;
118          arr[idx] = tmp;
119     }
120 }
121
122 int binary_search(int arr[], int startIdx, int endIdx, int ele)
123 {
124     if(startIdx > endIdx)
125     {
126         return -1;
127     }
128     int midIdx;
129     while(startIdx <= endIdx)
130     {
131         midIdx = (startIdx + endIdx) / 2;
132         if(arr[midIdx] == ele)
133         {
134             return midIdx;
135         }
136         else if(arr[midIdx] < ele)
137         {
138             startIdx = midIdx + 1;
139         }
140         else
141         {
142             endIdx = midIdx - 1;
143         }
144     }
145     return -1;
146 }
147
148 void quick_sort(int arr[], int startIdx, int endIdx)
149 {
150     if(startIdx >= endIdx)
151     {
152         return;
153     }
154     int pivot = partion2(arr, startIdx, endIdx);
155     quick_sort(arr, startIdx, pivot - 1);
156     quick_sort(arr, pivot + 1, endIdx);
157 }
158
159
160 int partion(int arr[], int startIdx, int endIdx)
161 {
162     int i = startIdx;
163     int j = endIdx - 1;
164     int tmp;
165     while(i<=j)
166     {
167         if(arr[i] < arr[endIdx])
168         {
169             ++i;
170             continue;
171         }
172         if(arr[j] >= arr[endIdx])
173         {
174             --j;
175             continue;
176         }
177         tmp = arr[i];
178         arr[i] = arr[j];
179         arr[j] = tmp;
180         ++i;
181         --j;
182     }
183
184     tmp = arr[endIdx];
185     arr[endIdx] = arr[i];
186     arr[i] = tmp;
187     return i;
188 }
189
190
191 int partion2(int arr[], int startIdx, int endIdx)
192 {
193     int i = startIdx + 1;
194     int j = endIdx;
195     int tmp;
196     int pivot;
197
198     while(true)
199     {
200         while(i<=endIdx && arr[i] <= arr[startIdx])
201         {
202             ++i;
203         }
204         while(j>=startIdx+1 && arr[j] > arr[startIdx])
205         {
206             --j;
207         }
208         if(i<j)
209         {
210             tmp = arr[i];
211             arr[i] = arr[j];
212             arr[j] = tmp;
213             ++i;
214             --j;
215         }
216         else
217         {
218             tmp = arr[startIdx];
219             arr[startIdx] = arr[j];
220             arr[j] = tmp;
221             pivot = j;
222             break;
223         }
224     }
225     return pivot;
226 }
227
228 void merge_sort(int arr[], int startIdx, int endIdx)
229 {
230     if(startIdx == endIdx)
231     {
232         return;
233     }
234     int mid = (startIdx + endIdx)/2;
235     merge_sort(arr, startIdx, mid);
236     merge_sort(arr, mid + 1, endIdx);
237     merge(arr, startIdx, mid, endIdx);
238 }
239 void merge(int arr[], int startIdx, int mid, int endIdx)
240 {
241     int len = endIdx - startIdx + 1;
242     int *arrTmp = new int[len];
243     memset(arrTmp, 0, len*sizeof(int));
244     int i = startIdx;
245     int j = mid + 1;
246     int k;
247     for(k=0; k<len; ++k)
248     {
249         if(j > endIdx || (i <= mid && arr[i] <= arr[j]))
250         {
251             arrTmp[k] = arr[i];
252             ++i;
253         }
254         else
255         {
256             arrTmp[k] = arr[j];
257             ++j;
258         }
259     }
260
261     for(k=0; k<len; ++k)
262     {
263         arr[startIdx + k] = arrTmp[k];
264     }
265
266     delete[] arrTmp;
267 }
268
269
270 void heap_sort(int arr[], int startIdx, int endIdx)
271 {
272     int *arrRef = &arr[startIdx];
273     int len = endIdx - startIdx + 1;
274     build_max_heap(arrRef, len);
275
276     int i, tmp;
277     for(i=1; i<len; ++i)
278     {
279         tmp = arrRef[0];
280         arrRef[0] = arrRef[len-i];
281         arrRef[len-i] = tmp;
282         max_heapify(arrRef, len-i, 0);
283     }
284 }
285
286 void build_max_heap(int arr[], int len)
287 {
288     int startIdx = (len - 2) / 2;
289     int i;
290     for(i=startIdx; i>=0; --i)
291     {
292         max_heapify(arr, len, i);
293     }
294 }
295
296 void max_heapify(int arr[], int len, int root)
297 {
298     int last = (len-2) / 2;
299     if(root > last)
300         return;
301
302     int left = root*2 + 1;
303     int right = root*2 + 2;
304     int max = arr[root];
305     int idx = root;
306
307     if(left < len && arr[left] > max)
308     {
309         max = arr[left];
310         idx = left;
311     }
312     if(right < len && arr[right] > max)
313     {
314         max = arr[right];
315         idx = right;
316     }
317
318     if(idx != root)
319     {
320         arr[idx] = arr[root];
321         arr[root] = max;
322         max_heapify(arr, len, idx);
323     }
324 }

时间： 2024-10-12 12:24:40

冒泡法、选择法、快速、归并、堆排序算法实现的相关文章

时间/空间复杂度，基础排序算法（冒泡、选择、快速、插入）

一.时间复杂度.空间复杂度时间复杂度:用来评估算法运行效率的一个东西,用O()来表示举例时间复杂度计算: print('Hello World') O(1) for i in range(n): #n次循环 print('Hello World') O(n) for i in range(n): for j in range(n): #两个n嵌套循环 print('Hello World') O(n²) 以下这些代码时间复杂度呢? print('Hello World') print('He

常见排序算法（冒泡、选择、插入、快速、归并C++实现）

常见排序算法(冒泡.选择.插入.快速.归并C++实现) #include <iostream> using namespace std; // 冒泡排序 void bubbleSort (int data[], size_t size) { for (size_t i = 0; i < size - 1; ++i) { bool ordered = true; for (size_t j = 0; j < size - 1 - i; ++j) if (data[j+1] <

php四种基础算法：冒泡，选择，插入和快速排序法

转自:http://www.php100.com/html/php/rumen/2013/1029/6333.html 许多人都说算法是程序的核心,一个程序的好于差,关键是这个程序算法的优劣.作为一个初级phper,虽然很少接触到算法方面的东西 .但是对于冒泡排序,插入排序,选择排序,快速排序四种基本算法,我想还是要掌握的.下面是我按自己的理解,将四个方法分析一遍. 需求:分别用冒泡排序法,快速排序法,选择排序法,插入排序法将下面数组中的值按照从小到的顺序进行排序. $arr(1,43,5

排序算法（交换法，选择法，插入排序，冒泡法，快速排序算法，C语言举例）

交换法:所谓交换,就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置,交换排序的特点是:将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动. 简单选择排序:的基本思想:第1趟,在待排序记录r[1]~r[n]中选出最小的记录,将它与r[1]交换;第2趟,在待排序记录r[2]~r[n]中选出最小的记录,将它与r[2]交换;以此类推,第i趟在待排序记录r[i]~r[n]中选出最小的记录,将它与r[i]交换,使有序序列不断增长直到全部排序完毕. 插入排序法:有一个已经有序的

冒泡法、选择法、插入法、二分法

小序排序是非常重要且很常用的一种操作,有冒泡排序.选择排序.插入排序.希尔排序.快速排序.堆排序等多种方法.这里我们先简单介绍前三种排序算法和代码的实现,其余算法将在后续课程<数据结构>中学习到.算法只是一种思想,其实现依赖于数据结构,所以这里提取出一些典型的算法和数据结构,包括排序以及链表/堆栈/队列等结构的操作. ------------------------------------------------------ 冒泡法排序数组中有N个整数,用冒泡法将他们从小到大(或从大到小)

基于python语言的经典排序法（冒泡法和选择排序法）

前每逢周末就遇雨期,闲暇之余,捣鼓了下python,心心念想学习,今天就在电脑上装了个2.7,学习了下经典算法,冒泡与选择排序法第一次写关于python的文章,说的不当之处,多多指正,我积极改正在之前,曾写过使用java和C语言实现该两种排序法,详情见https://www.cnblogs.com/hong-fithing/p/7615907.html 搭建环境,准备工作就不冗余介绍了,网上搜罗一大堆目录冒泡排序法选择排序法冒泡排序法冒泡类似于汽水现象,摇动一下,就有很多泡往上冒

算法学习01：二分查询，选择法、插入法、分治法排序

查询与排序是使用的再频繁不过的两个功能,算法学习系列实现语言为C#. 一般情况下的查询 Int32 Search(Int32[] source, Int32 task) { var index = 0; while (index < source.Length) if (source[index++] == task) return index - 1; //返回值为Length则说明未找到 return source.Length; } 时间复杂度为O(n),在检索源没有排序的情况下,这即为最

冒泡法和选择排序法（比较容易写混）

1 #include<stdio.h> 2 3 4 //冒泡排序法 5 6 void bubbling(int a[],int n); 7 8 //选择排序法 9 void choose(int a[],int n); 10 int main() 11 { 12 int i; 13 int s[6]; 14 printf("please enter five numbers:\n"); 15 for(i=1;i<6;i++) 16 { 17 scanf("%

八大内部排序算法（上）-冒泡、直接插入、简单选择、快速

八大内部排序算法(上)冒泡.直接插入.简单选择.快速排序分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大,一次不能容纳全部的排序记录,在排序过程中需要访问外存. 我们这里说说八大排序就是内部排序. 1.直接插入排序将一个记录插入到已排序好的有序表中,从而得到一个新,记录数增1的有序表.即:先将序列的第1个记录看成是一个有序的子序列,然后从第2个记录逐个进行插入,直至整个序列有序为止. 要点:设立哨兵,作为临时存储和判断数组边界之用. 直接插入实现如下:

C语言常见的排序方法——冒泡法、选择法、插入法

当我们要对C中一组数据进行排序是常见的排序方法有冒泡法.选择法.插入法冒泡排序法(升序):假设一组数据a[0].a[1].a[2].a[3]...a[n],第一轮:先比较a[0]与a[1].a[1]与a[2]...a[i]与a[i+1]...a[n-1]与a[n]的大小,如果a[i]与a[i+1]不是升序(即a[i] > a[i+1]),那么就将a[i]与a[i+1]的值互换,第一轮过后,a[n]就是最大值:第二轮:运用第一轮同样的方法,比较a[0]与a[1].a[1]与a[2]...a[i]