基本排序算法程序实现

简单算法O(n^2)：冒泡法<简单选择排序<直接插入排序（性能比较）

改进算法：希尔排序、堆排序、归并排序、快速排序

数组交换语句swap()

void swap(int* sortList,int intA,int intB)
{
    int a=sortList[intA];
    sortList[intA]=sortList[intB];
    sortList[intB]=a;
}

冒泡法（改进）

void BubbleSort(int* sortList,int len)
{
	bool isOrder=false; //哨兵
	for(int i=0;(i<len-1)&&!isOrder;i++)
	{
		isOrder=true;
		for(int j=len-1;j>=i;j--)
		{
			if(sortList[j]<sortList[j-1])
			{
				swap(sortList,j,j-1);
				isOrder=false;
			}
		}
	}
}

简单选择排序

void SimpleSort(int* sortList, int len)
{
	int minIndex;
	for(int i=0;i<len;i++)
	{
		minIndex=i;
		for(int j=i+1;j<len;j++)
		{
			if(sortList[i]>sortList[j])
				minIndex=j;
		}
		if(minIndex!=i)
			swap(sortList,i,minIndex);
	}
}

直接插入排序

void DirectInsertionSort(int* sortList,int len)
{
    int tempInt;
    for(int i=1;i<len;i++)
    {
        if(sortList[i]>sortList[i-1])continue;

        tempInt=sortList[i];
        int j;
        for(j=i-1;sortList[j]>tempInt&&j>=0;j--)
        {
            sortList[j+1]=sortList[j];
        }

        sortList[j+1]=tempInt;
    }
}

改进算法

希尔排序

void ShellSort(int* sortList,int len)
{
    int g=len;
    do
    {
        g=g/3+1;
        for(int i=0;i<g;i++)
        {
            for(int j=i+g;j<len;j+=g)
            {
                if(sortList[j]<sortList[j-g])
                {
                    int temp=sortList[j];
                    int k=j-g;
                    while(sortList[k]>temp&&k>=0)
                    {
                        sortList[k+g]=sortList[k];
                        k-=g;                
                    }
                    sortList[k+g]=temp;
                }
            }
        }
    }while(g>1);
}

堆排序（注意数组从1开始）

void HeapSort(int* sortList,int len)
{

    for(int j=len/2;j>0;j--)
    {
        HeapAdjust(sortList,j,len);
    }

    for(int fn=len;fn>1;fn--)
    {
        swap(sortList,1,fn);
        HeapAdjust(sortList,1,fn-1);
    }
}

void HeapAdjust(int* sortList,int r,int k)
{
    int temp,j;
    temp=sortList[r];
    for(j=2*r;j<=k;j=j*2)
    {
        if(j<k&&sortList[j]<sortList[j+1])
            j++;
        if(temp>=sortList[j])
            break;
        sortList[r]=sortList[j];
        r=j;
    }
    sortList[r]=temp;
}

归并排序

递归思想

const int MAXSIZE=10000;

void MergeSort(int* sortList,int len)
{
    MSort(sortList,sortList,0,len-1);
}

void MSort(int* SR,int* TR,int st,int fn)
{
    int* TR2=new int[MAXSIZE];
    int mid;
    if(st==fn)
    {
        TR[st]=SR[st];
    }
    else
    {
        mid=(st+fn)/2;
        MSort(SR,TR2,st,mid);
        MSort(SR,TR2,mid+1,fn);
        Merge(TR2,TR,st,mid,fn);
    }
    delete[] TR2;
}

void Merge(int* TR2,int* TR,int st,int mid,int fn)
{
  int index,s1,s2;
  index=st;
  for(s1=st,s2=mid+1;s1<=mid&&s2<=fn;index++)
  {
      if(TR2[s1]<TR2[s2])
      {
          TR[index]=TR2[s1++];
      }
      else
      {
          TR[index]=TR2[s2++];
      }
  }

  if(s1<=mid)
      for(s1;s1<=mid;s1++)
          TR[index++]=TR2[s1];

  if(s2<=fn)
      for(s2;s2<=fn;s2++)
          TR[index++]=TR2[s2];
}

快速排序

void QuitSort(int* sortList,int len)
{
    QSort(sortList,0,len-1);
}

void QSort(int* sortList,int low,int high)
{
    int pivot;
    if(low<high)
    {
        pivot=Partition(sortList,low,high);
        QSort(sortList,low,pivot-1);
        QSort(sortList,pivot+1,high);
    }
}

int Partition(int* sortList,int low,int high)
{
    int pivot=sortList[low];
    while(low<high)
    {
        while(high>low&&sortList[high]>=pivot)
            high--;
        swap(sortList,low,high);
        while(high>low&&sortList[low]<=pivot)
            low++;
        swap(sortList,low,high);
    }
    return low;
}