排序（课堂笔记）

Selection Sort

void selectSort(int a[],int N)
{
    for(int i=0;i

时间复杂度 O(N^2)

---

Insertion Sort

void insertionSort(int A[]){
    for(int i=1;i0 && 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

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 && j>left)
            j--;
        if(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)