六、内部排序综合(九种)—插入类排序(直接插入、折半插入、希尔排序);交换类排序(冒泡、快速);选择类排序(简单选择、堆排序);二路归并排序;基数排序

冒泡排序:

设数组长度为N,

1、比较相邻前后两个数据,数组为[0,N-1],则要比较N-1次

2、循环一次后,最大或者最小的数在数组最后面,这样比较数组[0,N-2],重复上述步骤即可


综上其就是两个for循环

第一个for循环表示:要排序的数值个数-1

第二个for循环表示:将无序数组进行排序,即比较相邻的两个数值


以下为代码:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. // sort.cpp : 定义控制台应用程序的入口点。  
  2. //  
  3.   
  4. #include "stdafx.h"  
  5.   
  6.   
  7. void Swap(int &a, int &b)  
  8. {  
  9.    int temp = a;  
  10.    a = b;  
  11.    b = temp;  
  12. }  
  13.   
  14. void BubbleSort1(int a[], int n)  
  15. {  
  16.     int i,j;  
  17.   
  18.     for (i = 0; i < n - 1; i++)  
  19.     {  
  20.         for (j = 0; j < n - i - 1; j++)  
  21.         {  
  22.             if (a[j] > a[j+1])  
  23.             {  
  24.                 Swap(a[j], a[j+1]);  
  25.             }  
  26.         }  
  27.     }  
  28.   
  29.      for (int i = 0; i < n; i++)  
  30.      {  
  31.          printf("%d\t", a[i]);  
  32.      }  
  33. }  
  34.   
  35. //改进  
  36. void BubbleSort2(int a[], int n)  
  37. {  
  38.     int i, j = n - 1;  
  39.     bool flag = true;            //设置标志,如果这一趟发生交换,则为true,否则为false  
  40.   
  41.     while(flag)  
  42.     {  
  43.         flag = false;  
  44.         for(i = 0; i < j; i++)  
  45.             if (a[i] > a[i+1])  
  46.             {  
  47.                 Swap(a[i], a[i+1]);;  
  48.                 flag = true;  
  49.             }  
  50.         j--;  
  51.     }  
  52.       
  53.     for (int i = 0; i < n; i++)  
  54.     {  
  55.         printf("%d\t", a[i]);  
  56.     }  
  57. }  
  58.   
  59. int _tmain(int argc, _TCHAR* argv[])  
  60. {  
  61.     int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  
  62.   
  63.     BubbleSort2(score, 8);  
  64.   
  65.     return 0;  
  66. }  

直接插入排序:

设数组为a[0,n-1];

1、取i = 1,2......n-1,每设置一次i的值,即将数组a[0,i-1]进行排序。

2、这样a[0,n-1]可以分为两个部分,a[0,i-1]为排好序的,而a[i,n-1]为无序。

3、i++直到n-1,即1步骤,即可。

以下是代码:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void InsertSort1(int a[], int n)  
  2. {  
  3.     int i,j,k;  
  4.     for (i = 1; i < n; i++)  //将下标1到n-1进行直接插入排序  
  5.     {  
  6.         for (j = i-1; j >=0; j--)  //当下标为i时,将a[i]排在a[0,i-1]上  
  7.         {  
  8.             if(a[j] < a[i])  
  9.                 break;  
  10.         }  
  11.   
  12.         if ( j != i-1 )          //如果j不在i的前一位,即表示将a[i]查到a[0,i-1]之间  
  13.         {  
  14.             int temp = a[i];  
  15.             for(k = i - 1; k > j; k--)  
  16.                 a[k+1]=a[k];  
  17.             a[k+1] = temp;  
  18.         }  
  19.     }  
  20. }  
  21.   
  22. //改进直接插入排序  
  23. void Insertsort2(int a[], int n)  
  24. {  
  25.     int i,j;  
  26.     for (i = 1; i < n; i++)  
  27.         if (a[i] < a[i-1])  
  28.         {  
  29.             int temp = a[i];  
  30.             for (j = i - 1; j >= 0 && a[j] > temp; j--)  
  31.             {  
  32.                 a[j+1] = a[j];  
  33.             }  
  34.             a[j+1] = temp;  
  35.         }  
  36.       
  37.       
  38. }  

希尔排序:

1、将无序数组分割成若干个子序列,子序列的长度(gap = n/2)是相隔特定的增量子序列,将各子序列进行直接插入排序;

2、在排序一次后,将数组再次分割若干子序列,子序列的长度(gap /= 2)是相隔特定的增量子序列,将各子序列进行直接插入排序;

3、重复上述过程,直到gap = 0时,数组排序完成。


