C++实现排序算法

稳定性：快速 希尔 选择 堆排序不稳定

时间复杂度：平均情况下，快速、希尔、归并和堆排序的时间复杂度均为O(nlog2(n))，其他都是O(n^2)。最坏情况下，快排的时间复杂度为O(n^2)

#include <iostream>
#include <stdlib.h>
#include <time.h>
#define N 1000
using namespace std;

//输出
void output(int a[], int num){
    for(int i=0;i<num;i++){
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

//交换元素位置
void swap(int a[], int index1, int index2){
    int tmp = a[index1];
    a[index1] = a[index2];
    a[index2] = tmp;
}

//快速排序
void quickSort(int a[], int l, int r, int num){
    if(l<r){
        int left = l;
        int right = r;
        int tmp = a[l];
        while(left<right){
            while(left<right && a[right]>=tmp){
                right--;
            }
            if(left<right){
                a[left++] = a[right];
            }
            while(left<right && a[left]<=tmp){
                left++;
            }
            if(left<right){
                a[right--] = a[left];
            }
        }
        a[left] = tmp;
        //output(a,num);
        quickSort(a,l,left-1,num);
        quickSort(a,left+1,r,num);
    }
}

//冒泡排序
void bubbleSort(int a[], int num){
    int i,j;
    int flag = 0;
    for(i=num-1;i>0;i--){
        flag = 0;
        for(j=0;j<i;j++){
            if(a[j]>a[j+1]){
                swap(a,j,j+1);
                flag=1;
            }
        }
        if(flag==0){
            break;
        }
    }
}

//选择排序
void selectSort(int a[], int num){
    int right,i;
    int maxIndex;
    for(right=num-1;right>0;right--){
        maxIndex = 0;
        for(i=0;i<right;i++){
            if(a[maxIndex]<a[i]){
                maxIndex = i;
            }
        }
        swap(a,maxIndex,right);
    }
        
}

//建立大顶堆
void buildHeap(int a[], int index, int len){
    int curParent = a[index];
    int child = index * 2 +1;
    while(child<len){
        if(child+1<len && a[child]<a[child+1]){
            child++;
        }
        if(curParent < a[child]){
            a[index] = a[child];
            //这里不用把curParent赋值给child，因为还要迭代子树，如果孩子中有更大的，会上移，curParent还要继续下移
            index = child;
            child = child * 2 +1;
        } else {
            break;
        }
    }
    a[index] = curParent;
}

/*
void buildHeap(int a[], int i, int len){
    int parent = a[i];
    int left = i*2+1;
    while(child < len){
        if(child+1<len && a[child]<a[child+1]){
            child++;
        }
        if(parent<a[child]){
            a[i] = child;
            child = 2*i+1;
        } else {
            break;
        }
    }
    a[p] = parent;
}*/


//堆排序
void heapSort(int a[], int num){
    int i;
    for(i=num/2-1;i>=0;i--){
        buildHeap(a, i, num);
    }
    for(i=num-1;i>=0;i--){
        int max = a[0];
        a[0] = a[i];
        a[i] = max;
        buildHeap(a,0,i);
    }

}
//插入排序
void insertSort(int a[], int num){
    int i,j,tmp;
    for(i=1;i<num;i++){
        tmp = a[i];
        for(j=i-1;j>=0;j--){
            if(a[j]>tmp){
                a[j+1] = a[j];
            } else {
                break;
            }
        }
        a[j+1] = tmp;
    }
}

void merge(int a[], int first, int mid, int last){
    int *tmp = (int *)malloc((last-first+1)*sizeof(int));
    int i = first;
    int j = mid+1;
    int k = 0;
    while(i<=mid && j<=last){
        if(a[i]<=a[j]){
            tmp[k++] = a[i++];
        } else {
            tmp[k++] = a[j++];
        }
    }
    while(i<=mid){
        tmp[k++] = a[i++];
    }
    while(j<=last){
        tmp[k++] = a[j++];
    }
    for(i=first;i<=last;i++){
        a[i] = tmp[i-first];
    }
    free(tmp);
}

void mergeSort(int a[], int first, int last){
    int mid = (first+last)/2;
    if(first<last){
        mergeSort(a,first,mid);
        mergeSort(a,mid+1,last);
        merge(a,first,mid,last);
    }
}

int main(){
    int num;
    while(cin>>num){
        int i;
        start = clock();
        int *arr = new int[num];
        for(int i=0; i<num; i++){
            arr[i] = rand()%1000;
            //cin>>arr[i];
        }
        cout<<"待排序数组为:"<<endl;
        output(arr,num);

        //quickSort(arr,0,num-1,num);            //快速排序
        //bubbleSort(arr,num);                    //冒泡排序
        //selectSort(arr,num);                    //归并排序
        //insertSort(arr,num);                    //插入排序
        //heapSort(arr,num);                    //堆排序
        //mergeSort(arr,0,num-1);                //归并排序
        stop = clock();
        cout<<stop-start<<endl;

        cout<<"排序后的数组为:"<<endl;
        output(arr,num);

    }
    return 0;
}