排序算法相关知识

堆排序，归并排序，快速排序应该是排序里面的重难点了。

在408考研中一般是以选择题考研各个排序算法的对比。需要达到对代码具有熟练编写的能力。

大体归为俩类：

1.内部排序：是指在排序期间元素全部存放在内存中的排序;     

2.外部排序：是指在排序期间元素无法全部同时存放在内存中，必须在排序的过程中根据要求不断地在内、外存之间移动的排序。

通常将排序算法分为插入排序、交换排序、选择排序、归并排序和基数排序五大类。

1.插入排序：

基本思想是：每次将一个待排序的记录按其关键字大小插入前面已排好序的子序列，直到全部记录插入完成。其中又分为：直接插入排序、折半插入排序和希尔排序。

1）直接插入排序：

将元素L插入已有序的子序列里，需要执行以下操作。

a.查找除L中的插入位置k；

b.将k及其以后的位置后移；

c.将L复制到k的位置上.

void InsertSort(ElemType A[],int n){
    int i,j;
    for(i=2;i<=n;i++){
        if(A[i]<A[i-1]){   //判断该元素是否小于前驱  （从第二个开始，因为第一个位置没有前驱）
            A[0]=A[i];     //将待排序的元素保存到哨兵
            for(j=i-1;A[0]<A[j];j--)   //依次查找待插入的位置
                    A[j+1]=A[j];       //将元素往后移
            A[j+1]=A[0]; 
        }
}

2）折半插入排序 

将直接插入排序里的比较和移动操作分离，先折半查找元素的待插入位置，然后统一地移动待插入位置之后的所有元素。

void InsertSort(ElemType A[],int n){
        int i,j,low,high,mid;
        for(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];
    }
}

3)希尔排序

基本思想：先将待排序分割成若干形如L【i，i+d，i+2d，......，i+kd】“特殊子表”，即把相隔某个“增量”的记录组成一个子表，对各个子表分别进行直接插入排序，当整个表中的元素已呈“基本有序”时，在对全体记录进行一次直接插入排序。

一般d1取  元素总长/2   di+1=【di/2】  

例如：关键字49 38 65 97 76 13 27 49/ 55 04

第一次分组：49                     13

          分组：      38                      27

          分组：           65                      49/

          分组：               97                        55

          分组：                    76                          04

第一趟排序：13<49 27<38 49/<65 55<97 04<76

则排序结果为：13 27 49/ 55 04  49 38 65 97 76

第二次分组： 13              55             38           76

           分组：        27             04            65

           分组：               49/          49             97

第二趟排序：第一个分组里13<38<55<76；第二个分组：04<27<65;第三个分组：49/=49<97

则排序结果为：13 04 49/ 38 27 49 55 65 97 76

......最终排序增量d=1；排序结果为：04 13 27 38 49/ 49 55 65 76 97

