C++數據結構-----排序

冒泡排序算法：

                  N個數進行排序，進行N-1趟排序，第i趟排序比較N-i次，運用兩個for循環實現。

代碼如下：

void sort(int a[],int len,bool f)
{
		int i,j;
		for(i=1;i<len;i++)
		{
		    for(j=0;j<len-i;j++)
			{
					if((f&&a[j]>a[j+1])||(!f&&a[j]<a[j+1]))
					{
							a[j]^=a[j+1];
							a[j+1]^=a[j];
							a[j]^=a[j+1];
                     }
              }
          }
}

排序函數sort對傳入的數組進行排序，len爲數組長度，f決定升降序。

選擇排序算法：

N個數進行排序，type  a[N], 默認升序排列

                        1.第1趟尋找數組中最小元素與a[0]交換

                        2.第2趟由a[1]遍歷最小元素與a[1]交換

                       3.第i趟由a[i-1]遍歷最小元素與a[i-1]交換

  總結共進行N-1趟排序，第i趟由a[i-1]遍歷數組與a[i-1]交換。

void Selection_Sort(int a[],int n)
{
    int flag;
    int m;
    int i,j;

    for(i=1;i<n;i++)//進行N-1趟排序
    {
        m=a[i-1];flag=i-1;
        for(j=i-1;j<n;j++)//第i趟由a[i-1]開始遍歷數組找最小的元素與a[i-1]交換
        {
            if(a[j]<m)
            {
                m=a[j];
                flag=j;
            }
        }
        a[flag]=a[i-1];
        a[i-1]=m;
    }
}

插入排序算法：

                         N個元素進行排序，默認升序排列。

                         1.a[0]與a[1]進行升序排列

                         2.從a[2]開始遍歷，若a[i]與a[i-1]升序則繼續循環。

                         3.若a[i]<a[i-1],則從a[i-2]往回遍歷找到比a[i]小的元素，進行插入即可

void Straight_Insertion_Sort(int a[],int n)
{
     if(a[1]<a[0])
     {
         int t;
         t=a[0];
         a[0]=a[1];
         a[1]=t;
     }
     int i,j,k;
     int tmp1,tmp2;
     for(i=2;i<n;i++)//n-2次比較
     {
         if(a[i]>=a[i-1])//若升序，則繼續遍歷
            continue;
         for(j=i-2;j>=0;j--)//從a[i-2]往回遍歷尋找插入的位置
         {
             if(a[j]<=a[i])
             {
                 k=j+1;
                 break;

             }
             if(j==0)
                k=0;
         }
         tmp1=a[k];
         a[k]=a[i];
         for(;k<i;k++)//進行插入   k,k+1,k+2,...i-1,i
                               //  i,k,k+1,k+2,...,i-2,i-1
            {
                tmp2=a[k+1];
                a[k+1]=tmp1;
                tmp1=tmp2;
            }
     }
}

   N個數進行排序，共進行N-1趟排序 ，第i趟排序將序列中的第i+1個元素插入到一個已經按值有序的子序列（k1,k2,k3,k4,...ki）中的合適位置，使得插入後仍然有序

void iiinsert(int a[],int n)
{
        int i,tmp,j,flag;
        for(i = 1; i<n; i++)//進行n-1趟排序
        {
                tmp=a[i];
                flag=i;
                for(j = i-1; j>=0 && tmp < a[j]; j--)//將值插入到子序列中使之仍然有序
                {
                             a[flag--]=a[j];  //不斷的交換直到遇到合適的位置
                             a[j]=tmp;
                }

            }
}

void insert(int a[],int n)
{
		int i,j;
		int tmp;
		for(i = 1; i<n; i++)
		{
		     tmp=a[i];
			 j=i-1;
			 while(j >= 0 && tmp < a[j])//找到tmp的插入位置
					 a[j+1]=a[j--];//將a[j]後移
            a[j+1]=tmp;//插入指定位置
        }
}

快速排序：

                 在當前的排序序列(k1,k2,k3,k4,k5,..)中任選一個元素作爲基準元素，把小於等於基準元素的所有元素都移到基準元素的前面，把大於基準元素的所有元素都移到基準元素的後面，這樣使得基準元素所處的位置恰好就在排序完成的最終位置，並且把當前參加排序的序列分成了兩個子序列，對子序列進行遞歸排序即可。

void quicksort(int a[],int n)//快速排序
{                       //任意選取一個基準元素，把小於等於基準元素的放在前面
                        //把大於基準元素的放在後面
                        //再將兩個子列進行排序.
    if(n<=1) return;
    if(n==2)
    {
        if(a[0]>a[1])
            swap(a[1],a[0]);
        return ;
    }
    swap(a[0],a[n/2]);
    int jie=a[0];
    int* L;
    int* R;
    L=a;
    R=a+n-1;
    while(L<R)
    {
        while(L<R && *L<jie) ++L;//定義左指針，不斷左移
        while(R>a && *R>jie) --R;//定義右指針，不斷右移
        if(L<R) swap(*L,*R);//如果兩指針未交叉，就交換
    }
    if(*R<jie)//交叉後交換界值與右指針所指元素位置
    swap(a[0],*R);
    quicksort(a,R-a);//兩個子序列進行遞歸
    quicksort(R+1,n-(R-a)-1);
}

備註：可以另外開闢一個數組實現快速排序算法。

希爾排序：又稱爲縮小增量排序

             基本思想：設定一個元素間隔增量爲gap，將參加排序的序列按這個間隔數gap從第一個元素一次分成若干子序列，進行排序，不斷的縮小增量直到gap=1爲止。

void shellsort(int a[],int n)
{
    int gap=n/2;
    while(gap>=1)
    {
        for(int i=0;i+gap<n;i++)
        {
            if(a[i]>a[i+gap])
                swap(a[i],a[i+gap]);
        }
        gap=gap/2;

    }
}