各种排序的比较

//讲一下稳定和不稳定的区别，稳定的排序算法是指，在相邻两个元素相同时，排序不用改变其位置，

//不稳定的排序算法是指，在相邻两个元素相同时，排序改变其位置。

#include<iostream>

using namespace std;

int low,high,mid;

typedef int ElemType ;

int i,j;

void Put(int a[],int n);

void Direct_insertion_sort(int a[],int n) {       //直接插入排序//平均时间复杂度O(n*n)

    int i,j;

    for(i=1;i<n;i++)//循环从第2个元素开始

    {

        if(a[i]<a[i-1])

        {

            int temp=a[i];

            for(j=i-1;j>=0 && a[j]>temp;j--)

            {

                a[j+1]=a[j];

            }

            a[j+1]=temp;//此处就是a[j+1]=temp;

        }

    }

}

void Binary_Insertion_Sort(int a[],int n) {       //折半插入排序//时间复杂度O(n*log2(n))

    int temp;

    for(i=1;i<n;i++) {

        temp=a[i];

        low=0;

        high=i-1;

        while(low<=high) {

            mid=(low+high)/2;

            if(temp<a[mid])

                high=mid-1;

            else

                low=mid+1;

        }

        for(j=i;j>=low+1;j--) {

            a[j]=a[j-1];

        }

        a[low]=temp;

    }

}

void Shell_Insert(int a[],int n) {     //希尔排序

    if(n<=1)

        return ;

    for(int div=n/2;div>=1;div=div/2) {

        for(int i=0;i<=div;i++) {

            for(int j=i;j<n-div;j+=div) {

                for(int k=j;k<n;k+=div) {

                    //cout<<i<<" "<<j<<" "<<k<<endl;

                    if(a[j]>a[k])

                        swap(a[j],a[k]);

                }

            }

        }

    }

}

void Qsort(int a[],int low,int high) {     //快速排序     //平均时间复杂度O(log2(n))

    if(low>=high)

        return ;

    int left=low;

    int right=high;

    int key=a[left];

    while(left<right) {

        while(left<right&&a[right]>=key)

            right--;

        a[left]=a[right];

        while(left<right&&a[left]<=key)

            left++;

        a[right]=a[left];

    }

    a[left]=key;

    Qsort(a,low,left-1);

    Qsort(a,left+1,high);

}

void heapsort(int a[],int n) {              //堆排序

    int i, j, root_index;

    for (i = n; i >= 0; i--) {

        //从最后一个元素开始向堆的上层查找

        for (j = i - 1; j > 0; j--) {

            if (j % 2 == 0) {

                //右子节点的根节点

                root_index = (j - 2) / 2;

            } else {

                //左子节点的根节点

                root_index = (j - 1) / 2;

            }

            //将大值向前移动

            if (a[root_index] < a[j]) {

                swap(a[root_index], a[j]);

            }

            cout<<j<<" ";

        //Put(a,n);

        }

        //将最大值向后移动

        swap(a[j], a[i - 1]);

    }

}

void Select_sort(int a[],int n) {       //选择排序  //每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完

    int temp;

    int b;

    for(i=0;i<n-1;i++)

    {

        temp=i;

        for(j=i+1;j<n;j++)

        {

            if(a[temp]>a[j])

                temp=j;

        }

        if(i!=temp)

        {

            b=a[temp];

            a[temp]=a[i];

            a[i]=b;}

    }

}

void bubble_sort(int arr[], int len)        //冒泡排序

{

    int i, j;

    int temp;

    for (i = 0; i < len - 1; i++)

        for (j = 0; j < len - 1 - i; j++)

            if (arr[j] > arr[j + 1])

            {

                temp = arr[j];

                arr[j] = arr[j + 1];

                arr[j + 1] = temp;

            }

}

int result[30];

void merge(int *data, int start, int mid, int end)

{

    int i, j, k;

    i = start;

    j = mid + 1;                        //避免重复比较data[mid]

    k = 0;

    while (i <= mid && j <= end) {

        if (data[i] <= data[j])         //如果data[i]小于等于data[j]

            result[k++] = data[i++];

        else

            result[k++] = data[j++];

    }

    while (i <= mid)

        result[k++] = data[i++];

    while (j <= end)

        result[k++] = data[j++];

    for (i = 0; i < k; i++)             //将归并后的数组的值逐一赋给数组data[start,end]

        data[start + i] = result[i];    //注意，应从data[start+i]开始赋值

}

void merge_sort(int *data, int start, int end)    //归并排序     时间复杂度O(nlogn)

{

    if (start < end)

    {

        int mid = (start + end) / 2;

        merge_sort(data, start, mid);                    //对左边进行排序

        merge_sort(data, mid + 1, end);                  //对右边进行排序

        merge(data, start, mid, end);                    //把排序好的数据合并

    }

}

void Put(int a[],int n) {

    for(int f=0;f<n;f++)

    {

        cout<<a[f]<<"  ";

    }

    cout<<endl;

}

int main()

{

    int a[]={98,76,109,34,67,190,80,12,14,89,1};

    int k=sizeof(a)/sizeof(a[0]);

    //Direct_insertion_sort(a,k);      //直接插入排序

    //Binary_Insertion_Sort(a,k);      //折半插入排序

    //Shell_Insert(a,k);               //希尔排序

    //Qsort(a,0,k-1);                  //快速排序

    //heapsort(a,k);                   //堆排序

    //Select_sort(a,k);                //选择排序

    //bubble_sort(a, k);               //冒泡排序

    merge_sort(a, 0, k-1);           //归并排序

    Put(a,k);

    return 0;

}