常见的排序算法C++实现

冒泡排序

void BubbleSort(int nums[],int n){

    for(int i=0;i<n;i++)// 从1到n-1，逐步缩小待排序序列
        for(int j=n-1;j>=i;j--)// 反向监测，检查是否逆序
            if(nums[j]<nums[j-1])// 发生逆序，交换元素的值
            {
                int temp = nums[j];
                nums[j] = nums[j-1];
                nums[j-1] = temp;
            }
}

改进的冒泡排序

void BubbleSort(int nums[],int n){

    bool exchange;
    for(int i=0;i<n;i++)
    {
        exchange = false;//exchange为是否发生交换的标志
        for(int j=n-1;j>=i;j--)
        {
            if(nums[j]<nums[j-1])
            {
                int temp = nums[j];
                nums[j] = nums[j-1];
                nums[j-1] = temp;
                exchage = true;//已经发生交换
            }

            if(exchange = false)//本趟无逆序，停止处理
                return;
        }
    }
}

直接插入排序

void Insertsort(int nums[],int left,int right)
{
    //依次将元素按其排序码插入到有序表中
    int temp,i,j;
    for(i=left+1;i<=right;i++)
    {
        if(nums[i]<nums[i-1])
        {
            j = i-1;
            temp = nums[i];
            do{
                nums[j+1] = nums[j];
                j--;
            }while(j>=left && nums[j]>temp);

            nums[j+1] = temp;
        }

    }
}

二分插入排序

void BinaryInsertSort(int nums[],int left,int right){

    int low,high,middle,temp,i,j;

    for(i=left+1;i<=right;i++){
        temp = nums[i];
        low = left;
        high = right-1;
        while(low<=high)//利用折半搜索插入位置
        {
            middle = (low+high)/2;//取中点
            if(temp<nums[middle])//插入值小于中点值
                high = middle - 1;//向左缩小区间
            else
                low = middle + 1;//否则向右缩小区间
        }
        for(j=i-1;j>=low;j--)//成块移动，空出插入位置
            nums[j+1] = nums[j];

        nums[low] = temp;
    }
}

快速排序

void Qsort(int arr[],int low,int high){

    if(low >= high)
        return;

    int first = low;
    int last = high;
    int key = arr[first];

    while(first<last){

        while(first<last && arr[last]>=key){

            --last;
        }
        arr[first] = arr[last];

        while(first<last && arr[first]<=key){

            ++first;
        }
        arr[last] = arr[first];

    }
    arr[first] = key;
    Qsort(arr,low,first-1);
    Qsort(arr,first+1,high);
}

选择排序

void SelectSort(int R[], int n)
{
    int i, j, m;
    int t;
    for(i=0; i<n-1; i++)
    {
        m = i;
        for(j = i+1; j < n; j++)
        {
            if(R[j] < R[m])
                m = j;
        }
        if(m != i)
        {
            t = R[i];
            R[i] = R[m];
            R[m] = t;
        }
    }
}

归并排序

void Merge(int a[],int left,int mid,int right,int temp[]){

    int i=left,j=mid+1;
    int  m=mid,n=right,k=0;

    while(i<=m && j<=n)
    {
        if(a[i] <= a[j])
        {
            temp[k++] = a[i++];
        }else{
            temp[k++] = a[j++];
        }
    }

    while(i<=m)
    {
        temp[k++] = a[i++];
    }

    while(j<=n)
    {
        temp[k++] = a[j++];//第一个表未检测完，复制
    }

    for(i=0;i<k;i++)
    {
        a[left+i] = temp[i];//第二个表未检测完，复制
    }
}

void MergeSort(int a[],int left,int right,int temp[]){

    if(left >= right)
        return;

    int mid = (left+right)/2;//从中间划分为两个子序列
    MergeSort(a,left,mid,temp);//对左侧子序列进行递归排序
    MergeSort(a,mid+1,right,temp);//对右侧子序列进行递归排序
    Merge(a,left,mid,right,temp);//合并
}

堆排序

void siftDown(int* heap,int start,int n){

    int i=start,j=2*i+1;//j是i的左子女
    int temp = heap[i];//暂存子树根节点

    while(j<=n){//检测是否到最后位置

        if(j<n && heap[j]<heap[j+1])//child指向两子女的最大者
            j++;

        if(temp>=heap[j])//temp的排序码大则不做调整
            break;
        else{//否则子女中大的上移
            heap[i] = heap[j];
            i=j;//i下降到子女位置
            j=2*i+1;
        }
    }
    heap[i] = temp;//temp中暂存元素放到合适位置
}

void Swap(int a,int b){
    int c = a;
    a = b;
    b = c;
}

void HeapSort(int* heap,int n){

    for(int i=(n-2)/2;i>=0;i--)//将表转化为堆
    {
        siftDown(heap,i,n-1);
    }
    for(int j=n-1;j>=0;j--)//对表排序
    {
        //交换建立最大堆
        Swap(0,j);
        siftDown(heap,0,j-1);

    }
}