Question

我有一个方法，它接受2个属性，这两个属性是2个数组，并按升序合并它们。剩下的就是弄清楚如何删除重复项。这是代码：

public static int[] mergeArrays(int[] a, int[] b){

    int[] c = new int[a.length+b.length];
    int aIt = 0;
    int bIt = 0;

    while(true) {


        if(aIt < a.length && bIt < b.length) {
            if(a[aIt] == b[bIt]){
                c[aIt+bIt] = a[aIt++];
            }
            else{
                c[aIt+bIt] = b[bIt++];
            }
        } else if(aIt < a.length) {
            c[aIt+bIt] = a[aIt++];
        } else if(bIt < b.length) {
            c[aIt+bIt] = b[bIt++];
        } else {
            break;
        }
    }
    return c;
}

你可以想象，这是一个赋值，所以我不应该使用任何外部库，否则这将更容易。

我试过这个方法，但是当我在控制台中运行这个代码时，它似乎把它放在一个永不停止的循环中，它完全消耗我的CPU内核，直到我停止进程：

public static int[] mergeArrays(int[] a, int[] b){

    int[] c = new int[a.length+b.length];
    int aIt = 0;
    int bIt = 0;
    int lastVal = 0;
    while(true) {
        if(c[aIt+bIt] == lastVal){
            continue;
        }
        else{
            if(aIt < a.length && bIt < b.length) {
                if(a[aIt] == b[bIt]){
                    c[aIt+bIt] = a[aIt++];
                    lastVal = c[aIt+bIt];
                }
                else{
                    c[aIt+bIt] = b[bIt++];
                    lastVal = c[aIt+bIt];
                }
            } else if(aIt < a.length) {
                c[aIt+bIt] = a[aIt++];
                lastVal = c[aIt+bIt];
            } else if(bIt < b.length) {
                c[aIt+bIt] = b[bIt++];
                lastVal = c[aIt+bIt];
            } else {
                break;
            }
        }
    }
    return c;
}

似乎“continue”关键字就是问题所在。当我尝试中断它时，代码就会执行。

编辑：

我在mergeArrays方法中添加了一个新数组：

public static int[] mergeArrays(int[] a, int[] b)
{
    int a_size = a.length;
    int b_size = b.length;
    int[] c = new int[a_size + b_size];
    int[] d = null;
    int i = 0 , j = 0, x = -1;
    for(; i < a_size && j < b_size;)
    {
        if(a[i] <= b[j])
        {
            c[++x] = a[i];
            ++i;
            }
        else          
        {
            if(c[x] != b[j])
            {
                c[++x] = b[j]; // avoid duplicates
            }
            ++j;
            }
            }
            --i; --j;
            while(++i < a_size)
            {
                c[++x] = a[i];
            }
            while(++j < b_size)
            {
                c[++x] = b[j];
            }
    d = new int[uniqueValues(c)];        

    for(int g=0; g<uniqueValues(c); g++){
        d[g] = c[g];
    }
    return d;
}

Answer 1

嗯，你可以按照以下两个步骤完成这些任务：

对两个数组进行排序。

static void sortArray(int[] a) {
    for (int lastPos = a.length - 1; lastPos >= 0; lastPos--) {
        for (int index = 0; index <= lastPos - 1; index++) {
            if (a[index] > a[index + 1]) {
                int temp = a[index];
                a[index] = a[index + 1];
                a[index + 1] = temp;
            }
        }
    }
}

合并时删除重复项。

public static int[] mergeArrays(int[] a, int[] b)
        {
            int a_size = a.length;
            int b_size = b.length;
            int[] c = new int[a_size + b_size];
            int i = 0 , j = 0, x = -1;
            for(; i < a_size && j < b_size;)
            {
                if(a[i] <= b[j])
                {
                    c[++x] = a[i];
                    ++i;
                    }
                else          
                {
                    if(c[x] != b[j])
                    {
                        c[++x] = b[j]; // avoid duplicates
                    }
                    ++j;
                    }
                    }
                    --i; --j;
                    while(++i < a_size)
                    {
                        c[++x] = a[i];
                    }
                    while(++j < b_size)
                    {
                        c[++x] = b[j];
                    }
                    return c;
                    }

计算新合并数组中的唯一值。

static int uniqueValues(int[] c) {
    int uniqueValues = c.length;
    for (int i = 0; i < c.length; i++) {
        while (c[i] == c[i + 1] && i + 1 < c.length && c[i] > c[i+1] ) {
            i++;
            uniqueValues--;
        }
    }
    return unique;
}

使用唯一值计数重新建立合并数组，即在计数完成后删除剩余元素。

sortArray(a);
sortArray(b);
int[] c = mergeArrays(a, b);
c = deleteDuplicateEntries(c, uniqueValues(c));

如果您发现它有用，请告诉我。

Answer 2

让图书馆为您服务：

（注意，在jshell之外，你必须用“;”终止每个非空行）

int[] ai = {0, 1, 15, 16, 27, 84, 49, 4, 5 }
int[] bi = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 1, 4, 5 }

List <Integer> li = new ArrayList<> ()
Arrays.stream (ai).forEach (i -> li.add (new Integer (i))) 
Arrays.stream (bi).forEach (i -> li.add (new Integer (i))) 
Collections.sort (li)
int [] res = li.stream().distinct().mapToInt (i -> i.intValue()).toArray()

导致jshell：

for (int i: res) System.out.printf (" %d", i); 
 0 1 2 3 4 5 6 7 8 9 10 11 12 15 16 27 49 84

如何在数组合并方法中删除重复项？

2 个答案: