内部排序算法

直接插入排序

void insert_sort(int a[], int n)
{
    int i;
    for(i = 2; i <= n; i++)
    {
        a[0] = a[i];
        for(j = i-1; a[0] < a[j]; j--)
        {
            a[j+1] = a[j];
        }
        a[j+1] = a[0];
    }
}

时间复杂度：O(n)~O(n2)
空间复杂度：O(1)

折半插入排序

void insert_sort1(int a[], int n)
{
    int i;
    for(i = 2; i <= n; i++)
    {
        a[0] = a[i];
        int low = 1, high = i-1;
        int mid = (low + high) / 2;
        while(low <= high)         //退出循环时，low在high的右边一个
        {
            mid = (low + high) / 2;
            if(a[0] >= a[mid])     //这里保证算法的稳定性，即使两个数值相等，也要继续往后找，插在原来数的后面
            {
                low = mid + 1;
            }
            else high = mid - 1;
        }
        int j;
        for(j = i-1; j >= low; j--)    //这时候[low,i-1]都是比a[0]大的，右移之后插在low的位置
        {
            a[j+1] = a[j];
        }
        a[low] = a[0];    //a[high+1]=a[0];
    }
}

希尔排序

void shell_sort(int a[], int n)
{
    int i, d;
    for(d = n/2; d >= 1; d = d/2)
    {
        for(i = 1; i+d<=n; i++)   //i+d<=n,这个一次循环是处理属于一个步长里面的,注意这里的i的变化，是加一
        {
            for(int j = i+d; j <= n; j += d)    //对于每一个元素进行插入排序
            {
                a[0] = a[j];
                int k;
                for(k = j-d; k>0&&a[0]<a[k]; k -= d)
                {
                    a[k+d] = a[k];
                }
                a[k+d] = a[0];
            }
        }
    }
    for(i = 1; i <= n; i++)
    {
        cout << a[i] << " ";
    }
}


void shell_sort1(int a[], int n)  //这个区别于上面的，并不是将处于当前d分区里的所有元素同时处理，是一个一个往后移
{
    int i, d;
    for(d = n/2; d >= 1; d = d/2)
    {
        for(i = d+1; i <= n; i++)   //没错就是这里，一个一个往后移
        {
            if(a[i] > a[i-d])
            {
                a[0] = a[i];
                for(int j = i-d; a[0] < a[j]&&j > 0; j -= d)
                {
                    a[j+d] = a[j];
                }
                a[j+d] = a[0];
            }
        }
    }
}

时间复杂度：如果每个排序算法都想希尔一样懂事就好了
空间复杂度：O(1)

冒泡排序

void bubble_sort(int a[], int n)
{
    int i;
    for(i = 0; i < n-1; i++)    //注意这里i的最大值是n-2,最后一个元素不用再冒了
    {
        int flag = 1;       //如果冒泡一趟之后flag还是1，说明现在的元素已经有序了，可以退出了
        for(j = n-1; j > i; j--)
        {
            if(a[j-1] > a[j])
            {
                Swap(a[j-1], a[j]);
                flag = 0;
            }
        }
        if(flag) break;
    }
}

时间复杂度：O(n)~O(n2)
空间复杂度：O(1)

快排：

void quick_sort(int a[], int n, int left, int right)
{
    int i = left, j = right;
    if(i >= j) return;
    int k = a[i];
    while(i < j)
    {
        while(a[j] >= k && i < j) j--;
        a[i] = a[j];
        while(a[i] <= k && i < j) i++;
        a[j] = a[i];
    }
    a[i] = k;
    quick_sort(a, n, left, i-1);
    quick_sort(a, n, i, right);
}

时间复杂度：O(n2) ~ O(nlog2n)
空间复杂度：O(log2n)

选择排序

void select_sort(int a[], int n)    //选择排序，从头到尾遍历一遍，每次遍历找到最小的交换到最头的位置
{
    int i;
    for(i = 0; i < n; i++)
    {
        int minn = i;
        for(int j = i+1; j < n; j++)
        {
            if(a[j] < a[minn])
            {
                minn = j;
            }
        }
        if(minn != j) Swap(a[minn], a[j]);
    }
}

时间复杂度：O(n2)
空间复杂度：O(1)

堆排序

void head_adjust(int a[], int k, int n)
{
    a[0] = a[k];
    for(i = k*2; i <= n; i = i*2)
    {
        if(i < n && a[i+1] < a[i]) i++;
        if(a[0] >= a[i]) break;
        else
        {
            a[k] = a[i];
            k = i;
        }
    }
    a[k] = a[0]
}
void buildmax_heap(int a[], int n)
{
    for(int i = n/2; i >= 1; i--)
    {
        head_adjust(a, i, n);
    }
}
void heap_sort(int a[], int n)
{
    buildmax_heap(a, n);
    for(int i = n; i >= 1; i--)
    {
        Swap(a[1], a[i]);
        head_adjust(a, 1, i-1);
    }
}

时间复杂度：O(nlog2n)
空间复杂度：O(n)