基础排序算法

学习目录：

• 　　选择排序

• 　　冒泡排序

• 　　插入排序

• 　　归并排序

• 　　二分法

• 　　异或运算

 

详细解析后期会补上，目前先更新代码块

 

选择排序（ 时间复杂度，O(N²) ）

void selectSort(int array[], int len)
{
    if (array == NULL || len < 2)
    {
        return;
    }
    for (int i = 0; i < len - 1; i++)
    {
        int minIndex = i;
        for (int j = i + 1; j < len; j++)
        {
            if (array[j] < array[minIndex])
            {
                Swap(array, minIndex, j);
            }
        }
    }
}

 

冒泡排序（ 时间复杂度，O(N²) ）

void BubbleSort(int array[], int len)
{
    if (array == NULL || len < 2)
    {
        return;
    }
    for (int i = len - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            if (array[j] > array[j + 1])
            {
                Swap(array, i, j);
            }
        }
    }
}

 

插入排序（ 时间复杂度，最优O(N)，最差O(N²) ）

void insertSort(int array[], int len)
{
    if (array == NULL || len < 2)
    {
        return;
    }
    for (int i = 1; i < len; i++)
    {
        for (int j = i - 1; j >= 0 && array[j] > array[j + 1]; j--)
        {
            Swap(array, j, j + 1);
        }
    }
}

 

归并排序（时间复杂度，O(N*logN) ）

void merge(int array[], int L, int M, int R)
{
    vector<int>help;
    int p1 = L;
    int p2 = M + 1;
    while (p1 <= M && p2 <= R)
    {
        help.push_back(array[p1] <= array[p2] ? array[p1++] : array[p2++]);
    }
    while (p1 <= M)
    {
        help.push_back(array[p1++]);
    }
    while (p2 <= R)
    {
        help.push_back(array[p2++]);
    }
    for (int i = 0; i < help.size(); i++)
    {
        array[L + i] = help.at(i);
    }
}

void mergeSort(int array[], int L, int R)
{
    if (L == R)
    {
        return;
    }
    int mid = L + ((R - L) >> 1);
    mergeSort(array, L, mid);
    mergeSort(array, mid + 1, R);
    merge(array, L, mid, R);
}

void mergeSort(int array[], int len)
{
    if (array == NULL || len < 2)
    {
        return;
    }
    mergeSort(array, 0, len - 1);
}

 

归并排序例题：

题目：小和问题

在一个数组中，每一个数左边比当前数小的和累加起来，叫做这个数的小和。

int merge(int array[], int L, int R)
{
    vector<int>help(R - L + 1);
    int M = L + ((R - L) >> 1);
    int res = 0;
    int p1 = L;
    int p2 = M + 1;

    while (p1 <= M&&p2 <= R)
    {
        res += array[p1] < array[p2] ? (R - L + 1)*array[p1] : 0;
        help.push_back(array[p1] < array[p2] ? array[p1++] : array[p2++]);
    }
    while (p1 <= M)
    {
        help.push_back(array[p1++]);
    }
    while (p2 <= M)
    {
        help.push_back(array[p2++]);
    }
    return res;
    
}

int mergeSort(int array[], int L, int R)
{
    if (L == R)
    {
        return 0;
    }
    int M = L + ((R - L) >> 1);
    return merge(array, L, M) + merge(array, M + 1, R) + merge(array, L, R);
}

int smallSum(int array[], int len)
{
    if (array == NULL || len < 2)
    {
        return 0;
    }
    mergeSort(array, 0, len - 1);
}

 

 

二分法（时间复杂度，O(logN) ）

注：不一定是有序才能二分，例如  局部最小值问题

bool binarySort(int array[], int len, int num)
{
    if (array == NULL || len == 0)
    {
        return false;
    }
    int L = 0;
    int R = len + 1;
    int mid = 0;
    while (L < R)
    {
        mid = L + ((R - L) >> 1);
        if (array[mid] == num)
        {
            return true;
        }
        else if (array[mid] < num)
        {
            R = mid - 1;
        }
        else if (array[mid] > num)
        {
            L = mid + 1;
        }
    }
    return array[L] == num;
}

用二分法解决问题

题目：在一个有序数组中，找>=某个数最左侧的位置

int binarySolve(int array[],int len,int num)
{
    int L = 0;
    int R = len - 1;
    int mid = 0;
    int index = -1;
    while (L < R)
    {
        mid = L + ((R - L) >> 1);
        if (array[mid] >= num)
        {
            index = mid;
            R = mid - 1;
        }
        else
        {
            L = mid + 1;
        }
    }
    return index;
}

 

 

用异或运算交换值

void Swap(int array[], int i, int j)
{
    array[i] = array[i] ^ array[j];
    array[j] = array[i] ^ array[j];
    array[i] = array[i] ^ array[j];
}

 

用异或运算解决问题

题目：一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到这个两个数

分析：

首先，将所有的数全部异或，然后得到的结果，就是奇数A与奇数B异或的结果。

因为异或相同的要变成0，所以说，A^B异或的结果肯定有一个1。

然后去取出这个结果最右侧的1，提出来之后，再用这个1去跟所有的数去做 与 操作，

如果 与 操作的结果是1 ，那么就跟这个数进行 异或 操作。这样就得出来了A或者B中的一个值

再用这个值 去跟 A^B异或，然后得出另一个值，这两个奇数答案就出来了。

void findodd(int array[], int len)
{
    int eor=0;
    for (int i = 0; i < len; i++)
    {
        eor ^= array[i];
    }
    //eor = a^b; 两个奇数
    //现在要找出最右侧的1
    int rightone = eor & (~eor + 1);
    //把有1的跟其中一组奇数进行异或
    int onlyone = 0;
    for (int i = 0; i < len; i++)
    {
        if ((rightone&array[i])!=0)
        {
            onlyone^= array[i];
        }
    }
    int res = onlyone ^ eor;
    cout << onlyone << "  " << res;
}

 

递归解题

题目：求一个数组中的最大值

int process(int array[], int L, int R)
{
    if (L == R)
    {
        return array[L];
    }
    int mid = L + ((R - L) >> 1);
    int left = process(array, L, mid);
    int right = process(array, mid + 1, R);
    return max(left, right);
}

int getMax(int array[], int len)
{
    return process(array, 0, len - 1);
}