排序算法代码实现

直接插入排序

template<class T>
void InsertSort(T* array, int n) {               //array待排序数组,n:数组元素数量
    int i, j;                                    //循环变量
    T temp;                                      //存储待排序元素
    for (i = 1; i < n; i++) {
        j = i;
        temp = array[i];                         //待排序元素赋值给临时变量
        while (j > 0 && temp < array[j - 1]) {   //当未达到数组的第一个元素或者待插入元素小于当前元素
            array[j] = array[j - 1];             //就将该元素后移
            j--;                                 //下标减一，继续比较
        }
        array[j] = temp;                         //插入位置已经找到，立即插入
    } 
}

冒泡排序

#include <stdio.h>
//交换 a 和 b 的位置的函数
void swap(int *a, int *b);
int main()
{
    int array[8] = {49,38,65,97,76,13,27,49};
    int i, j;
    int key;
    //有多少记录，就需要多少次冒泡，当比较过程，所有记录都按照升序排列时，排序结束
    for (i = 0; i < 8; i++){
        key=0;//每次开始冒泡前，初始化 key 值为 0
        //每次起泡从下标为 0 开始，到 8-i 结束
        for (j = 0; j+1<8-i; j++){
            if (array[j] > array[j+1]){
                key=1;
                swap(&array[j], &array[j+1]);
            }
        }
        //如果 key 值为 0，表明表中记录排序完成
        if (key==0) {
            break;
        }
    }
    for (i = 0; i < 8; i++){
        printf("%d ", array[i]);
    }
    return 0;
}
void swap(int *a, int *b){
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

简单选择排序

void selection_sort(int array[], int length)
{
    int i, j, m;
    int temp;    // 用于存放临时待排序的元素值
 
    for(i = 0; i < length -1; i++)
    {
        m = i;
        for(j = i + 1; j < length; j++)
        {
            if(array[j] < array[m])
                m = j;
        }
        if(m != i)
        {
            temp = array[i];
            array[i] = array[m];
            array[m] = temp;
        }
    }
}

希尔排序

/*
*希尔排序
数组，长度
*/
void shell_sort(int *arr,int length)
{
    int temp;
    int j;
    for(int d = (length/3) + 1;d >= 1;d =d/2)
    {
        for(int i = d;i < length; ++i)
        {
            temp=arr[i];
            for(j = i-d; j >= 0 && temp < arr[j]; j = j-d)
            {
                arr[j+d]= arr[j];
            }
            arr[j+d] = temp;
        }
 
    }
 
}

快速排序

int Partion(int *arr,int low,int high)       //一次找基准过程
{
    int temp = arr[low];
    while(low < high)        //当low = high时退出循环,此时的位置为基准位置
    {
       while(low < high && arr[high] > temp)
       {
         high--;                              
       }
       if(low >= high)
       { 
           break;
       }
       else
       {
           arr[low] = arr[high];
       }
       while(low < high && arr[low] < temp)
       {
         low++;
       }
       if(low >= high)
       { 
           break;
       }
       else
       {
           arr[high] = arr[low];
       }
   }
   arr[low] = temp;
   return low;
}

堆排序

typedef int ElementType;
int arr1[11]={0,2,87,39,49,34,62,53,6,44,98};
#define LeftChild(i) (2 * (i) + 1)

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

void PercDown(int  A[], int i, int N)
{
    int child;
    ElementType Tmp;

    for (Tmp = A[i]; 2*i+1 < N; i = child){
        child = 2*i+1; //注意数组下标是从0开始的，所以左孩子的求发不是2*i
        if (child != N - 1 && A[child + 1] > A[child])
            ++child;                //找到最大的儿子节点
        if (Tmp < A[child])
            A[i] = A[child];
        else
            break;
    }
    A[i] = Tmp;
}

void HeapSort(int A[], int N)
{
    int i;
    for (i = N / 2; i >= 0; --i)
        PercDown(A, i, N);    //构造堆
    for(i=N-1;i>0;--i)
    {
        Swap(&A[0],&A[i]);        //将最大元素（根）与数组末尾元素交换，从而删除最大元素，重新构造堆
        PercDown(A, 0, i);
    }
}

归并排序

//分组归并
void _Merge(int *a, int begin1, int end1, int begin2, int end2, int *tmp)
{
    int index = begin1;
    int i = begin1, j = begin2;
    //注意:当划分的区间足够小时,begin1==end1,begin2==end2
    while (i <= end1&&j <= end2){
        if (a[i]<=a[j])
            tmp[index++] = a[i++];
        else
            tmp[index++] = a[j++];
    }
    //将左边元素填充到tmp中
    while (i <= end1)
        tmp[index++] = a[i++];
    //将右边元素填充的tmp中
    while (j <= end2)
        tmp[index++] = a[j++];
    //将tmp中的数据拷贝到原数组对应的序列区间
    //注意:end2-begin1+1
    memcpy(a + begin1, tmp + begin1, sizeof(int)*(end2 - begin1 + 1));
}
//归并排序
void MergeSort(int *a, int left, int right, int *tmp)
{
    if (left >= right)
        return;
    assert(a);
    //mid将数组二分
    int mid = left + ((right - left) >> 1);
    //左边归并排序,使得左子序列有序
    MergeSort(a, left, mid, tmp);
    //右边归并排序,使得右子序列有序
    MergeSort(a, mid + 1, right, tmp);
    //将两个有序子数组合并
    _Merge(a, left, mid, mid + 1, right, tmp);
}
时间空间复杂度图