考研数据结构——排序

人生哪有最好，把每一个当下做到最好，就很不错了呀。

以下以考试主要考查的重点内容为主体，讲述过程以方便大家记忆为上，并不面面俱到。

 

首先得知道排序分内部排序和外部排序。

内部排序：排序整个过程中数据在内存中。

外部排序：排序整个过程中数据会有出现在内、外存之间调动的情况。

考研主要考内部排序。

内部排序主要分三大类（这里是大的类别名不是排序算法的名字）：插入排序、交换排序、选择排序（还有归并和基数排序）

先讲最普遍常用的：交换排序有两种：冒泡排序+快速排序

1. 冒泡：每次两两交换，小的在前大的在后，一趟一趟跑，直到全部有序。每次可以确定一个元素的最终位置，时间复杂度：O（n^2）  冒泡排序是稳定的排序。快速排序，传入的参数有三个，一个数组，两个位置。每次可以确定一个元素的最终位置，时间复杂度o(n^2),由于快排中应用了递归，需要一个栈，所以空间复杂度是o(log2n)，快排不稳定

   void BubbleSort(Elemtype A[],int n)
   {
       for(int i=0;i<n-1;i++)  //每走一趟会有1个元素待在正确的位置，所以有n次循环
       {
           flag = false;         //表示本趟排序有没有发生交换
           for(int j=n-1;j>1;j--)
           {
               if(A[j-1].key>A[j].key) //如果前边的数比后边的数大
               {
                   swap(A[j-1],A[j]);  //交换
                   flag=true;         //标志交换了
               }
           if(flag==false) return;  //如果本趟排序没发生交换，说明已经有序，该退出了
   }
   
   //不懂的先敲三遍再看注释，加油~

    

2   快速排序，传入的参数有三个，一个数组，两个位置。每次可以确定一个元素的最终位置，时间复杂度o(n^2),由于快排中应用了递归，需要一个栈，所以空间复杂度是o(log2n)，快排不稳定 

/*以下快排出自严蔚敏数据结构书中讲解*/


void QuickSort(int A[],int low ,int high)
{
    int pos=Partition(A,low,high);  //第一次划分出的轴

    QuickSort(A,low,pos-1);    //轴左边继续快排

    QuickSort(A,pos+1,high);  //轴右边继续快排、
}


int Partition(int a[],int low ,int high)
{
    int pivot = a[low];

    while(low<high)  //注意这里没有等于号
    {
        while(low<high && a[high]<=pivot) high--;
        a[low] = a[high];
        while(low<high && a[low]>=pivot ) low++;
        a[high]=a[low];
    }
    a[low]=pivot;
    return low;
}

选择排序包括：简单选择排序和堆排序

  3   简单选择排序：每次先出一个最小的加到前边来，直到排完。时间复杂度o(n^2)空间o(1);是不稳定的排序。

void selectSort(int a[],int len)
{
    int min;
    for(int i=0;i<n-1;i++)  //最后一个自然是有序的所以共比较n-1次
    {
        min=i;
        for (j=i+1;j<n;j++)
        {
            if(a[j]<a[min]) min=j;
        }
        if(min!=i) swap(a[i],a[min]);
    }
}

void swap(int a,int b)
{
    a=a+b;
    b=a-b;
    a=a-b;
}

4   堆排序，第每次确定一们排序位置，时间复杂度o(nlogn)空间o(1)是不稳定的排序 

void HeapMaxSort(int a[],int len)
{
    BuildMaxHeap(a,len);
    for(int i=len;i>1;i--)
    {
        swap(a[1],a[i]);
        AdjustDown(a,1,i-1);
    }
}

void BuildHeapMax(int a[],int len)
{
    for(int i=len/2;i>1;i--)
        AdjustDown(a,i,len);
}

void AdjustDown(int a[].int k,int len)
{
    a[0]=a[k];
    for(i=2*k;i<len;i*=2)
    {
        if(a[i]<a[i+1]) i++;
        if(a[0]>a[i]) break;
        else{
            a[i]=a[k];
            k=i;
        }
    }
    a[k]=a[0];
}

            

插入排序包括直接插入，折半插入，希尔排序，这里不讲希尔，因为考的太少

5 直接插入，每次直接看下一个该放在前面哪个位置，时间复杂度o(n^2)是稳定的排序

void insertSort(int a[],in len)
{
    for (int i=2;i<n;i++)
    {
        if(a[i]<a[i-1])
        {
            a[0]=a[i];   //a[0]是辅助性的位置，也叫哨兵

            for(int j=i-1;a[j]>a[0];j--)
                a[j+1]=a[j];

            a[j+1]=a[0];
        }
    }
}

6  折半插入 时间复杂度o(n^2),稳定

void insertSort(int a[],int len)
{
    int mid,low ,high;
    for(int i=2;i<n;i++)
    {
        a[0]=a[i];
        low=1;
        high=i-1;
        while(low<=high)      //注意，所有折半查找这个位置都有等号
        {
            mid=(low+high)/2;
            if(a[mid]<a[0]) high=mid-1;
            else low=mid+1;
        }
        for(j=i-1;j>=high+1;--j)
            a[j+1]=a[j];

        a[high+1]=a[0];
    }
}