插入排序, 合并排序, 快速排序C++源代码

下面3个排序函数都是对数组进行排序, 排序后为非递减序列
函数模版,  两个参数, 一个是数组首地址, 另一个是元素个数， 如 merge_sort( A, 20);

/**/ /*******************************Insertion sort ****************************************/
template  < class  T >
void  insertion_sort(T entry[],  int  count)
... {
   int first_unsorted;    //  position of first unsorted entry
   int position;          //  searches sorted part of list
   T current;        //  holds the entry temporarily removed from list

   for (first_unsorted = 1; first_unsorted < count; first_unsorted++)
      if (entry[first_unsorted] < entry[first_unsorted - 1]) ...{
         position = first_unsorted;
         current = entry[first_unsorted];         //  Pull unsorted entry out of the list.
         do ...{               //  Shift all entries until the proper position is found.
            entry[position] = entry[position - 1];
            position--;                           //  position is empty.
         } while (position > 0 && entry[position - 1] > current);
         entry[position] = current;
      }
}
/**/ /*******************************Insertion ^^^^ sort ****************************************/

合并排序:

/**/ /******************************Merge sort***************************************/
template < typename T >
void  merge(T arr[],  int  low,  int  mid,  int  high)
/**/ /* merge arr[low..mid] and arr[mid+1..high]; */
... {
    int i, j, k;
    int len1=mid-low+1;
    int len2=high-mid;
    T *left=new T[len1];
    T *right=new T[len2];
    for(i=0; i<len1; i++)
        left[i]=arr[low+i];
    for(i=0; i<len2; i++)
        right[i]=arr[mid+1+i];
    for(i=0, j=0, k=low; i<len1 && j<len2 ; k++)
        if(left[i]<=right[j])
            arr[k]=left[i++];
        else
            arr[k]=right[j++];
    if(i>=len1)
        while( j<len2)
            arr[k++]=right[j++];
    else 
        while( i<len1)
            arr[k++]=left[i++];
      delete[] left;               // remember to delete
      delete[] right;
    return;
}

template < typename T >
void  recursive_merge_sort(T arr[],  int  low,  int  high)
... {
    if(low<high)
    ...{
        int    mid=(low+high)/2;
        recursive_merge_sort(arr, low, mid);
        recursive_merge_sort(arr, mid+1, high);
        merge(arr, low, mid, high);
    }
}

template < typename T >
void  merge_sort(T arr[],  int  num)
... {
    recursive_merge_sort(arr, 0, num-1);
}

/**/ /******************Merge ^^^^^ sort****************************************************/

快速排序:

/**/ /******************************************Quick sort *******************************/
template  < class  T >
int  partition(T entry[],  int  low,  int  high)
... {
   T pivot;
   int i,            //  used to scan through the list
       last_small;   //  position of the last key less than pivot
   swap(entry[low], entry[(low + high) / 2]);
   pivot = entry[low];   //  First entry is now pivot.
   last_small = low;
   for (i = low + 1; i <= high; i++)
      if (entry[i] < pivot) ...{
         last_small = last_small + 1;
         swap(entry[last_small], entry[i]);  //  Move large entry to right and small to left.
      }
   swap(entry[low], entry[last_small]);      //  Put the pivot into its proper position.
   return last_small;
}

template  < class  T >
void  recursive_quick_sort(T entry[],  int  low,  int  high)
... {
   int pivot_position;
   if (low < high) ...{   //   Otherwise, no sorting is needed.
      pivot_position = partition(entry, low, high);
      recursive_quick_sort(entry, low, pivot_position - 1);
      recursive_quick_sort(entry, pivot_position + 1, high);
   }
}

template  < class  T >
void  quick_sort(T entry[],  int  count)
...{
   recursive_quick_sort(entry, 0, count - 1);
}

例子:

#include<iostream>
#include<cstdlib>
#include<ctime>
using   namespace  std;

int  main()
... {
    srand((unsigned)time( NULL ) ); //Seed the random-number generator with current time        
    int i, n=20;
    int arr[30];
    cout<<"before sorting: ";
    for(i=0; i<n; i++)
    ...{
        arr[i]=rand()%100;               // rand() 返回0－RAND_MAX (32767)的伪随机数
        cout<<arr[i]<<endl;
    }
    //quick_sort(arr, n):       // 调用quick_sort 
    //insertion_sort(arr, n);    // 调用insertion_sort
    merge_sort(arr, n);
    cout<<"after sorting: ";
    for(i=0; i<n; i++)
        cout<<arr[i]<<endl;
    return 0;
}