void ShellSort(ElemType A[],int n){
        for(dk=n/2;dk>=1;dk=dk/2){
                for(i=dk+1;i<=n;++i){
                        if(A[i]<A[i-dk]){
                            A[0]=A[i];
                            for(j=i-dk;j>0&&A[0]<A[j];j-=dk)
                                A[j+dk]=A[j];
                            A[j+dk]=A[0];
            } //if
}

2.交换排序

1）冒泡排序

        基本思想：从后往前（或从前往后）俩俩比较相邻元素的值，若为逆序，则交换他们，直到序列比较完，我们称它为第一趟冒泡，结果是将最小的元素交换到待排序列的第一个位置（或者是最大的元素交换到待排序的最后一个位置），关键字小的元素如气泡一般逐渐往上“漂浮”直至“水面”（或关键字大的像石头一样沉入水底）.....

      

void BubbleSort(ElemType A[],int n){
        for(int i=0;i<n-1;i++){
              flag=false;//表示本趟冒泡是否发生交换的标志
              for(j=n-1;j>i;j--)
                    if(A[j-1]>A[j]){
                        swap(A[j-1],A[j]);
                        flag=true;
                    }
              if(flag==false){
                    return;      //本趟遍历后没有发生交换，说明表已经有序
    }
}
 

void swap(int &a,int &b){
        int temp=a;
        b=a;
        a=temp;
}

2）快速排序

基本思想：基于分治法，在待排序表L【1...n】中任取一个元素pivot作为枢轴（通常是取首元素），通过一趟排序将待排序表划分为独立的俩部分L【1...k-1】和L【k+1...n】，使得L【1...k-1】中的所有元素小于pivot，L【k+1...n】中的所有元素大于等于pivot，则pivot放在了其最终位置L(k)上，这个过程称为一趟快速排序（或一次划分）。然后递归地对俩个子表重复上述过程，直至每部分内只有一个元素或空为止。

void QuickSort(ElemType A[],int low,int high){
       if(low<high){
            int pivotpos=Partiotion)A,low,high);
            QuickSort(A,low,pivotpos-1);
            QuickSort(A,pivotpos+1,high);
    }
}

int Partiotion(ElemType A[],int low,int high){
        ElemType 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.选择排序：

1）简单选择排序

        基本思想：假设排序表为L，第i趟排序即从L中选择关键字最小的元素与L交换，每一趟排序可以确定一个元素的最终位置，这样经过n-1趟排序就可以使得整个排序表有序。

void SelectSort(ElemType A[],int n){
    for(int i=0;i<n-1;i++){
        min=i;
        for(j=i+1;j<n;j++)
            if(A[j]<A[min]) 
                    min=j;
        if(min!=i)
            swap(A[i],A[min]);
    }
}

2)堆排序

        大根堆：根结点元素大于等于其子节点；

        小根堆：根结点元素小于等于其子节点；

基本思想：首先将存放在L中的n个元素建成初始堆，由于堆本身的特点，堆顶元素就是最大值。输出堆顶元素后，通常将堆底元素送入堆顶，此时根结点已不满足大顶堆的性质，堆杯破坏，将堆顶元素向下调整使其继续保持大顶堆的性质，再输出堆顶元素。

大根堆算法代码:
void BUildMaxHeap(ElemType A[],int len){
    for(int i=len/2li>0;i--){
            HeadAdjust(A,i,len);
}
void HeadAdjust(ElemType A[],int k,in len){
    A[0]=A[k];
    for(i=2*k;i<=len;i*=2){
        if(i<len&&A[i]<A[i+1]){
              i++;
        if(A[0]>=A[i])   break;
        else{
                A[k]=A[i];
                k=i;
        }
    }
    A[k]=A[0];
}

堆排序算法：
void HeapSort(ElemType A[],int len){
  BuildMaxHeap(A,len);
  for(i=len;i>1;i--){
        Swap(A[i],A[1]);
        HeadAdjust(A,1,i-1);
     }
}

4.归并排序

归并排序是将俩个或俩个以上的有序表组合成一个新的有序表。假定待排序表含有n个记录，则可将其视为n个有序的子表，每个字表的长度为1，然后俩俩归并，得到【n/2】个长度为2或1的有序表；继续俩俩归并......如此重复，知道合并成一个长度为n的有序表位置，这种排序方法称为2路归并排序。

初始关键字  （49 38 ）   （65 97）  （76 13） （27）

一趟归并后  （38 49           65 97）    （13 76      27）

二趟归并后    （38 49 65 97                    13 27 76）

三趟归并后   （13 27 38 49 65 76 97）

ElemType  *B=（ElemType *）malloc（（n+1)*sizeof(ElemType));//辅助数组B
void Merge(ElemType A[],int low,,int mid,int high){
        for(int k=low;k<=high;k++){
            B[k]=A[k];
        for(i=low,j=mid+1,k=i;i<mid&&j<=high;k++){
            if(B[i]<=B[j])
                A[k]=B[i++];
            else    
                A[k]=B[j++];
        }
        while(i<=mid)  A[k++]=B[j++];
        while(j<=high)  A[k++]=B[i++];
}

void MergeSort(ElemType A[],int low,int high){
    if(low<high){
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        MergeSort(A,low,mid,high);
    }
}    
            

 5.基数排序

写不动了，自己看

6.算法比较