排序（课堂笔记）

Selection Sort

void selectSort(int a[],int N)
{
    for(int i=0;i<N;i++)
    {
        int min_idx=i;
        for(int j=i+1;j<N;j++){
            if(a[j]<a[min_idx])
                min_idx=j;
        }
        exch(a,i,min_idx);    
    }
}

时间复杂度 O(N^2)

---

Insertion Sort

void insertionSort(int A[]){
    for(int i=1;i<A.length;i++){
        int x=A[i];
        int j;
        for(j=i-1;j>=0 && A[j]>x;j--){
            A[j+1]=A[j];
        }
        A[j+1]=x;
    }
}

时间复杂度：

最好：O(N) sorted data

最坏：O(N^2)

平均：O(N^2)

---

Quick Sort

void QuickSort(int A[], int left, int right){
    int pivot_idx;
    if(left<right){
        pivot_idx=partition(A, left, right);
        QuickSort(A, left, pivot_idx-1);
        QuickSort(A, pivot_idx+1, right);
    }
}

int partition(int A[], int left, int right){
    int pivot_idx=right;
    int X= A[pivot_idx];
    int i=left;
    int j=right-1;
    do{
        while(A[i]<x)
            i++;
        while(A[j]>=x && j>left)
            j--;
        if(i<j)
            exch(A, i, j);
    }while(i<j);
    exch(A, pivot_idx, i);
    return i;
}

时间复杂度：

最坏：O(N^2)

平均：O(N*logN)

---

Merge Sort

if(L.length==1){
    the list is sorted;
}
else{
    Merge Sort the left side(1 to k/2);
    Merge Sort the right side(k/2+1 to k);
    Merge the right side with the left side;
}

时间复杂度：

最坏：O(NlogN)

平均：O(NlogN)

---

Tree Sort

分两步：

1. Construct the tree (insertion) O(logN)

2. Retrieval O(N)

时间复杂度：

最好：O(NlogN)   

平均：O(NlogN)

最坏：O(N^2)

---

Heap Sort

分两步：

1. 上浮或下沉 O(logN)

2. 遍历 O(N)

上浮 (Bubbling-Up)：用于插入元素时

最差：O(NlogN)  插入节点的复杂度是log(N+1),插N个点就是O(NlogN)

下沉 (Trickle-Down)：用于移除元素时

最差：O(NlogN)