1. 二分查找

int binary_search(int*A,int target,int low, int high){
    
    
    if(low > high){
    
    
        return -1;
    }
    int middle = (low+high)/2;
    if(A[middle] == target)
        return middle;
    if(A[middle]<target){
    
    
        return binary_search(A,target,middle+1,high);
    }
    if(A[middle]>target){
    
    
        return binary_search(A,target,0,middle);
    }
}

2. 排序

2.1 冒泡排序(bubble sort)

auto bubbleSort(int* arr, int low, int high){
    
    
    int pointer_i = high; //一个指针从右往左移动
    int pointer_j = low; //一个指针从左往右移动
    while(pointer_i >= low){
    
    
        for(pointer_j = low; pointer_j <= pointer_i; pointer_j++){
    
    
            if(arr[pointer_j]>arr[pointer_j+1]){
    
     //逆序
                int tmp = arr[pointer_j];
                arr[pointer_j] = arr[pointer_j+1];
                arr[pointer_j+1] = tmp;
            }
        }
        pointer_i--;
    }
}

2.2 归并排序(merge sort)

整体框架：

auto MergeSort(int* arr, int low, int high){
    
    
    if(low >= high){
    
     //单元素或无元素区间必定有序
        return;
    }
    int middle = (low + high)/2;
    MergeSort(arr, low, middle); //左边有序
    MergeSort(arr, middle+1, high); //右边有序
    Merge(arr, low, middle, high); //将左右两个有序向量合并成一个有序向量
}

合并两个有序向量的函数Merge:

void Merge(int * arr, int low, int middle, int high){
    
    
    int* buffer = new int[high - low + 1]; //需要开辟新的空间
    int left_ptr = low; //左边向量的开始
    int right_ptr = middle+1; //右边向量的开始
    int buffer_ptr = 0;
    while(buffer_ptr<=high-low) {
    
    
        if (left_ptr > middle) {
    
     //左边向量已经空了，就把右边向量一股脑塞到buffer中
            for (; right_ptr <= high; right_ptr++) {
    
    
                buffer[buffer_ptr] = arr[right_ptr];
                buffer_ptr++;
            }
            continue;
        }
        if (right_ptr > high) {
    
    
            for (; left_ptr <= middle; left_ptr++) {
    
    
                buffer[buffer_ptr] = arr[left_ptr];
                buffer_ptr++;
            }
            continue;
        }

        if (arr[left_ptr] < arr[right_ptr]) {
    
    
            buffer[buffer_ptr] = arr[left_ptr];
            left_ptr++;
            buffer_ptr++;
        }
        if(arr[right_ptr] < arr[left_ptr]){
    
    
            buffer[buffer_ptr] = arr[right_ptr];
            right_ptr++;
            buffer_ptr++;
        }
    }
}

2.3 插入排序

序列总能视作两部分：前一部分有序，后一部分无序。
对于一个candidate e，需要找到它在前面那个有序的序列中应该排在什么位置，然后插入其中。值得注意的是，由于向量这个数据结构天然不适合“插入”，所以还是列表更适合做插入排序。

2.4 选择排序

void selection_sort(int*arr, int low, int high){
    
    
    if(high < low)
        return;
    int mmax = -INT32_MAX;
    int max_pos = -1;
    for(int i = low; i<=high ; i++){
    
    
        if(arr[i] > mmax){
    
    
            max_pos = i;
            mmax = arr[i];
        }
    }//找到了无序区间最大的元素位置max_pos
    swap(arr[max_pos], arr[high]);
    //减而治之
    selection_sort(arr, low, high-1);

}