C++学习日志day19-----数据结构与算法

介绍4种排序算法和1种查找算法：
冒泡排序
先确定目的位置（比如说，最大的放在数组末尾），然后从另一端的第一个数开始，将相邻的两个数进行比较，交换。代码如下：

int bubble_sort(int *num,int size){
    int temp = 0;
    for(int i = 0;i < size - 1;i++)
        for(int j = 0;j < size - 1 -  i;j++){
            if(*(num + j) < *(num + j + 1)){
                temp = *(num + j + 1);
                *(num + j + 1) = *(num + j);
                *(num + j) = temp;
            }
        }
}

选择排序
先选择一个目标位置，然后从另一端的第一个数开始，和数字中的每一个数进行比较，交换，直到把合适的数放在合适的位置上。代码如下：

int choice_sort(int* p_num,int size){
    int temp = 0;
    for(int i = size - 1;i > 0;i--)
        for(int j = 0;j < i;j++){
            if(*(p_num + i) < *(p_num + j)){
                temp = *(p_num + i);
                *(p_num + i) = *(p_num + j);
                *(p_num + j) = temp;
            }
        }
}

插入排序
默认数组中第一个数据已经按照顺序（这里用从小到大举例）排列，用第二个数据和第一个数据比较小，就将第二个数据插入到第一个数据之前，完成换位动作之后，原本的第二个数据肯定是已经到达合适的位置，就不再往前比较。按照这样的规律将数据后续剩余的所有数据都依次插入。
代码如下：

int insert_sort(int* p_num,int size){
    int temp = 0;
    for(int i = 1;i < size;i++)
        for(int j = i - 1;j >= 0;j--)
        {
            if(*(p_num + j + 1) < *(p_num + j)){
                temp = *(p_num + j + 1);
                *(p_num + j + 1) = *(p_num + j);
                *(p_num + j) = temp;
            }
            else break;
        }
}

快速排序
这种排序方法最快，也是最难理解的。（以从小到大为例）
3，8，1，2，9，7，6，5 我们以5为目标数据，3是这一次比较的比较数据
3，8，1，2，9，7，6，5 3在5的左边且比5小，不换位，将8作为这次的比较数据
3，5，1，2，9，7，6，8 8在5的左边且比5大，换位，将6作为这次的比较数据
3，5，1，2，9，7，6，8 6在5的右边且比5大，不换位，将7作为这次的比较数据
3，5，1，2，9，7，6，8 7在5的右边且比5大，不换位，将9作为这次的比较数据
3，5，1，2，9，7，6，8 9在5的右边且比5大，不换位，将2作为这次的比较数据
3，2，1，5，9，7，6，8 2在5的右边且比5小，换位，将1作为这次的比较数据
3，2，1，5，9，7，6，8 1在5的左边且比5小，不换位，本轮换位结束。

可以发现一轮换位之后，5左边的数字都比5小，5右边的数字都比5大。
上述的操作是快速排序的最基本操作。
接下来，要对5左边的数字进行上述操作，然后对右边也进行这样的操作，最终会把所有的数据排列好。
所以快速排序，是由它基本的操作和递归函数组成的。
代码如下：

void quick_sort(int* p_num,int size){
    int base = *p_num;
    int* p_start = p_num;
    int* p_end = p_num + size - 1;
    int temp = 0;
    if(!(p_start < p_end))
        return ;
    while(p_start < p_end){
        if(*p_start > *p_end)
            ex(p_start,p_end);
        if(*p_start == base)
            p_end--;
        else
            p_start++;
    }
    quick_sort(p_num,p_start - p_num);
    quick_sort(p_end + 1,size - (p_end - p_num) - 1);
}

上述代码中，灵活的运用了指针。
原本，按照快速排序的思想，会选择一个数据来展开讨论，且有四种情况。
然而，代码中，从考虑目标数数据通过指针转变成了考虑位置。
只要前面的位置的数据大于后面数据的位置，就换位，然后再确定谁是目标数据，再将参与过排序的比较数据剔除。大大的简化了代码。目前说不上来是什么改进，总觉得是个很棒的思想。
折半查找
比起顺序查找，折半查找节省了一半的时间。
折半查找要求数组已经是有序的。
将要查找的目标数据和查找范围的中间值比较，然后缩小查找范围，最终找到数据。
代码如下：

void ex(int* first,int* secend){
    int temp = 0;
    temp = *secend;
    *secend = *first;
    *first = temp;
}
int* search(const int* p_num,int size,int value){
    const int* p_first = p_num;
    const int* p_last = p_num + size - 1;
    const int* p_mid = NULL;
    while(p_first <= p_last){                        //当两个指针没有交错的时候继续循环
        p_mid = p_first + (p_last - p_first + 1)/2; //中间指针用于查找数值，每次都要设置成查找范围的中间位置
        if(*p_mid < value){                         //如果目标值比当前的中间指针所指的数字要大，就把头指针移动到中间指针的后面的位置，来缩小范
围
            p_first = p_mid + 1;
        }
        else if(*p_mid > value){                    //如果目标值比当前的中间指针所知的数字要小，就把尾指针移动到中加你指针的前面的位置，缩小范
围
            p_last = p_mid - 1;
        }
        else{                                       //找到了就返回中间指针
            return (int*)p_mid;
        }
    }
    return NULL;                                    //找不到就返回空指针
}