算法导论2-9章补充几道题

本篇博文意在对前几章中遗漏的，本人觉得有意思的习题当独拿出来练练手。

1、习题2-4，求逆序对，时间复杂度要求Θ(nlgn)

定义：对于一个有n个不同的数组A, 当i<j时，存在A[i]>A[j]，则称对偶(i, j)为A的一个逆序对。

譬如：<2,3,8,6,1>有5个逆序对。

解题思路：归并排序的思想：逆序对的数量=左区间的逆序对+右区间的逆序对+合并的逆序对

代码如下：

#include <iostream>
#include <vector>
using namespace std;

int MergeInversion(int arr[], int nLeft, int nRight);
int Merge(int arr[], int p, int q, int r);

//用归并排序找逆序对
int MergeInversion(int arr[], int nLeft, int nRight)
{
    int nInversion = 0;
    if (nLeft < nRight) {
        int nMid = (nLeft+nRight) >> 1;
        nInversion += MergeInversion(arr, nLeft, nMid);
        nInversion += MergeInversion(arr, nMid+1, nRight);
        nInversion += Merge(arr, nLeft, nMid, nRight);
    }
    return nInversion;
}

int Merge(int arr[], int p, int q, int r)
{
    int n1 = q - p + 1;
    int n2 = r - q;
    int *left = new int[n1];
    int *right = new int[n2];

    int i,j;
    for (i = 0; i < n1; i ++)
        left[i] = arr[p+i];
    for (j = 0; j < n2; j ++)
        right[j] = arr[q+1+j];

    i = 0;
    j = 0;
    int k = p;
    int nInverCount = 0; //逆序对的数目

    while (i < n1 && j < n2) {
        if (left[i] <= right[j]) 
            arr[k++] = left[i++];
        else {//假如左边子序列的数大于右子序列，则逆序对数为n1 - i;
            arr[k++] = right[j++];
            nInverCount += (n1 - i);
        }
    }
    while (i < n1)
        arr[k++] = left[i++];
    while (j < n2)
        arr[k++] = right[j++];
    
    delete left;
    left = NULL;
    delete right;
    right = NULL;
    
    return nInverCount;
}

int main()
{
    int arr[] = {2,3,8,6,1};
    int len = sizeof(arr)/sizeof(arr[0]);

    int *arrT = new int[len];
    

    cout << MergeInversion1(arr, 0, 4, arrT) << endl;
    for (int i = 0; i < 5; i++)
        cout << arrT[i] << " ";
    return 0;
}

2、习题9.3-7，设计一个O(n)时间的算法，对于一个给定的包含n个互异元素的集合S和一个正整数 k<=n，该算法能够确定S中最接近中位数的k个元素。

譬如数组：<5,7,10,3,6,2,8,9,1,11,12>，中位数为6，如果k=3，最接近6的3个元素是<5,7,4>或<5,7,8>；如果k=4，则最接近6的4个元素是<5,7,4,8>。

解题思路：

1）通过Select()得到A的中位数 --->O(n)

2）计算A中每个数到中位数的差值作为数组D ，并增加D的一个副本D‘ --->O(n)

3）通过Select()得到D’中第k大的数 ---> O(n)

4）依次遍历D中的数，判断比k小的k个数，即为所求 ---> <O(n)

代码如下：

#include <iostream>
#include <cassert>
#include <cmath>
using namespace std;

int* K_Select(int arr[], int nLen, int k);
int Select(int arr[], int nLeft, int nRight, int nMin);
int Partition(int arr[], int p, int r);
void Swap(int &n, int &m);

int* K_Select(int arr[], int nLen, int k)
{
    assert(k <= nLen);
    
    int *pDis = new int[nLen-1]; //the distance of every bit and median
    int *pDis_cpy = new int[nLen-1];
    int *pKArr = new int[k]; //return k_array

    int nMedian = Select(arr, 0, nLen-1, nLen/2); //get the median of arr
    int iMedian;
    int nDLen = 0;
    for (int i = 0; i < nLen; i ++) {
        if (arr[i] != nMedian)
            pDis[nDLen++] = abs(arr[i]-nMedian); //get the distance using abs()
        else
            iMedian = i; //get the index of median
    }
    memcpy(pDis_cpy, pDis, sizeof(int)*(nLen-1)); //copy the distance    
    int nKMedian = Select(pDis_cpy, 0, nDLen-1, k); //get the k-th minimum distance between median and every bit
    
    delete pDis_cpy;
    pDis_cpy = NULL;

    int ik = 0;
    for (int i = 0; ik < k && i < nDLen; i ++) {
        if (pDis[i] <= nKMedian) {
            if (i < iMedian) //judge the index of array and the index of median
                pKArr[ik++] = nMedian - pDis[i];
            else
                pKArr[ik++] = nMedian + pDis[i];
        }
    }

    delete pDis;
    pDis = NULL;

    return pKArr;
}

