zoukankan      html  css  js  c++  java
  • 八大排序算法概述及实现

      1 /************************************************************************/
      2 /*                        八大排序算法概述及实现                            */
      3 /*                                                                      */
      4 /*                               |- 冒泡排序                              */
      5 /*                   -  交换排序 -|                                       */
      6 /*                  |            |- 快速排序                              */
      7 /*                  |                                                   */
      8 /*                  |            |- 插入排序                              */
      9 /*                  |   插入排序 -|                                       */
     10 /*                  |            |- 希尔排序                              */
     11 /*         排序算法 -|                                                    */
     12 /*                  |            |- 选择排序                              */
     13 /*                  |   选择排序 -|                                       */
     14 /*                  |            |- 堆排序                                */
     15 /*                  |                                                    */
     16 /*                  |   归并排序                                          */
     17 /*                  |                                                    */
     18 /*                   -  基数排序                                          */
     19 /*                                                                       */
     20 /*************************************************************************/
     21 
     22 #include <iostream>
     23 #include <cstring>
     24 using namespace std;
     25 
     26 /************************************************************************/
     27 /*                              冒泡排序                                 */
     28 /************************************************************************/
     29 void bubbleSort(int* arr, int len)
     30 {
     31     int temp = 0;
     32     for (int i = 0; i < len - 1; i++) //排序len-1次
     33     {
     34         for (int j = 0; j < len - i - 1; j++) //每次找到当前范围内的最大值
     35         {
     36             if (arr[j] > arr[j + 1])
     37             {
     38                 temp = arr[j];
     39                 arr[j] = arr[j + 1];
     40                 arr[j + 1] = temp;
     41             }
     42         }
     43     }
     44 }
     45 
     46 /************************************************************************/
     47 /*                              快速排序                                 */
     48 /************************************************************************/
     49 void quikSort(int* arr, int left, int right)
     50 {
     51     if (left < right)
     52     {
     53         int i = left, j = right, x = arr[i];
     54         while (i < j)
     55         {
     56             while (i < j&&x <= arr[j])
     57                 j--;
     58             if (i < j)
     59                 arr[i++] = arr[j];
     60 
     61             while (i < j&&x >= arr[i])
     62                 i++;
     63             if (i < j)
     64                 arr[j--] = arr[i];
     65         }
     66         arr[i] = x;
     67         quikSort(arr, 0, i - 1);
     68         quikSort(arr, i + 1, right);
     69     }
     70 }
     71 
     72 /************************************************************************/
     73 /*                              插入排序                                 */
     74 /************************************************************************/
     75 void insertSort(int* arr, int len)
     76 {
     77     int temp;
     78     for (int i = 1; i < len; i++) //从第2个数开始
     79     {
     80         for (int j = i - 1; j >= 0; j--)
     81         {
     82             if (arr[j] > arr[j + 1])
     83             {
     84                 temp = arr[j];
     85                 arr[j] = arr[j + 1];
     86                 arr[j + 1] = temp;
     87             }
     88         }
     89     }
     90 }
     91 
     92 /************************************************************************/
     93 /*                              希尔排序                                 */
     94 /************************************************************************/
     95 void shellSort(int* arr, int len)
     96 {
     97     int d = len / 2, temp;
     98     while (d >= 1)
     99     {
    100         for (int i = d; i < len; i++)
    101         {
    102             for (int j = i - d; j >= 0; j -= d)
    103             {
    104                 if (arr[j] > arr[j + d])
    105                 {
    106                     temp = arr[j];
    107                     arr[j + d] = arr[j];
    108                     arr[j] = temp;
    109                 }
    110             }
    111         }
    112         d /= 2;
    113     }
    114 }
    115 
    116 /************************************************************************/
    117 /*                              选择排序                                 */
    118 /************************************************************************/
    119 void selectSort(int* arr, int len)
    120 {
    121     int id, temp;
    122     for (int i = 0; i < len - 1; i++) //进行len-1次选择
    123     {
    124         id = 0;
    125         for (int j = 0; j < len - i; j++) //找到最大数据的位置
    126             if (arr[j] > arr[id])
    127                 id = j;
    128 
    129         temp = arr[id];
    130         arr[id] = arr[len - i - 1];
    131         arr[len - i - 1] = temp;
    132     }
    133 }
    134 
    135 /************************************************************************/
    136 /*                                堆排序                                 */
    137 /************************************************************************/
    138 //调整结点
    139 void adjustNode(int* arr, int len, int n)
    140 {
    141     int l, r, max, temp;
    142     l = 2 * n + 1;
    143     r = 2 * n + 2;
    144     max = n;
    145 
    146     if (l < len&&arr[n] < arr[l])
    147         max = l;
    148     if (r < len&&arr[n] < arr[r])
    149         max = r;
    150 
    151     if (max != n)
    152     {
    153         temp = arr[n];
    154         arr[n] = arr[max];
    155         arr[max] = temp;
    156         
    157         adjustNode(arr, len, max);
    158     }
    159 }
    160 
    161 //建立堆
    162 void makeHeap(int* arr, int len)
    163 {
    164     for (int i = len / 2; i >= 0; i--)
    165         adjustNode(arr, len, i);
    166 }
    167 
    168 //堆排序
    169 void heapSort(int* arr, int len)
    170 {
    171     makeHeap(arr, len);
    172 
    173     int temp;
    174     for (int i = len - 1; i >= 0; i--)
    175     {
    176         temp = arr[i];
    177         arr[i] = arr[0];
    178         arr[0] = temp;
    179 
    180         adjustNode(arr, i, 0);
    181     }
    182 }
    183 
    184 /************************************************************************/
    185 /*                              归并排序                                 */
    186 /************************************************************************/
    187 //将数组中的两个局部有序序列合并(temp数组中的内存足够)
    188 void mergeArray(int* arr, int first, int mid, int last, int temp[])
    189 {
    190     int i = first, j = mid + 1;
    191     int m = mid, n = last;
    192     int k = 0;
    193 
    194     while (i <= m && j <= n)
    195     {
    196         if (arr[i] <= arr[j])
    197             temp[k++] = arr[i++];
    198         else
    199             temp[k++] = arr[j++];
    200     }
    201 
    202     while (i <= m)
    203         temp[k++] = arr[i++];
    204 
    205     while (j <= n)
    206         temp[k++] = arr[j++];
    207 
    208     for (i = 0; i < k; i++)
    209         arr[first + i] = temp[i];
    210 }
    211 
    212 //归并排序
    213 void mergeSort(int* arr, int first, int last, int temp[])
    214 {
    215     if (first < last)
    216     {
    217         int mid = (first + last) >> 1;
    218         mergeSort(arr, first, mid, temp);
    219         mergeSort(arr, mid + 1, last, temp);
    220         mergeArray(arr, first, mid, last, temp);
    221     }
    222 }
    223 
    224 /************************************************************************/
    225 /*                              基数排序                                 */
    226 /************************************************************************/
    227 //计算数组中所有数据的最大位数
    228 int maxbit(int data[], int n)
    229 {
    230     int d = 1;
    231     for (int i = 0; i < n; i++)
    232     {
    233         int c = 1;
    234         int p = data[i];
    235         while (p / 10)
    236         {
    237             p = p / 10;
    238             c++;
    239         }
    240         if (c > d)
    241             d = c;
    242     }
    243     return d;
    244 }
    245 
    246 //基数排序
    247 void radixSort(int arr[], int n)
    248 {
    249     int* tmp = new int[10];
    250     int* count = new int[10];
    251 
    252     int d = maxbit(arr, n);
    253     int r = 1;
    254     for (int i = 0; i < d; i++)
    255     {
    256 
    257         for (int i = 0; i < 10; i++)//装桶之前要先清桶
    258             count[i] = 0;
    259         for (i = 0; i < n; i++) //记录每个桶的记录数
    260         {
    261             int k = arr[i] / r;
    262             int q = k % 10;
    263             count[q]++;
    264         }
    265         for (i = 1; i < 10; i++)//计算位置
    266         {
    267             count[i] += count[i - 1];
    268         }
    269         for (int j = n - 1; j >= 0; j--) //将排序后的结果存到tmp中
    270         {
    271             int p = arr[j] / r;
    272             int s = p % 10;
    273             tmp[count[s] - 1] = arr[j];
    274             count[s]--;
    275         }
    276         for (i = 0; i < n; i++)
    277         {
    278             arr[i] = tmp[i];
    279         }
    280         r = r * 10;
    281     }
    282 
    283     delete[] tmp;
    284     delete[] count;
    285 }
    286 
    287 //打印数组
    288 void printArr(int* arr, int len)
    289 {
    290     for (int i = 0; i < len; i++)
    291     {
    292         cout << arr[i] << ' ';
    293     }
    294     cout << endl;
    295 }
    296 
    297 int main()
    298 {
    299     int num, temp;
    300 
    301     cout << "请输入待排序的序列(格式:序列长度n 数1 数2 ... 数n),以回车符结束输入:" << endl;
    302     cin >> num;
    303     int* parr = new int[num];
    304     int* parr0 = new int[num];
    305     int* ptemp = new int[num]; //辅助内存
    306     for (int i = 0; i < num; i++)
    307     {
    308         cin >> temp;
    309         parr[i] = temp;
    310     }
    311     memcpy(parr0, parr, sizeof(int)*num);
    312 
    313     cout << "
    请选择排序方法:
    ";
    314     cout << "0 原数组序列; 1 冒泡排序; 2 快速排序; 3 插入排序; 4 希尔排序;
    ";
    315     cout << "5 选择排序; 6 堆排序;  7 归并排序; 8 基数排序;  非数字结束!
    ";
    316     int id;
    317     while (cin >> id)
    318     {
    319         switch (id)
    320         {
    321         case 0:
    322             memcpy(parr, parr0, sizeof(int)*num);
    323             break;
    324         case 1:
    325             memcpy(parr, parr0, sizeof(int)*num);
    326             bubbleSort(parr, num);
    327             break;
    328         case 2:
    329             memcpy(parr, parr0, sizeof(int)*num);
    330             quikSort(parr, 0, num - 1);
    331             break;
    332         case 3:
    333             memcpy(parr, parr0, sizeof(int)*num);
    334             insertSort(parr, num);
    335             break;
    336         case 4:
    337             memcpy(parr, parr0, sizeof(int)*num);
    338             shellSort(parr, num);
    339             break;
    340         case 5:
    341             memcpy(parr, parr0, sizeof(int)*num);
    342             selectSort(parr, num);
    343             break;
    344         case 6:
    345             memcpy(parr, parr0, sizeof(int)*num);
    346             heapSort(parr, num);
    347             break;
    348         case 7:
    349             memcpy(parr, parr0, sizeof(int)*num);
    350             mergeSort(parr, 0, num - 1, ptemp);
    351             break;
    352         case 8:
    353             memcpy(parr, parr0, sizeof(int)*num);
    354             radixSort(parr, num);
    355             break;
    356         default:
    357             break;
    358         }
    359         printArr(parr, num);
    360 
    361         cout << "
    请选择排序方法:";
    362     }
    363 
    364     printArr(parr, num);
    365 
    366     delete[] parr;
    367     delete[] parr0;
    368     delete[] ptemp;
    369 }
  • 相关阅读:
    JavaSE 基础 第51节 定义自己的异常
    JavaSE 基础 第50节 Java中的异常链
    JavaSE 基础 第49节 手动抛出异常
    JavaSE 基础 第48节 Java中的异常声明
    JavaSE 基础 第47节 获取异常信息
    JavaSE 基础 第46节 异常的分类
    JavaSE 基础 第45节Java异常快速入门
    JavaSE 基础 第44节 引用外部类的对象
    JavaSE 基础 第43节 静态内部类
    通用爬虫
  • 原文地址:https://www.cnblogs.com/jmliao/p/8526519.html
Copyright © 2011-2022 走看看