iOS開發-一些面試算法總結

由於最近需要面試,筆試的時候遇到了不同的算法,上網搜了一些

這裏把常考到的常用排序算法簡單彙總了下。

包括冒泡排序，簡單選擇排序，直接插入排序，希爾排序，堆排序和快速排序。

//常用排序彙總

#include <stdio.h>

void swap(intint *a, intint *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(intint *a, intint *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);
}