排序算法

目录

目录

简单插入排序

希尔排序

冒泡排序

快速排序

简单选择排序

堆排序

二路归并排序

分治归并排序

比较

---

一、简单插入排序

void InsertSort(int A[], int n){    
    int i,j,temp;
    for(i=1; i<n; i++)
        if(A[i]<A[i-1]){    
            temp = A[i];  
            for(j=i-1; j>=0 && A[j]>temp; --j)
                A[j+1] = A[j];     
            A[j+1] = temp;         
        }
}

---

二，折半插入排序

void InsertSort(int 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--){    //high+1 也要换走
            A[j+1]=A[j];    
        }
        A[high+1]=A[0];
    }
}

三.希尔排序

代码如下（示例）：

void ShellSort(int A,int n){
    for(int d=n/2;d>=1;d/=2){
        for(int i=d+1;i<=n;i++){    //i=d+1
            if(A[i]<A[i-d]){
                A[0]=A[i];
                for(int j=i-d;j>0 && A[0]<A[j];j-=d)    //i指向后，j指向前
                    A[j+d]=A[j];
                A[j+d]=A[0];
            }
    }
}

---

四.快速排序

void QuickSort(int A[],int low,int high){
    if(low<high){
        int pivotpos=position(A,low,high);    //找分界线
        QuickSort(A,low,pivotpos-1);
        QuickSort(A,pivotpos+1,high);
}
int position(int A[],int low,int high){    //int 
    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;
}

1.空O(logn) O(n)    时O(n*logn) O(n^2)

五.简单选择排序

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

1.空O(1) 时O(n^2) (时永远不变) 不稳定

六.堆排序

void BuildMaxHeap(int A[],int len){
    for(int i=len/2;i>0;i--){
        HeadAdjust(A,i,len);
    }
}
void HeadAdjust(int A[],int k,int len){
    A[0]=A[k];  //不可放于for之内，保存k指。逐级比较，最后确认
    for(int i=k*2,i<=len;i*=2){
        if(i<len && A[i]<A[i+1])    //防止i为最后结点
            i++;
        if(A[0]>=A[i])
            break;
        else{
            A[k]=A[i];
            k=i;
        } 
    }
    A[k]=A[0];
}
void HeapSort(int A[],int len){
    BuildMaxHeap(A,len);
    for(int i=len;i>1;i--){     //将堆顶元素与堆尾交换，后将元素降下去，重新形成大根堆
        swap(A[1],A[i]);    //len为节点个数，不用减一
        HeadAdjust(A,1,i-1);
    }
}

1.S O(1)   T O(n*logn)   jiandui O(n)   cha O(n*logn)  不稳健的排序

七.归并排序

int *B=(int *)malloc(n*siezeof(int));
void Merge(A[],int low,int mid,int high){
    for(int i=low;i<=high;i++){
        B[i]=A[i];
    }
    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++]=A[i++];
    while(j<=high) A[k++]=A[j++];
}
void MergeSort(int A[],int low,int high){
    if(low<high){
        int mid=(low+high)/2;
        MergeSort(A,low,mid);
        MergeSort(A,mid+1,high);
        Merge(A,low,mid,high);
    }
}

1.S O(n）  T O(nlogn) 稳健

八.冒泡排序

void swap(int &a,int &b){
    int temp=a;
    b=a;
    a=temp;
}
void BubbleSort(int A[],int n){
    for(int i=0;i<n-1;i++){    //n-1处的一定是最大的
        bool tag=false;
        for(int j=n-1;j>i;j--){
            if(A[j]<A[j-1]){
                swap(A[j],A[j-1]);
                tag=true;
            }
        }
        if(tag==false)    //溜达一圈后还为false，则推出，没到一圈不能退
            return;
    }
}