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

冒泡排序：

设数组长度为N，

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

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

综上其就是两个for循环

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

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

以下为代码：

[cpp]view plaincopy 
   
 // sort.cpp : 定义控制台应用程序的入口点。  
 //  
   
 #include "stdafx.h"  
   
   
 void Swap(int &a, int &b)  
 {  
    int temp = a;  
    a = b;  
    b = temp;  
 }  
   
 void BubbleSort1(int a[], int n)  
 {  
     int i,j;  
   
     for (i = 0; i < n - 1; i++)  
     {  
         for (j = 0; j < n - i - 1; j++)  
         {  
             if (a[j] > a[j+1])  
             {  
                 Swap(a[j], a[j+1]);  
             }  
         }  
     }  
   
      for (int i = 0; i < n; i++)  
      {  
          printf("%d\t", a[i]);  
      }  
 }  
   
 //改进  
 void BubbleSort2(int a[], int n)  
 {  
     int i, j = n - 1;  
     bool flag = true;            //设置标志，如果这一趟发生交换，则为true，否则为false  
   
     while(flag)  
     {  
         flag = false;  
         for(i = 0; i < j; i++)  
             if (a[i] > a[i+1])  
             {  
                 Swap(a[i], a[i+1]);;  
                 flag = true;  
             }  
         j--;  
     }  
       
     for (int i = 0; i < n; i++)  
     {  
         printf("%d\t", a[i]);  
     }  
 }  
   
 int _tmain(int argc, _TCHAR* argv[])  
 {  
     int score[] = {67, 69, 75, 87, 89, 90, 99, 100};  
   
     BubbleSort2(score, 8);  
   
     return 0;  
 }  

直接插入排序：

设数组为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 plaincopy 
   
 void InsertSort1(int a[], int n)  
 {  
     int i,j,k;  
     for (i = 1; i < n; i++)  //将下标1到n-1进行直接插入排序  
     {  
         for (j = i-1; j >=0; j--)  //当下标为i时，将a[i]排在a[0，i-1]上  
         {  
             if(a[j] < a[i])  
                 break;  
         }  
   
         if ( j != i-1 )          //如果j不在i的前一位，即表示将a[i]查到a[0，i-1]之间  
         {  
             int temp = a[i];  
             for(k = i - 1; k > j; k--)  
                 a[k+1]=a[k];  
             a[k+1] = temp;  
         }  
     }  
 }  
   
 //改进直接插入排序  
 void Insertsort2(int a[], int n)  
 {  
     int i,j;  
     for (i = 1; i < n; i++)  
         if (a[i] < a[i-1])  
         {  
             int temp = a[i];  
             for (j = i - 1; j >= 0 && a[j] > temp; j--)  
             {  
                 a[j+1] = a[j];  
             }  
             a[j+1] = temp;  
         }  
       
       
 }  

希尔排序：

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

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

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

以下为代码：

[cpp]view plaincopy 
   
 void shellSort1(int a[], int n)  
 {  
     int i,j,gap; //gap为步长  
     for (gap = n/2; gap > 0; gap /= 2) // 设置步长  
         for (i = 0; i < gap; i++)      //按组排序  
         {  
             for (j = i + gap; j < n; j += gap)  
             {  
                 if (a[j] < a[j-gap])  //如果后面的比前面的小  
                 {  
                     int temp = a[j];  
                     int k = j-gap;  
   
                     while (k >= 0 && a[k] > temp)  
                     {  
                         a[k+gap] = a[k];  
                         k -= gap;  
                     }  
                     a[k+gap] = temp;  
                 }  
             }  
         }  
   
 }  
   
 //改进希尔排序  
 void shellSort2(int a[], int n)  
 {  
     int j,gap;  
     for(gap = n/2; gap > 0; gap /= 2)  
         for(j = gap; j < n; j++)   //从数组第gap个元素开始  
             if (a[j] < a[j-gap])  
             {  
                 int temp = a[j];  
                 int k = j-gap;  
   
                 while (k >= 0 && a[k] > temp)  
                 {  
                     a[k + gap] = a[k];  
                     k -= gap;  
                 }  
   
                 a[k+gap] = temp;  
             }  
   
 }  

归并排序：

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

代码如下：

[cpp]view plaincopy 
   
 void mergeArray(int a[], int first, int mid, int last, int temp[])  
 {  
     int i = first, j = mid + 1, k = 0;  
     int m = mid, n = last;  
   
     while (i <= m && j <= n)  
     {  
         if(a[i] < a[j])  
             temp[k++] = a[i++];  
         else  
             temp[k++] = a[j++];  
     }  
   
     while(i <= m)  
         temp[k++] = a[i++];  
   
     while(j <= n)  
         temp[k++] = a[j++];  
   
     for (i = 0; i < k; i++)  
     {  
         a[first + i] = temp[i];  
   
     }  
 }  
   
   
 void mergesort(int a[], int first, int last, int temp[])  
 {  
     if (first < last)  
     {  
         int mid = (first + last)/2;  
         mergesort(a, first, mid, temp);  
         mergesort(a, mid + 1, last, temp);  
         mergeArray(a, first, mid, last, temp);  
     }  
 }  
   
 bool MergeSort(int a[], int n)  
 {  
     int* pTempArray = new int[n];  
     if(pTempArray == NULL)  
         return false;  
     mergesort(a, 0, n-1, pTempArray);  
     delete[] pTempArray;  
     return true;  
   
   
 }  

快速排序：

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

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

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

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

以下为代码：

