基礎排序算法

學習目錄：

• 　　選擇排序

• 　　冒泡排序

• 　　插入排序

• 　　歸並排序

• 　　二分法

• 　　異或運算

 

詳細解析后期會補上，目前先更新代碼塊

 

選擇排序（ 時間復雜度，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);
}