有序数组归并

写下这段文字纯粹因为太生疏了。
下午花了很多时间写有序数组的归并陷入死胡同,结果是证明了两个数组归并没有辅助数组时不幸的。
通常的数组归并,对于大小为m和n的数组,需要m+n的辅助数组，写起来并不复杂。
有次面试的时候要求写一个只有n辅助大小的做法。将b数组拷到a数组中,然后在a,b中选小的逐个放入a中。

复杂一点,除了省点内存外意义不大,可能效率还降低。

以下代码在vs2005下编译运行。

#include <cstdio>
#include <vector>

using namespace std;

void mergearr(int* a, int m, int* b, int n)
{
    int* assit = new int[m + n];
    int* posa = a, *posb = b, *cur = assit;
    while (posa < a + m && posb < b + n)
    {
        if (*posa <= *posb)
        {
            *cur = *posa;
            ++cur;
            ++posa;
        }
        else
        {
            *cur = *posb;
            ++cur;
            ++posb;
        }
    }

    if (posa == a + m)
    {
        for (; posb < b + n; ++posb,++cur)
        {
            *cur = *posb;
        }
    }
    else
    {
        for (; posa < a + m; ++posa, ++cur)
        {
            *cur = *posa;
        }
    }

    memcpy(a, assit, sizeof(int) * (m + n));
}

int main()
{
    vector<int> a,b;
    int m,n;
    printf("输入两个有序数组:/n输入数组大小:");
    scanf("%d", &m);
    a.resize(m);
    for (int i = 0; i < m; ++i)
    {
        scanf("%d", &a[i]);
    }
    printf("输入数组大小:");
    scanf("%d", &n);
    b.resize(n);
    for (int i = 0; i < n; ++i)
    {
        scanf("%d", &b[i]);
    }

    a.resize(m + n);
    mergearr(&a[0], m, &b[0], n);

    for (int i = 0; i < m + n; ++i)
    {
        printf("%d ", a[i]);
    }

    putchar('/n');
    return 0;
}

最少交换次数
将一个无序序列变成有序(序列中没有相等的数),可以进行任意两个位置的交换操作，求最少的交换次数
如:
5 2 1 4 3
转成:
0 1 4 5 9

循环分解:
(9 0 4)(1)(5)，只需将(9 0 4)分解即可。
而(1 2 ... n)=(1 2 ... n-1)(1 n)=(1 2)(1 3)...(1 n)
因此(9 0 4)可以分解为两个置换。
所以该序列只需经过两次交换即可。按照这种做法，对于一个序列，我们对其循环分解,n-循环总数即是交换次数。

代码如下(vc2005)：

#include <vector>
#include <hash_set>

using namespace std;
using namespace stdext;

int main()
{
    int n;
    scanf("%d", &n);
    printf("必须是1-n的一个序列,数字不能重复:/n");

    hash_set<int> h;
    bool notin_1, notin_2;
    int val;
    int loops = 0;

    for (int i = 1; i <= n; ++i)
    {
        scanf("%d", &val);

        notin_1 = h.find(val) == h.end();
        notin_2 = h.find(i) == h.end();

        if (notin_1)
        {
            //两个都没在哈希表中,循环个数+1,两个都放入哈希表中
            if (notin_2)
            {
                h.insert(val);
                h.insert(i);
                ++loops;
            }
            //只有一个在哈希表中,将没在哈希表中的加入
            else
            {
                h.insert(val);
            }
        }
        else if (notin_2)
        {
            h.insert(i);
        }
        //两个都在表中,什么也不做
    }

    printf("最少需要交换%d次./n", n - loops);
}

这比求逆序数更快,只有o(n)的复杂度,扫描一次即可。

 

疑问:

这种做法求出来的是否是最少交换?
如果序列中有重复怎么解决?