内部排序算法的总结一（包括冒泡、希尔排序、递归和非递归的快速排序、简单选择排序）

一、冒泡法：

//冒泡排序
void Bubble_Sort(DataType a[],int n)
{
    int i,j;
    DataType temp;
    for(i=0;i<n-1;i++)
    {
        for(j=i+1;j<n;j++)
        {
            if(a[i].key<a[j].key)
            {
                temp=a[j];
                a[j]=a[i];
                a[i]=temp;
            }
        }
    }
}
//冒泡2
void Bubble_Sort2(DataType a[],int n)
{
    int j,k;
    DataType temp;
    for (j=0; j<n; j++)         //共有n-1趟排序
    {
        for (k=1; k<n-j; k++)    // 一趟排序
        {
            if (a[k].key<=a[k-1].key )
            {
                temp=a[k] ;
                a[k]=a[k-1] ;
                a[k-1]=temp ;
            }

        }
    }

}

二、希尔排序

1  排序思想

①   先取一个正整数d1(d1<n)作为第一个增量，将全部n个记录分成d1组，把所有相隔d1的记录放在一组中，即对于每个k(k=1, 2,  … d1)，R[k], R[d1+k], R[2d1+k] , …分在同一组中，在各组内进行直接插入排序。这样一次分组和排序过程称为一趟希尔排序；

②   取新的增量d2<d1，重复①的分组和排序操作；直至所取的增量di=1为止，即所有记录放进一个组中排序为止。

//希尔排序
void shell_pass(DataType a[],int n,int d)
   /*  对顺序表L进行一趟希尔排序, 增量为d  */
{
        int j, k ;
        DataType temp;
        for (j=0;j<n-d; j++)
        {
            temp=a[j+d] ;
            k=j;
            while (k>=0&&temp.key<a[k].key)
            {
                a[k+d]=a[k] ;
                k=k-d;
             }
                a[k+d]=temp ;
        }
}
void shell_Sort(DataType a[],int n,int dk[],int t)
{
    int m;
    for (m=0; m<t; m++)
        shell_pass(a,n,dk[m]);


}

三、递归和非递归的快速排序

一趟快速排序方法

        从序列的两端交替扫描各个记录，将关键字小于基准关键字的记录依次放置到序列的前边；而将关键字大于基准关键字的记录从序列的最后端起，依次放置到序列的后边，直到扫描完所有的记录。

快速排序算法

         当进行一趟快速排序后，采用同样方法分别对两个子序列快速排序，直到子序列记录个为1为止。

 

//快速排序
int Quick_one_pass(DataType a[],int n,int low,int high)
{
    int i=low,j=high;
    DataType temp=a[i];
    do
    {   while ((temp.key<a[j].key)&&(j>i))
                j-- ;
                if  (j>i)
                    {
                        a[i]=a[j] ;
                        i++;
                    }
        while ((temp.key>a[i].key)&&(j>i))
                i++ ;
                if  (j>i)
                    {
                        a[j]=a[i] ;
                        j--;
                    }
    } while(i!=j) ;    /*   i=j时退出扫描  */
    a[i]=temp ;
return i ;
}
//递归算法的快速排序
void  Quick_Sort1(DataType a[],int n,int low, int high)
{
    int k ;
if  (low<high)
{
    k=Quick_one_pass(a,n, low, high);
    Quick_Sort1(a,n,low, k-1);
    Quick_Sort1(a,n,k+1, high);
}     /*   序列分为两部分后分别对每个子序列排序   */
}
//非递归的快速排序
#define  MAX_STACK  100
void  Quick_Sort2(DataType a[],int n , int low, int high)
{
    int k , stack[MAX_STACK] ,  top=0;
    do
        {  while  (low<high)
            {
                k=Quick_one_pass(a,n,low,high);
                stack[++top]=high ;
                stack[++top]=k+1 ;
          /*  第二个子序列的上,下界分别入栈  */
                high=k-1 ;
            }
            if (top!=0)
            {
                low=stack[top--] ;
                high=stack[top--] ;
            }
        }while (top!=0&&low<high) ;
}

四、简单选择排序

选择排序(Selection Sort)的基本思想是：每次从当前待排序的记录中选取关键字最小的记录表，然后与待排序的记录序列中的第一个记录进行交换，直到整个记录序列有序为止。

       简单选择排序(Simple Selection Sort ，又称为直接选择排序)的基本操作是：通过n-i次关键字间的比较，从n-i+1个记录中选取关键字最小的记录，然后和第i个记录进行交换，i=1, 2, … n-1 。

//简单选择排序
void simple_selection_sort(DataType a[],int n)
{
    int i,j,flag=0;
    DataType temp;
    for(i=0;i<n;i++)
    {
        flag=i;
     for(j=i+1;j<n;j++)
     {
         if(a[flag].key>=a[j].key)
         {
             flag=j;
         }
     }
    if(i!=flag)
    {
          temp=a[flag];
     a[flag]=a[i];
     a[i]=temp;
    }
    }
}