int Select(int arr[], int nLeft, int nRight, int nMin)
{
    assert(nLeft <= nRight);
    assert(nMin <= nRight-nLeft+1);

    if (nLeft == nRight)
        return arr[nLeft];
    int nMid = Partition(arr, nLeft, nRight);
    int k = nMid - nLeft + 1;
    if (k == nMin)
        return arr[nMid];
    else if (k > nMin)
        return Select(arr, nLeft, nMid-1,nMin);
    else
        return Select(arr, nMid+1, nRight, nMin-k);
}

int Partition(int arr[], int p, int r)
{
    assert(p <= r);

    int nTemp = arr[r];
    int i = p - 1, j = p;
    while(j < r) {
        if (arr[j] <= nTemp) {
            Swap(arr[i+1], arr[j]);
            i ++;
        }
        j ++;
    }
    Swap(arr[i+1], arr[r]);
    return i+1;
}

void Swap(int &n, int &m)
{
    int t = n;
    n = m;
    m = t;
}

int main()
{
    int arr[] = {5,7,10,3,6,2,8,9,4,1,11,12};
    int *karr = K_Select(arr, 12, 4);
    for (int i=0; i < 4; i ++)
        cout << karr[i] << " ";
    return 0;
}

3、习题9.3-8，求两个有序数组的中位数？

题目：设X[1...n]和Y[1...n]为两个数组，每个都包含n个有序的元素。请设计一个O(lgn)时间的算法来找出数组X 和Y中所有2n个元素的中位数。

譬如：X：<1,2,3,4,7,9>; Y:<2,5,6,7,10,11>; 中位数为数组Y中的6.

解题思路：二分查找思想--->O(lgn)

1）如果两个数组均只有一个元素，则返回数组中的较小值。

2）两个数组有2n个元素，则中位数位于n index，小于中位数的元素个数为n-1;

3）如果当前找到中位数在数组X中的标号为 K，则在数组Y的标号为：n-K-2 < index <= n-K-1;

4）如果当前在数组X中找到的中位数 X[K]<= Y[n-K-2]，说明该数小了，应该在X的右区间[mid+1, right]继续找，反之，如果X[K] > Y[n-K-1]，说明该数大了，应该在X的左区间[left, mid-1]继续找。

5）如果重复该过程，没有在X中找到该中位数，则采用同样的方法在Y中找。

代码如下：

#include <iostream>
#include <cassert>
using namespace std;

int SelectMedian(int *arrA, int *arrB, int left, int right)
{
    assert(NULL != arrA);
    assert(NULL != arrB);
    
    int nLen = right-left+1;

    while (left <= right) {
        int mid = (left+right)/2;

        if (mid == nLen-1 && arrA[mid] <= arrB[0]) //only one element
            return arrA[mid];
        else if (mid < nLen-1) {
            if(arrA[mid] <= arrB[nLen-mid] && arrA[mid] > arrB[nLen-1-mid]) //K = nLen-1-K note:from 0 index
                return arrA[mid];
            else if (arrA[mid] <= arrB[nLen-1-mid]) //if the element is small, find it in right region.
                left = mid + 1;
            else         //if the element is big, find it in left region.
                right = mid - 1;
        }
    }
    return -1;
}

//find the median of two array: arrA and arrB
//return the median of two array
void TwoArrMedian(int *arrA, int *arrB, int nLen)
{
    assert(NULL != arrA);
    assert(NULL != arrB);
    
    int nMedian;
    if (SelectMedian(arrA, arrB, 0, nLen-1) == -1) //not find
        nMedian = SelectMedian(arrB, arrA, 0, nLen-1);
    
    cout << nMedian << endl;
}

int main()
{
    int a[] = {1,2,3,4,8,9,13};
    int b[] = {2,5,6,7,10,11,12};

    TwoArrMedian(a, b, 7);
    return 0;
}

---

我的公众号 「Linux云计算网络」(id: cloud_dev)，号内有 10T 书籍和视频资源，后台回复 「1024」 即可领取，分享的内容包括但不限于 Linux、网络、云计算虚拟化、容器Docker、OpenStack、Kubernetes、工具、SDN、OVS、DPDK、Go、Python、C/C++编程技术等内容，欢迎大家关注。