面试排序算法总结

直接插入排序

从第二个元素开始，每次选择一个元素插入到之前已经排好序的部分。
选择插入位置的时候从后往前，将带插入元素取出，依次后移大于带插入元素的数。
算法复杂度：
最好是正序有序，需要n次比较。
最差逆序有序，复杂度$O(n^2)$
平均复杂度$O(n^2)$
插入排序是稳定的

void insertsort(int a[],int size){
    int tmp;
    for(int i = 1; i < size; ++i){
        tmp = a[i];
        int j = i-1;
        while(j>=0&&a[j]>a[i]){
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = tmp; //最后j位置数小于带插入的数，在j+1位置插入数
    }
}

希尔排序

实际也是一组插入排序，只不过是分组插入排序。给定增量值d,将序列分为d个子序列，先插入排序子序列，最后对全部序列进行 一次插入排序。
也就是增量值必须取小于n的值，且最后一个增量必须为1。
由于大于1的增量，排序是不稳定的。
平均复杂度：$O(nlogn)$

void shellsort(int a[],int size){
    int d,i,j;
    int tmp; //暂存数据
    d = n/2;
    while(d>0){
        for(i = d; i < size; ++i){
            j = i-d;
            tmp = a[i];
            while(j>=0 && a[j] > tmp){
                a[j+d] = a[j];
                j -= d;
            }
            a[j+d] = tmp;
        }
        d /= 2;
    }
}

快速排序

对冒泡排序的一种改进，基于交换
算法复杂度在最坏情况下为$O(n^2)$,平均为$O(nlogn)$
同时快排是不稳定的

void quicsort(int a[],int low,int high){
    if(low>=high) return;
    int i = low, j = high;
    int tmp = a[i];
    while(i<j){
        while(i<j && a[j] > tmp) j--;
        if(i<j) a[i++] = a[j];
        while(i<j && a[i] < tmp) i++;
        if(i<j) a[j--] = a[i];
    }
    a[i] = tmp;
    quicksort(a,low,i-1);
    quicksort(a,i+1,high);
}

选择排序

排序不稳定

void selectsort(int a[],int size){
    int tmp,k;
    for(int i = 0; i < size-1; ++i){
        tmp = a[i];
        k = i;
        for(int j = i+1; j < size; ++j){
            if(a[j] < tmp){
                tmp = a[j];
                k = j;
            }
        }
        if(k != i) swap(a[i],a[k]);
    }
}

堆排序

1. 在数组中建堆
2. 从最后一个非叶节点进行调整
3. 将堆顶元素与最后的元素交换，然后调整堆。
   复杂度为：$O(nlogn)$

void heapAdjust(int a[],int i,int size){
    int tmpMin = a[i];
    for(int j = i*2+1; j < size; j = j*2+1){
        if(j<size-1&&a[j+1]<a[j]) j += 1;
        if(a[i] < a[j]) break;
        a[i] = a[j];
        i = j;
    }
}

void buildHeap(int a[],int size){
    for(int i = size/2+1; i >= 0; --i){
        heapAdjust(a,i,size);
    }
}
void heapsort(int a[],int size){
    buildHeap(a,size);
    for(int i = size-1; i > 0; --i){
        swap(a[0],a[i]);
        heapAdjust(a,0,i);
    }
}

归并排序

归并排序是稳定排序，复杂度为$O(nlogn)$,缺点是需要额外的$O(n)$空间

void merge(int a[], int tmp[],int left,int mid, int right) {
    int i = left, j = mid+1;
    int k = i;
    while (i <= mid && j <= right) {
        if (a[i] < a[j]) {
            tmp[k++] = a[i++];
        }
        else {
            tmp[k++] = a[j++];
        }
    }
    while (i <= mid) tmp[k++] = a[i++];
    while (j <= right) tmp[k++] = a[j++];
    for (int p = left; p <= right; p++) {
        a[p] = tmp[p];
    }
}
void m_sort(int a[],int tmp[],int left,int right) {
    if (left == right) return;
    int mid = (left + right) / 2;
    m_sort(a, tmp,left, mid);
    m_sort(a,tmp, mid + 1, right);
    merge(a, tmp,left, mid,right);
}
void mergesort(int a[], int size) {
    int *tmp = new int[size];
    m_sort(a, tmp, 0, size - 1);
    delete[]tmp;
}