Java 显示不属于两个数组的两个数组中的元素

我编写这段代码是为了显示只属于任何一个数组的元素。我们能提高效率吗

public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

公共类应用程序{
公共静态void main（字符串[]args）{
int[]a={1,2,3,4,5,6,7,8,9}；
int[]b={1,20,3,4,15,13,6,7,8,12}；
for（int i=0；i

您的代码以

O（m*n）

时间复杂度运行，其中

m

和

n

是数组的大小

public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

如果可以修改阵列，有一些方法可以改善这一点：

public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

对两个数组进行排序

对数组执行类似于merge sort的合并操作，但合并操作是，如果元素相等，则删除它们

---

总体复杂性=

O（m*log（m）+n*log（n）+m+n）=O（m*log（m）+n*log（n））=O（k*log（k））

其中

k=max（m，n）

。请注意，此方法中没有使用额外的空间，即空间复杂度为

O（1）

您的代码以

O（m*n）

时间复杂度运行，其中

m

和

n

是数组的大小

public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

如果可以修改阵列，有一些方法可以改善这一点：

public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

对两个数组进行排序

对数组执行类似于merge sort的合并操作，但合并操作是，如果元素相等，则删除它们

总体复杂性=

O（m*log（m）+n*log（n）+m+n）=O（m*log（m）+n*log（n））=O（k*log（k））

其中

k=max（m，n）

。请注意，此方法中没有使用额外的空间，即空间复杂度为

O（1）

是的。肯定

public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

当前，您有一个

O（m*n）

其中

m

是数组

a

的大小，

n

是数组

b

的大小。
将数据从第一个数组复制到

散列集
（一个
O（n）
操作，其中
n
是
a
的大小）。然后，解析第二个数组检查，查看数据是否在
hashset
中（一个
O（1）
操作）。


考虑对第二个数组做同样的操作。
 < P>是的。肯定
public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}

当前，您有一个
O（m*n）
其中
m
是数组
a
的大小，
n
是数组
b
的大小。


将数据从第一个数组复制到
散列集
（一个
O（n）
操作，其中
n
是
a
的大小）。然后，解析第二个数组检查，查看数据是否在
hashset
中（一个
O（1）
操作）。


考虑对第二个数组做同样的事情。
你尝试检查这两个列表之间的相似性吗？我投票把这个问题作为主题关闭，因为“请让这个更高效”不是堆栈溢出的合法问题描述。堆栈溢出适用于代码不工作的情况。当您想改进完全工作的代码的实现时，请改用。@dasblinkenlight我对这里不熟悉。我不知道。谢谢。您试图检查两个列表之间的相似性吗？我投票将此问题作为离题题结束，因为“请使其更有效”不是堆栈溢出的合理问题描述。堆栈溢出适用于代码不工作的情况。当您想改进完全工作的代码的实现时，请改用。@dasblinkenlight我对这里不熟悉。我不知道。谢谢。请注意，这种方法增加了O（m）或O（n）空间的复杂性。请注意，这种方法增加了O（m）或O（n）空间的复杂性。
public class App {
public static void main(String[] args){
    int[] a = {1,2,3,4,5,6,7,8,9};
    int[] b = {1,20,3,4,15,13,6,7,8,12};

    for(int i = 0; i < a.length; i++){
        int temp = a[i];
        for(int j = 0; j < b.length; j++){
            if(b[j] == temp){
                b[j] = -1;
                a[i] = -1;
            }
        }
        if(a[i] != -1)
            System.out.print(a[i] + " ");
    }

    for(int i = 0; i < b.length; i++){
        if(b[i] != -1)
            System.out.print(b[i] + " ");
    }
}   
}