以下为代码:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void shellSort1(int a[], int n)  
  2. {  
  3.     int i,j,gap; //gap为步长  
  4.     for (gap = n/2; gap > 0; gap /= 2) // 设置步长  
  5.         for (i = 0; i < gap; i++)      //按组排序  
  6.         {  
  7.             for (j = i + gap; j < n; j += gap)  
  8.             {  
  9.                 if (a[j] < a[j-gap])  //如果后面的比前面的小  
  10.                 {  
  11.                     int temp = a[j];  
  12.                     int k = j-gap;  
  13.   
  14.                     while (k >= 0 && a[k] > temp)  
  15.                     {  
  16.                         a[k+gap] = a[k];  
  17.                         k -= gap;  
  18.                     }  
  19.                     a[k+gap] = temp;  
  20.                 }  
  21.             }  
  22.         }  
  23.   
  24. }  
  25.   
  26. //改进希尔排序  
  27. void shellSort2(int a[], int n)  
  28. {  
  29.     int j,gap;  
  30.     for(gap = n/2; gap > 0; gap /= 2)  
  31.         for(j = gap; j < n; j++)   //从数组第gap个元素开始  
  32.             if (a[j] < a[j-gap])  
  33.             {  
  34.                 int temp = a[j];  
  35.                 int k = j-gap;  
  36.   
  37.                 while (k >= 0 && a[k] > temp)  
  38.                 {  
  39.                     a[k + gap] = a[k];  
  40.                     k -= gap;  
  41.                 }  
  42.   
  43.                 a[k+gap] = temp;  
  44.             }  
  45.   
  46. }  

归并排序:

先分,在组合,这里是递归算法

代码如下:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void mergeArray(int a[], int first, int mid, int last, int temp[])  
  2. {  
  3.     int i = first, j = mid + 1, k = 0;  
  4.     int m = mid, n = last;  
  5.   
  6.     while (i <= m && j <= n)  
  7.     {  
  8.         if(a[i] < a[j])  
  9.             temp[k++] = a[i++];  
  10.         else  
  11.             temp[k++] = a[j++];  
  12.     }  
  13.   
  14.     while(i <= m)  
  15.         temp[k++] = a[i++];  
  16.   
  17.     while(j <= n)  
  18.         temp[k++] = a[j++];  
  19.   
  20.     for (i = 0; i < k; i++)  
  21.     {  
  22.         a[first + i] = temp[i];  
  23.   
  24.     }  
  25. }  
  26.   
  27.   
  28. void mergesort(int a[], int first, int last, int temp[])  
  29. {  
  30.     if (first < last)  
  31.     {  
  32.         int mid = (first + last)/2;  
  33.         mergesort(a, first, mid, temp);  
  34.         mergesort(a, mid + 1, last, temp);  
  35.         mergeArray(a, first, mid, last, temp);  
  36.     }  
  37. }  
  38.   
  39. bool MergeSort(int a[], int n)  
  40. {  
  41.     int* pTempArray = new int[n];  
  42.     if(pTempArray == NULL)  
  43.         return false;  
  44.     mergesort(a, 0, n-1, pTempArray);  
  45.     delete[] pTempArray;  
  46.     return true;  
  47.   
  48.   
  49. }  

快速排序:

1、在数组取一个数作为基数

2、在L在往前查找比基数小的数,然后将此坑与基数的坑对换。

3、在R往后查找比基数大的数,然后将此坑与基数的坑对换。

4、知道LR相等时,将基数放置在L或者R处。

以下为代码:

[cpp]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. void quickSort(int a[], int L, int R)  
  2. {  
  3.     if( L < R )  
  4.     {  
  5.         int i = L, j = R, x = a[L];  
  6.   
  7.         while (i < j)  
  8.         {  
  9.             while ( i < j && a[j] >= x)  
  10.                j--;  
  11.             if(i < j)  
  12.                 a[i++] = a[j];  
  13.   
  14.             while (i < j && a[i] < x)  
  15.                 i++;  
  16.             if(i < j)  
  17.                 a[j--] = a[i];    
  18.               
  19.         }  
  20.         a[i] = x;  
  21.         quickSort(a, L, i-1);  
  22.         quickSort(a,i+1, R);  
  23.     }  
  24. }  


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

java实现:

