一些排序算法分享

考研学习中～

学完排序自己写了一遍总结了一遍哈哈哈，分享出来供大家参考学习。

直接插入排序：

时间复杂度是：最好：n；一般：n平方；最坏：n平方

空间复杂度：1

稳定性：稳定

思路：从第二个元素开始，每一个首先与前一个比较，如果小于前一个元素，则再与前一个的前一个元素比较。。。一直找到合适的位置，然后插入此元素。

void InsertSort(int list[],int n)//直接插入排序
//（因为要与其他排序方法共用同一个被排列的数组，所以这个不用哨兵）
{
    static int i,j;
    int temp;
    for(i = 1;i < n;i++){
        if(list[i]<list[i-1]){
            temp = list[i];
            for(j = i-1;temp<list[j];j--){
                list[j+1] = list[j];
            }
            list[j+1] = temp;
        }
    }
}

折半插入排序：

时间复杂度：

空间复杂度：

稳定性：

void HalfInsertSort(int list[],int n)//折半插入排序
{
    int i,j,low,high,mid;
    int temp;
    for(i = 1;i<n;i++){
        if(list[i]<list[i-1]){
            temp = list[i];
            low = 0;high = i-1;
            while(low <= high){
                mid = (low+high)/2;
                if(list[mid] > temp){
                    high = mid - 1;
                }else{
                    low = mid + 1;
                }
            }
            for(j = i-1;j>high;j--){
                list[j+1] = list[j];
            }
            list[high+1] = temp;
        }
    }
}

简单选择排序：

很简单的原理，复杂度比较高。

void SelectSort(int list[],int n)//简单选择排序
{
    int i,j;
    int min;
    i = j = min = 0;
    for(i = 0;i < n-1;i++){
        min = i;
        for(j = i;j<n;j++){
            if(list[min] > list[j]){
                min = j;
            }
        }
        swap(&list[i],&list[min]);
    }
}

快速排序：
这是递归的写法，Partition函数有很多种写法，意思都差不多的。

void FastSort(int list[],int low,int high)//快速排序
{
    int pivotpos;
    if(low<high){
        pivotpos = Partition2(list,low,high);
        //pivotpos = Partition(list,low,high);
        //pivotpos = PartitionRandom(list,low,high);
        FastSort(list,low,pivotpos-1);
        FastSort(list,pivotpos+1,high);
    }
}

快速排序的Partition：

三种写法。

int Partition(int list[],int low,int high)
{
    int pivot;
    pivot = list[low];
    while(high>low){
        while(list[high] > pivot && low < high){
            high--;
        }
        list[low] = list[high];
        while (list[low] < pivot && low <high){
            low++;
        }
        list[high] = list[low];
    }
    list[low] = pivot;
    return low;
}

int Partition2(int list[],int low,int high)
{
    int pivot;
    int i,j;
    pivot = list[low];
    j = low;
    for(i = low+1;i<=high;i++){
        if(list[i]<pivot){
            swap(&list[++j],&list[i]);
        }
    }
    swap(&list[low],&list[j]);
    return j;
}

int PartitionRandom(int list[],int low,int high)//每次随即选取pivot
{
    int pivot;
    int random;
    random = low + rand()%(high - low);
    swap(&list[low],&list[random]);
    pivot = list[low];
    while(high>low){
        while(list[high] > pivot && low < high){
            high--;
        }
        list[low] = list[high];
        while (list[low] < pivot && low <high){
            low++;
        }
        list[high] = list[low];
    }
    list[low] = pivot;
    return low;
}

冒泡排序：

两两比较，原理也很简单。还有一种双冒泡排序。

void BubbleSort(int list[],int n)//冒泡排序
{
    static int i,j;static int temp;bool flag;
    flag = true;
    for(i = 1;flag && i<n-1;i++){
        flag = false;
        for(j = 0;j<n-i;j++){
            if(list[j]>list[j+1]){
                flag = true;
                swap(&list[j],&list[j+1]);
            }
        }
    }
}

void DoubleBubbleSort(int list[],int n)//双冒泡排序
{
    static int i,j,high,low;static int temp;bool flag;
    high = n-1;low = 0;flag = true;
    while(high>low&&flag){
        for(i = low;i<high;i++){
            if(list[i]>list[i+1]){
                flag = true;
                swap(&list[i],&list[i+1]);
            }
        }
        high--;
        for(j = high;j>low;j--){
            if(list[j]<list[j-1]){
                flag = true;
                swap(&list[j],&list[j-1]);
            }
        }
        low++;
    }
}

俺全部的代码见github：

GitHub - heiyt/datastructSort