算法——排序算法个人总结

总结：

O(n^2) 冒泡/插入/选择

O(nlogn) 高速/归并/堆

O(n^1.3) Shell排序

O(n) 桶/基数(位数区别不大。先低位排序后高位排序)/箱子

数据为正序时，插入和冒泡最佳。

稳定排序： 冒泡/插入/基数/归并。

不稳定排序：选择/高速/shell/堆。

邻近交换的排序基本上是稳定的。存在远距离交换的是不稳定排序。

详细代码例如以下：

#include<algorithm>
/*  冒泡排序：相邻元素比較。n为数据长度*/
template<typename T>
void BubbleSort(T* r, int n)
{   T temp; bool empty;
    for(int i=0;i<n-1;i++)
    {   empty=false;
        for(int j=0;j<n-1-i;j++)
            if(r[j]>r[j+1])
            {temp=r[j];r[j]=r[j+1];r[j+1]=temp; empty=true;}
        if(!empty)
            return ;
    }
}
/*高速排序：左边比他小，右边比他大，递归实现；
定义的一个重要数据，能够省去数据交换操作
low=0,high=数据长度-1*/
template<typename T>
void QuickSort(T a[],int low,int high)
{   if(low >=high)
        return ;
    T elem = a[low];    int l = low, r = high;
    while(l < r)
    {   while(l < r && a[r] >= elem) r--;
        if (l < r){ a[l++] = a[r];  }
        while(l< r && a[l] <= elem) l++;
        if (l < r)  {   a[r--] = a[l];  }
    }
    a[r] = elem;
    QuickSort(a,low,r-1);
    QuickSort(a,r+1,high);
}
/*插入排序：数据向右移动。a[j+1]=a[j]
n为数据长度*/
template<typename T>
void InsertSort(T a[],int n)
{  int i,j; T elem;
    for (i=1;i<n ;++i)
    {   j = i- 1;   elem = a[i];
        while(j>=0 && elem < a[j] ) {   a[j+1] = a[j];    j--;  }
        a[j+1] = elem;
    }
}
/*希尔（shell）排序：分组进行插入排序(把插入排序1的改成d就可以)
n为数据长度*/
template<typename T>
void ShellInsert(T arra[],int d,int n)
{  int i,j;  T elem;
    for ( i = d;i < n;i++)  //首个下标从d開始
    {   j = i - d;      elem = arra[i];
        while (j >= 0 && elem < arra[j])
        {  arra[j+d] = arra[j];   j = j - d;  }
        arra[j+d] = elem;
    }
}
template<typename T>
void ShellSort(T arra[],int n)
{  int inc = n;
    do  { inc = inc/2;
        ShellInsert(arra,inc,n);
    }   while (inc > 1);
}
/*选择排序：在未排序中找出最小的放在前面*/
template <typename T>
void SelectSort(T a[],int n)
{   T  elem;
    for (int i=0;i<n-1;i++)
    {   int elemNum = i;
        for (int j= i+1;j<n;j++)
            if (a[j] < a[elemNum])
                elemNum = j;
        if (elemNum != i)
        {   elem = a[i];    a[i] = a[elemNum];  a[elemNum] = elem;}
    }
}
/*归并排序：左边小取左边，左边++；右边小取右边，右边++*/
template<typename T>
void Merge(T arra[], int low, int mid, int high)
{   int k;   T *temp = new T[high-low+1];
    int begin1 = low, end1 = mid, begin2 = mid + 1, end2 = high;
    for (k = 0; begin1 <= end1 && begin2 <= end2; ++k)
    {   if(arra[begin1]<=arra[begin2])      temp[k] = arra[begin1++];
        else        temp[k] = arra[begin2++];
    }
    if(begin1 <= end1)
        for(int p=begin1;p<=end1;p++)   temp[k++]=arra[p];
    if(begin2 <= end2)
         for(int p=begin2;p<=end2;p++)   temp[k++]=arra[p];
    for(int s=left;s<=right;s++)      arra[s]=temp[s-left];
    delete []temp;
}
template<typename T>
void MergeSort(T arra[], unsigned int first, unsigned int last)
{   int mid = 0;
    if(first>=last) return;
    mid = (first+last)/2;
    MergeSort(arra, first, mid);
    MergeSort(arra, mid+1,last);
    Merge(arra,first,mid,last);
}
//*堆排序*/
template <typename E>
void HeapDown( E a[],int pos,int len)
{   E temp=a[pos]; int k=pos;//插入排序的思想
      for(int i=2*k+1;i<len;i=2*i+1)//下标从0開始
      { if(i<len-1 && a[i]<a[i+1]) i++;
            if(a[i]>temp) {a[k]=a[i];k=i;}
            else break;
      }
      a[k]=temp;
}
template <typename E>
void HeapSort( E a[],int n)
{     for(int i=n/2;i>=0;i--) HeapDown(a,i,n);//建堆
      for(int j=n-1;j>=1;j--)
      {     swap(a[j],a[0]);
            HeapDown(a,0,j);
      }
}