[cpp]view plaincopy 
   
 void quickSort(int a[], int L, int R)  
 {  
     if( L < R )  
     {  
         int i = L, j = R, x = a[L];  
   
         while (i < j)  
         {  
             while ( i < j && a[j] >= x)  
                j--;  
             if(i < j)  
                 a[i++] = a[j];  
   
             while (i < j && a[i] < x)  
                 i++;  
             if(i < j)  
                 a[j--] = a[i];    
               
         }  
         a[i] = x;  
         quickSort(a, L, i-1);  
         quickSort(a,i+1, R);  
     }  
 }  

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

java实现：

[java]view plaincopy 
   
 package com.example.sorts;  
   
 public class sorts {  
       
     //冒泡排序  
     public static void bubbleSort(int[] arr){  
         int i, j;  
         int len = arr.length;  
         int temp;  
         for(i = 0; i < len - 1; i++)  
             for(j = 0; j < len - 1 - i; j++){  
                 if(arr[j] > arr[j+1]){  
                     temp = arr[j];  
                     arr[j] = arr[j+1];  
                     arr[j+1] = temp;  
                 }  
             }  
     }  
       
     //直接插入排序  
     public static void insertSort(int[] arr){  
         int i, j;  
         int len = arr.length;  
         int temp;  
         for(i = 1; i < len; i++)  
             if(arr[i] < arr[i-1]){  
                 temp = arr[i];  
                 for(j = i - 1; j >= 0 && arr[j] > temp; j--)  
                     arr[j+1] = arr[j];  
                 arr[j+1] = temp;      
             }  
     }  
       
     //希尔排序  
     public static void shellSort(int[] arr){  
         int i, j;  
         int gap; //间隔  
         int len = arr.length;  
         int temp;  
         for(gap = len/2; gap > 0; gap /= 2)  
             for(i = gap; i < len; i++)  
                 if(arr[i] < arr[i-gap]){  
                     temp = arr[i];  
                     for(j = i - gap; j >= 0 && arr[j] > temp; j -= gap)  
                         arr[j+gap] = arr[j];  
                     arr[j+gap] = temp;  
                 }  
     }  
       
     //直接选择排序  
     public static void selectSort(int[] arr){  
         int i, j;  
         int len = arr.length;  
         int temp;  
         int nMinIndex;  
         for(i = 0; i < len; i++){  
             nMinIndex = i;  
             for(j = i + 1 ; j < len ; j++)  
                 if(arr[nMinIndex] > arr[j])  
                     nMinIndex = j;  
             temp = arr[nMinIndex];  
             arr[nMinIndex] = arr[i];  
             arr[i] = temp;  
         }  
     }  
       
       
     //归并排序  
     public static void mergeSort(int[] arr, int low, int high){  
         int mid = (low + high)/2;  
         if(low < high){  
         mergeSort(arr, low, mid);  
         mergeSort(arr, mid+1, high);  
         merge(arr, low, mid, high);  
         }  
     }  
       
     public static void merge(int[] arr, int low, int mid, int high){  
         int[] temp = new int[high-low+1];  
         int i = low;  //数组1的起始点  
         int j = mid+1; //数组2的起始点  
         int k = 0;  
           
         while(i <= mid && j <= high){  
             if(arr[i] < arr[j]){  
                 temp[k++] = arr[i++];  
             }else{  
                 temp[k++] = arr[j++];  
             }  
         }  
           
         while(i <= mid){  
             temp[k++] = arr[i++];  
         }  
           
         while(j <= high){  
             temp[k++] = arr[j++];  
         }  
           
         for(int m = 0; m < temp.length; m++)  
             arr[low+m] = temp[m];  
     }  
       
     //快速排序  
     public static void quickSort(int[] arr, int L, int R){  
         if(L < R){  
             int i = L, j = R;  
             //选定基数  
             int x = arr[i];  
             while(i < j){  
                   
                 while(i < j && arr[j] >= x)  
                     j--;  
                 if(i < j)  
                     arr[i++] = arr[j];  
                   
                 while(i < j && arr[i] < x)  
                     i++;  
                 if(i < j)  
                     arr[j--] = arr[i];    
             }  
             arr[i] = x;  
             quickSort(arr, L, i-1);  
             quickSort(arr, i+1, R);  
         }  
     }  
       
     //堆排序  
       
     public static void MinHeapSort(int[] arr, int n){  
         int temp;  
         //建立最小堆  
         MakeMinHeap(arr, n);  
         for(int i = n - 1; i >= 0; i--){  
             temp = arr[i];  
             arr[i] = arr[0];  
             arr[0] = temp;  
             MinHeapFixdown(arr, 0, i);  
         }  
     }  
       
     public static void MinHeapFixdown(int[] arr, int i, int n){  //i表示节点，n表示节点数  
         int j; //子节点  
         int temp = arr[i];//将父节点值保存到temp  
         j = 2*i + 1;  
           
         while(j < n){  
             if(j + 1 < n && arr[j+1] < arr[j])  
                 j++;  
             if(temp <= arr[j])  
                 break;  
             arr[i] = arr[j];  
             i = j;    //将子节点设置为父节点  
             j = 2*i + 1; //得到父节点的子节点  
         }  
         arr[i] = temp;  
     }  
     //建立最小堆  
     public static void MakeMinHeap(int[] arr, int n){  
         for(int i = n/2 - 1; i >= 0; i--)  
             MinHeapFixdown(arr, i, n);  
     }  
       
     public static void main(String[] args){  
   
         int[] arrI = {9, 12, 17, 30, 50, 20, 60, 65, 4, 49};  
         MinHeapSort(arrI, 10);  
           
         for(int k : arrI)  
             System.out.print(k+" ");  
     }  
   
 }  