排序算法的总结与感悟

插入排序

算法概要：插入排序依据遍历到第N个元素的时候前面的N-1个元素已经是排序好的，那么就查找前面的N-1个元素把这第N个元素放在合适的位置，如此下去直到遍历完序列的元素为止。

    void insertSort(int array[], int length)  
    {  
        int key;  
        for(int i=1; i<length; i++)  
        {  
            key = array[i];   
            for(int j=i-1; j>=0 && array[j] > key; j--)  
            {  
                    array[j+1] = array[j];  
            }  
            array[j+1] = key;  
        }  
    }  

希尔排序

算法概要：shell排序是对插入排序的一个改装，它每次排序排序根据一个增量获取一个序列，对这这个子序列进行插入排序，然后不断的缩小增量扩大子序列的元素数量，直到增量为1的时候子序列就和原先的待排列序列一样了，此时只需要做少量的比较和移动就可以完成对序列的排序了。

    void shellSort(int array[], int length)  
    {  
        int key;  
        int increment;  
        for(increment = length/2; increment>0; increment /= 2)  
        {  
            for(int i=increment; i<length; i++)  
            {  
                key = array[i];  
                for(int j = i-increment; j>=0 && array[j] > key; j -= increment)  
                {  
                    array[j+increment] = array[j];  
                }  
                array[j+increment]=key;  
            }  
        }  
      
    }  

冒泡排序

算法概要：冒泡排序是经过n-1趟子排序完成的，第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数。

void bubbleSort(int  array[], int length)  

    {  
        int flag = 0;  
        for(int i=0; i<length-1; i++)  
        {  
            for(int j=0; j<length-1-i; j++)  
            {  
                if(array[j]>array[j+1])  
                {  
                    flag = 1;  
                    array[j] = array[j] + array[j+1];  
                    array[j+1] = array[j] - array[j+1];  
                    array[j] = array[j] - array[j+1];  
                }  
            }  
            if(flag == 0) break;  
        }  
    }  

快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

    int Sort(int array[], int first, int last)  
    {  
        int pivot = array[first];  
        int temp;  
        if(last-first <=0) return -1;  
      
        while(first != last)  
        {  
            while(array[last] >= pivot && last != first) last--;  
            temp = array[first];  
            array[first] = array[last];  
            array[last] = temp;  
            while(array[first] <= pivot && last != first) first++;  
            temp = array[first];  
            array[first] = array[last];  
            array[last] = temp;  
        }  
        return last;  
    }  
      
    void quickSort(int array[], int length)  
    {  
        int temp = Sort(array, 0, length-1);  
        if(temp == -1 ) return;  
        quickSort(array,temp+1);  
        quickSort(&array[temp+1],length-temp-1);  
    }  

归并排序

算法概要：归并排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

void Merge(int A[],int low,int mid,int high)      

     {      
         int i,j,k;    
         int *P = new int[mid-low+1],*Q = new int[high-mid];      
         
         for (i =0;i  < mid - low +1;++i)   P[i] = A[i+low];
              
         for (i = 0; i  < high - mid;++i)   Q[i] = A[mid+1+i];      
          
         i = j = 0,k = low;      
         while ((i  <= mid-low) && (j  <= high-mid-1))      
         {      
          
             if (P[i]  <= Q[j])   A[k++] = P[i++];      
             else  A[k++]= Q[j++];      
         }      
          
         if (i > mid - low)   { for (;j  <= high-mid-1;++j)   A[k++] = Q[j]; }      
         else     
         {   for (; i <= mid - low;++i)   A[k++] = P[i];  }      
          
         delete [] P;      
         delete [] Q;      
     }      
          
     void mergeSort(int A[],int left,int right)      
     {      
         if (left  < right)      
         {      
             int i = (left + right) / 2;      
             MergeSort(A,left,i);      
             MergeSort(A,i+1,right);      
             Merge(A,left,i,right);      
         }      
     }