常见的排序算法

近来由于手上有两个项目要写，没有时间构思和写博客= =。

现在属于校招季，计算机原理，算法和数据结构，c语言基础属于最重要的。这里把常考到的常用排序算法简单汇总了下。

包括冒泡排序，简单选择排序，直接插入排序，希尔排序，堆排序和快速排序。

//常用排序汇总

#include <stdio.h>

void swap(int *a, int *b);
void bubble_sort(int a[], int n);
void select_sort(int a[], int n);
void insert_sort(int a[], int n);
void shell_sort(int a[], int n);
void heap_adjust(int a[], int i, int n);
void heap_sort(int a[], int n);
void quick_sort(int a[], int low, int high);

int main()
{
    int arr[] = {0,2,3,1,6,9,8,7,4,5};
    
//    bubble_sort(arr, 10);
//    select_sort(arr, 10);
//    insert_sort(arr, 10);
//    shell_sort(arr, 10);
//    heap_sort(arr, 10);
    quick_sort(arr, 0, 9);
    
    for (int i = 0; i < 10; i++)
    {
        printf("%d\n", arr[i]);
    }
    
    return 0;
}

//交换数据
void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

//冒泡排序法
//时间复杂度O(n^2) 空间复杂度O(1)
void bubble_sort(int a[], int n)
{
    int i, j;
    //旗帜位，判断这次遍历是否有交换
    int flag = 1;
    
    for (i = 0; i < n && flag; i++)
    {
        flag = 0;
        for (j = n-2 ; j >= i; j--)
        {
            if (a[j] > a[j+1])
            {
                swap(&a[j], &a[j+1]);
                flag = 1;
            }
        }
    }
}

//简单选择排序
//时间复杂度O(n^2) 空间复杂度O(1)
void select_sort(int a[], int n)
{
    int i, j, min;
    
    for (i = 0; i < n ; i++)
    {
        min = i;
        for (j = i+1; j < n; j++)
        {
            if (a[j] < a[min])
            {
                min = j;
            }
        }
        if (min != i)
        {
            swap(&a[min], &a[i]);
        }
    }
}

//直接插入排序
//时间复杂度O(n^2) 空间复杂度O(1)
void insert_sort(int a[], int n)
{
    for (int i = 0; i < n ; i++)
    {
        int temp = a[i];
        int j = i-1;
        while (j>=0 && a[j] > temp)
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = temp;
    }
}

//希尔排序
//时间复杂度为O(nlogn) 空间复杂度为O(1)
void shell_sort(int a[], int n)
{
    int i,j,temp;
    int gap = 0;
    while (gap <= n) gap = gap*3+1;
    while (gap > 0)
    {
        for (i = gap; i < n; i++)
        {
            temp = a[i];
            j = i - gap;
            while (j >= 0 && a[j] > temp)
            {
                a[j+gap] = a[j];
                j = j - gap;
            }
            a[j+gap] = temp;
        }
        gap = (gap-1)/3;
    }
}

//堆排序
//时间复杂度为O(nlogn) 空间复杂度为O(1)
void heap_sort(int a[], int n)
{
    for (int i = n/2 - 1; i >= 0; i--)
    {
        heap_adjust(a, i, n);
    }
    for (int i = n-1; i > 0; i--)
    {
        swap(&a[0], &a[i]);
        
        heap_adjust(a, 0, i);
    }
}

//构建大顶堆
void heap_adjust(int a[], int i, int n)
{
    int child, temp;
    
    for (temp = a[i]; 2*i+1 < n; i = child)
    {
        child = 2*i+1;
        //取得较大子结点索引
        if (child < n -1 && a[child] < a[child+1]) child++;
        //保证父结点大于等于子结点
        if (temp < a[child]) swap(&a[i], &a[child]);
        else break;
    }
}

//快速排序
//时间复杂度为O(nlogn) 空间复杂度为O(logn) ~ O(n)
void quick_sort(int a[], int low, int high)
{
    int i = low+1;
    int j = high;
    int key = a[low];
    
    if (low >= high) return;
    
    while (1) {
        while (key<a[j]) j--;
        while (key>a[i] && i<j) i++;
        if (i >= j) break;
        
        swap(&a[i], &a[j]);
        
        if (a[i] == key) j--;
        else i++;
    }
    
    swap(&a[low], &a[j]);
    
    if (i-1>low) quick_sort(a, low, i-1);
    if (j+1<high) quick_sort(a, j+1, high);
}

刚看到优快云也有oc的代码模板了:)以后估计方便了不少。