基础排序代码

Posted 2021-08-04 牧空

冒泡

void BubbleSort(int *h,size_t len){
    if(h==NULL) return;
    if(len<=1) return;
    
    for(int i = 0;i<len-1;i++){
        for(int j = 0;j<len-1-i;j++){
            if(h[j]>h[j+1]){
                Swap(h[j],h[j+1]);
            }
        }
    }
    return;
}

快排

递归

void QuickSort(int *h, int left, int right)
{
    if (h == NULL)
        return;
    if (left >= right)
        return;
    //防止有序队列导致快排效率降低,随机选择提高算法的鲁棒性
    srand((unsigned)time(NULL));
    int len = right - left;
    int k_index = rand() % (len + 1) + left;
    Swap(h[left], h[k_index]);

    int key = h[left], i = left, j = right;
    while (i < j)
    {
        while (h[j] >= key && i < j)
            j--;
        //找到h[j]<key停止,并交换
        if (i < j)
            h[i] = h[j];
        while (h[i] < key && i < j)
            i++;
        if (i < j)
            h[j] = h[i];
    }
    h[i] = key;

    QuickSort(h, left, i - 1);
    QuickSort(h, j + 1, right);
}

非递归

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; //pivot的最终落点
    return low;
}

//非递归快排
void QuickSort(int a[], int left, int right)
{
    //手动利用栈来存储每次分块快排的起始点
    //栈非空时循环获取中轴入栈
    stack<int> s;
    if (left < right)
    {
        int boundary = Partition(a, left, right);

        if (boundary - 1 > left) //确保左分区存在
        {
            //将左分区端点入栈
            s.push(left);
            s.push(boundary - 1);
        }
        if (boundary + 1 < right) //确保右分区存在
        {
            s.push(boundary + 1);
            s.push(right);
        }

        while (!s.empty())
        {
            //得到某分区的左右边界
            int r = s.top();
            s.pop();
            int l = s.top();
            s.pop();

            boundary = Partition(a, l, r);
            if (boundary - 1 > l) //确保左分区存在
            {
                //将左分区端点入栈
                s.push(l);
                s.push(boundary - 1);
            }
            if (boundary + 1 < r) //确保右分区存在
            {
                s.push(boundary + 1);
                s.push(r);
            }
        }
    }
}

归并

void MergeArray(int * arr, size_t left,size_t mid,size_t right,int *temp){
    if(arr==NULL) return;
    size_t i = left,j = mid + 1,k=0;
    while(i<=mid && j<=right){
        if(arr[i]<=arr[j]){
            temp[k++] = arr[i++];
            continue;
        }
        
        temp[k++] = arr[j++];
    }
    while(i<=mid)
        temp[k++] = arr[i++];
    while(j<=right)
        temp[k++] = arr[j++];
    memcpy(&arr[left],temp,k*sizeof(int));
    return;
}

void MMergeSort(int *arr,size_t left,size_t right,int * temp){
    if(left<right){
        size_t mid = (left+right)/2;
        MMergeSort(arr,left,mid,temp);
        MMergeSort(arr,mid+1,right,temp);
        MergeArray(arr,left,mid,right,temp);
    }
}

void MergeSort(int *h,size_t len){
    if(h==NULL) return;
    if(len<=1) return;
    int * temp = (int *) calloc(len,sizeof(int));
    MMergeSort(h,0,len-1,temp);
    memcpy(h,temp,sizeof(int) *len);
    free(temp);
    return ;
}

插入

void InsertSort(int * h,size_t len){
    if(h==NULL) return;
    if(len<=1) return;
    int i,j;
    
    for(i=1;i<len;i++){
        for(j=i;j>0;j--){
            if(h[j]<h[j-1])
                Swap(h[j],h[j-1]);
            else 
                break;
        }
    }
    return;
}

希尔排序

void ShellSort(int * h,size_t len){
    if(h==NULL) return;
    if(len<=1) return;
    //div 步长,k 组号
    for(int div=len/2;div>=1;div/=2){
        for(int k=0;k<div;k++){
            for(int i=div+k;i<len;i+=div){
                for(int j=i;j>k;j-=div){
                    if(h[j]<h[j-div]) Swap(h[j],h[j-div]);
                    else break;
                }
            }
        }
    }
    return;
}

选择

void SelectionSort(int* h,size_t len){
    if(h==NULL) return;
    if(len<=1) return;
    
    int min_index,i,j;
    //i已排序的,j后面还需要排的序列
    for(i=0;i<len-1;i++){
        min_index = i;
        for(j=i+1;j<len-1;j++){
            if(h[j]<h[min_index]) min_inde = j;
        }
        Swap(h[i],h[min_index]);
    }
    return ;
}

堆排序

//===调整堆===	
void AdjustHeap(int *h,int node,int len){
    int index = node;
    int child = 2*index + 1;
    while(child<len){
        if(child+1<len && h[child]<h[child+1])
            child++;
        if(h[index]>=h[child]) break;
        Swap(h[index],h[child]);
        index = child;
        child = 2*index+1;
    }
}
//===建堆===
void MakeHeap(int *h,int len){
    for(int i=len/2;i>=;i--){
        AdjustHeap(h,i,len);
    }
}
//===排序===
 void HeapSort(int *h,int len){
     MakeHeap(h,len);
     for(int i=len-1;i>=0;i--){
         Swap(h[i],h[0]);
         AdujstHeap(h,0,i);
     }
 }