七种排序算法代码+总结（复试）

排序！

捋一遍最近学的排序算法

1.冒泡排序
最好时间复杂度：o（n）
平均时间复杂度: o（n^2）
最坏平均复杂度： o（n^2）
稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

int main()
{
    int n;
    int arr[MAX];
    while(scanf("%d", &n) != EOF)
    {
        memset(arr, 0, sizeof(arr));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < n - i; j++)
            {
                //因为数组长度没确定不做这个判断会出错
                //可能有更好的方法
                if(j + 1 <= n - 1)
                {
                    if(arr[j] > arr[j + 1])
                    {
                        int t;
                        t = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = t;
                    }
                }

            }
        }
        for(int i = 0; i < n; i++)
        {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }

    return 0;
}

2.直接插入排序
最好时间复杂度：o（n）
平均时间复杂度: o（n^2）
最坏平均复杂度： o（n^2）
稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

void InSort(int a[], int n)
{
    int t, j;
    for(int i = 0; i < n; i++)
    {
        t = a[i];//哨兵
        j = i - 1;
        while(t < a[j] && j >= 0)
        {
            a[j + 1] = a[j];
            j--;
        }
        a[j + 1] = t;
    }
}
int main()
{
    int n;
    int arr[MAX];
    while(scanf("%d", &n) != EOF)
    {
        memset(arr, 0, sizeof(arr));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        InSort(arr, n);
        for(int i = 0; i < n; i++)
        {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }

    return 0;
}

3.快速排序
最好时间复杂度：o（nlogn）
平均时间复杂度: o（nlogn）
最坏平均复杂度： o（n^2）
不稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

void QuickSort(int a[], int left, int right)
{
    int i = left;
    int j = right;
    int t = a[i];
    while(i < j)
    {
        while(a[j] > t)
        {
            j--;
        }
        while(a[i] < t)
        {
            i++;
        }
        int temp;
        temp = a[j];
        a[j] = a[i];
        a[i] = temp;
        if(i == j)
        {
            break;
        }
    }
    if(left < i)
    {
        QuickSort(a, left, i - 1);
    }
   if(i < right)
    {
        QuickSort(a, i + 1, right);
    }
}

int main()
{
    int n;
    int arr[MAX];
    while(scanf("%d", &n) != EOF)
    {
        memset(arr, 0, sizeof(arr));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        QuickSort(arr, 0, n - 1);
        for(int i = 0; i < n; i++)
        {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }

    return 0;
}

4.希尔排序
不稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

void ShellSort(int a[], int n)
{
    int d = n / 2;
    while(d >= 1)
    {

        for(int i = d; i < n; i++)
        {
            int j = i - d;
            while(a[j] > a[j + d] && j >= 0)
            {
                int temp;
                temp = a[j];
                a[j] = a[j + d];
                a[j + d] = temp;
                j = j - d;
            }
        }
        d /= 2;
    }
}

int main()
{
    int n;
    int arr[MAX];
    while(scanf("%d", &n) != EOF)
    {
        memset(arr, 0, sizeof(arr));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        ShellSort(arr, n);
        for(int i = 0; i < n; i++)
        {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }

    return 0;
}

5.归并排序
最好时间复杂度：o（nlogn）
平均时间复杂度: o（nlogn）
最坏平均复杂度： o（nlogn）
稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

int arr[100];
int temp[100];
int merge(int left, int mid, int right)
{
    int i = left;
    int j = mid + 1;
    int k = left;
    while(i <= mid && j <= right)
    {
        if(arr[i] <= arr[j])
        {
            temp[k++] = arr[i++];
        }
        else
        {
            temp[k++] = arr[j++];
        }
    }
    while(i <= mid)
    {
        temp[k++] = arr[i++];
    }
    while(j <= right)
    {
        temp[k++] = arr[j++];
    }
    for(int i = left; i <= right; i++)
    {
        arr[i] = temp[i];
    }
    return 0;
}
int merge_sort(int left, int right)
{
    int mid;
    if(left < right)
    {
        mid = (left + right) / 2;
        merge_sort(left, mid);
        merge_sort(mid + 1, right);
        merge(left, mid, right);
    }
    return 0;
}

int main()
{
    int n;
    while(scanf("%d", &n) != EOF)
    {
        memset(arr, 0, sizeof(arr));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        merge_sort( 0, n - 1);
        for(int i = 0; i < n; i++)
        {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }

    return 0;
}

6.选择排序
最好时间复杂度：o（n^2）
平均时间复杂度: o（n^2）
最坏平均复杂度： o（n^2）
不稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

int main()
{
    int n;
    int arr[MAX];
    while(scanf("%d", &n) != EOF)
    {
        memset(arr, 0, sizeof(arr));
        for(int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }

        for(int i = 0; i < n; i++)
        {
            for(int j = i + 1; j < n; j++)
            {
                if(arr[i] > arr[j])
                {
                    int t;
                    t = arr[i];
                    arr[i] = arr[j];
                    arr[j] = t;
                }

            }
        }
        for(int i = 0; i < n; i++)
        {
            printf("%d ", arr[i]);
        }
        printf("\n");
    }

    return 0;
}

7.堆排序
最好时间复杂度：o（nlogn）
平均时间复杂度: o（nlogn）
最坏平均复杂度： o（nlogn）
不稳定

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1010

int h[MAX], n;

//交换函数
void swap(int a,int b)
{
    int t;
    t = h[a];
    h[a] = h[b];
    h[b] = t;
}

//向下调整
void siftdown(int i)
{
    int t, flag = 0;
    //如果有左孩子
    while(2 * i <= n && flag == 0)
    {
        if(h[2 * i] < h[i])
        {
            t = 2 * i;
        }
        else
        {
            t = i;
        }
        //如果有右孩子
        if(h[2 * i + 1] < h[t] && (2 * i + 1) <= n)
        {
            t = 2 * i + 1;
        }
        if(t != i)
        {
            swap(t, i);
            i = t;
        }
        else
        {
            flag = 1;
        }
    }
}

//堆排序
int heapsort()
{
    int t;
    t = h[1];
    h[1] = h[n];
    n--;
    siftdown(1);
    return t;
}

//创建堆
void creat()
{
    for(int i = n / 2; i >= 1; i--)
    {
        siftdown(i);
    }
}

int main()
{
    int num;
    scanf("%d", &num);
    n = num;
    for(int i = 1; i <= num; i++)
    {
        scanf("%d", &h[i]);
    }
    creat();

    for(int i = 1; i <= num; i++)
    {
        printf("%d ", heapsort());
    }
    return 0;
}