[java]  view plain copy 在CODE上查看代码片 派生到我的代码片
  1. package com.example.sorts;  
  2.   
  3. public class sorts {  
  4.       
  5.     //冒泡排序  
  6.     public static void bubbleSort(int[] arr){  
  7.         int i, j;  
  8.         int len = arr.length;  
  9.         int temp;  
  10.         for(i = 0; i < len - 1; i++)  
  11.             for(j = 0; j < len - 1 - i; j++){  
  12.                 if(arr[j] > arr[j+1]){  
  13.                     temp = arr[j];  
  14.                     arr[j] = arr[j+1];  
  15.                     arr[j+1] = temp;  
  16.                 }  
  17.             }  
  18.     }  
  19.       
  20.     //直接插入排序  
  21.     public static void insertSort(int[] arr){  
  22.         int i, j;  
  23.         int len = arr.length;  
  24.         int temp;  
  25.         for(i = 1; i < len; i++)  
  26.             if(arr[i] < arr[i-1]){  
  27.                 temp = arr[i];  
  28.                 for(j = i - 1; j >= 0 && arr[j] > temp; j--)  
  29.                     arr[j+1] = arr[j];  
  30.                 arr[j+1] = temp;      
  31.             }  
  32.     }  
  33.       
  34.     //希尔排序  
  35.     public static void shellSort(int[] arr){  
  36.         int i, j;  
  37.         int gap; //间隔  
  38.         int len = arr.length;  
  39.         int temp;  
  40.         for(gap = len/2; gap > 0; gap /= 2)  
  41.             for(i = gap; i < len; i++)  
  42.                 if(arr[i] < arr[i-gap]){  
  43.                     temp = arr[i];  
  44.                     for(j = i - gap; j >= 0 && arr[j] > temp; j -= gap)  
  45.                         arr[j+gap] = arr[j];  
  46.                     arr[j+gap] = temp;  
  47.                 }  
  48.     }  
  49.       
  50.     //直接选择排序  
  51.     public static void selectSort(int[] arr){  
  52.         int i, j;  
  53.         int len = arr.length;  
  54.         int temp;  
  55.         int nMinIndex;  
  56.         for(i = 0; i < len; i++){  
  57.             nMinIndex = i;  
  58.             for(j = i + 1 ; j < len ; j++)  
  59.                 if(arr[nMinIndex] > arr[j])  
  60.                     nMinIndex = j;  
  61.             temp = arr[nMinIndex];  
  62.             arr[nMinIndex] = arr[i];  
  63.             arr[i] = temp;  
  64.         }  
  65.     }  
  66.       
  67.       
  68.     //归并排序  
  69.     public static void mergeSort(int[] arr, int low, int high){  
  70.         int mid = (low + high)/2;  
  71.         if(low < high){  
  72.         mergeSort(arr, low, mid);  
  73.         mergeSort(arr, mid+1, high);  
  74.         merge(arr, low, mid, high);  
  75.         }  
  76.     }  
  77.       
  78.     public static void merge(int[] arr, int low, int mid, int high){  
  79.         int[] temp = new int[high-low+1];  
  80.         int i = low;  //数组1的起始点  
  81.         int j = mid+1//数组2的起始点  
  82.         int k = 0;  
  83.           
  84.         while(i <= mid && j <= high){  
  85.             if(arr[i] < arr[j]){  
  86.                 temp[k++] = arr[i++];  
  87.             }else{  
  88.                 temp[k++] = arr[j++];  
  89.             }  
  90.         }  
  91.           
  92.         while(i <= mid){  
  93.             temp[k++] = arr[i++];  
  94.         }  
  95.           
  96.         while(j <= high){  
  97.             temp[k++] = arr[j++];  
  98.         }  
  99.           
  100.         for(int m = 0; m < temp.length; m++)  
  101.             arr[low+m] = temp[m];  
  102.     }  
  103.       
  104.     //快速排序  
  105.     public static void quickSort(int[] arr, int L, int R){  
  106.         if(L < R){  
  107.             int i = L, j = R;  
  108.             //选定基数  
  109.             int x = arr[i];  
  110.             while(i < j){  
  111.                   
  112.                 while(i < j && arr[j] >= x)  
  113.                     j--;  
  114.                 if(i < j)  
  115.                     arr[i++] = arr[j];  
  116.                   
  117.                 while(i < j && arr[i] < x)  
  118.                     i++;  
  119.                 if(i < j)  
  120.                     arr[j--] = arr[i];    
  121.             }  
  122.             arr[i] = x;  
  123.             quickSort(arr, L, i-1);  
  124.             quickSort(arr, i+1, R);  
  125.         }  
  126.     }  
  127.       
  128.     //堆排序  
  129.       
  130.     public static void MinHeapSort(int[] arr, int n){  
  131.         int temp;  
  132.         //建立最小堆  
  133.         MakeMinHeap(arr, n);  
  134.         for(int i = n - 1; i >= 0; i--){  
  135.             temp = arr[i];  
  136.             arr[i] = arr[0];  
  137.             arr[0] = temp;  
  138.             MinHeapFixdown(arr, 0, i);  
  139.         }  
  140.     }  
  141.       
  142.     public static void MinHeapFixdown(int[] arr, int i, int n){  //i表示节点,n表示节点数  
  143.         int j; //子节点  
  144.         int temp = arr[i];//将父节点值保存到temp  
  145.         j = 2*i + 1;  
  146.           
  147.         while(j < n){  
  148.             if(j + 1 < n && arr[j+1] < arr[j])  
  149.                 j++;  
  150.             if(temp <= arr[j])  
  151.                 break;  
  152.             arr[i] = arr[j];  
  153.             i = j;    //将子节点设置为父节点  
  154.             j = 2*i + 1//得到父节点的子节点  
  155.         }  
  156.         arr[i] = temp;  
  157.     }  
  158.     //建立最小堆  
  159.     public static void MakeMinHeap(int[] arr, int n){  
  160.         for(int i = n/2 - 1; i >= 0; i--)  
  161.             MinHeapFixdown(arr, i, n);  
  162.     }  
  163.       
  164.     public static void main(String[] args){  
  165.   
  166.         int[] arrI = {912173050206065449};  
  167.         MinHeapSort(arrI, 10);  
  168.           
  169.         for(int k : arrI)  
  170.             System.out.print(k+" ");  
  171.     }  
  172.   
  173. }  
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值