一个短数组a，一个长数组b，都为正整数，找出两个数组重复的元素，要求不用其他数据结构，时间复杂度与空间复杂度尽量最优

一个短数组a，一个长数组b，元素都为正整数，找出两个数组重复的元素，要求不用其他数据结构，时间复杂度与空间复杂度尽量最优

1.最刚的办法：

public static void main(String[] args) {
		int[] a = new int[10000];
		int[] b = new int[100000];
//		Set<Integer> set = new HashSet<Integer>();
		Random rd = new Random();
		for (int i = 0; i < a.length; i++) {
			a[i] = rd.nextInt(8000);
		}
		
		for (int j = 0; j < b.length; j++) {
			b[j] = rd.nextInt(15000);
		}
		long s1 = System.currentTimeMillis();
		compare2(a, b);
//		Iterator<Integer> iterator = set.iterator();
//		while (iterator.hasNext()) {
//			System.out.println(iterator.next());
//		}
	    System.out.println("----------------------");
		System.out.println(System.currentTimeMillis() - s1);
	}
	
	/**
	 * 最刚的办法，一个数一个数比较，时间复杂度O(a.length * b.length)
	 * @param a
	 * @param b
	 * @param set
	 */
	public static void compare2(int[] a, int[] b) {
		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < b.length; j++) {
				if (a[i] == b[j]) {
					System.out.println(a[i]);
				}
			}
		}
	}

平均耗时: 900毫秒

2.我目前想到的办法

public static void main(String[] args) {
		int[] a = new int[10000];
		int[] b = new int[100000];
//		Set<Integer> set = new HashSet<Integer>();
		Random rd = new Random();
		for (int i = 0; i < a.length; i++) {
			a[i] = rd.nextInt(8000);
		}
		
		for (int j = 0; j < b.length; j++) {
			b[j] = rd.nextInt(15000);
		}
		long s1 = System.currentTimeMillis();
		compare1(a, b);
//		Iterator<Integer> iterator = set.iterator();
//		while (iterator.hasNext()) {
//			System.out.println(iterator.next());
//		}
		System.out.println("----------------------");
		System.out.println(System.currentTimeMillis() - s1);
	}

/**
	 * 先将2数组快速排序排为升序，短数组在外层循环，长数组在内层循环，定义2个内外层游标，从左向右移动
	 * @param a
	 * @param b
	 * @param set
	 */
	public static void compare1(int[] a, int[] b) {
		quickSort(a, 0 , a.length - 1);
		quickSort(b, 0 , b.length - 1);
//		System.out.println(Arrays.toString(a));
//		System.out.println(Arrays.toString(b));
//		System.out.println("----------------------");
		
		int i = 0;
		int j = 0;
		while (i < a.length) {
			while (i + 1 < a.length && a[i] == a[i + 1]) {
				i++;
			}
			if (a[i] < b[j]) {
				i++;
				continue;
			}
			while (j < b.length) {
				while (j + 1 < b.length && b[j] == b[j + 1]) {
					j++;
				}
				if (a[i] < b[j]) {
					i++;
					break;
				}
				if (a[i] == b[j]) {
					System.out.println(a[i]);
//					set.add(a[i]);
					i++;
					j++;
					break;
				}
				if (a[i] > b[j]) {
					j++;
					continue;
				}
			}
		}
	}
	
	public static void quickSort(int[] arr, int left, int right) {
		if (left >= right) {
			return;
		}
		int i = left;
		int j = right;
		int base = arr[i];
		while (i < j) {
			while (i < j && arr[j] >= base) {
				j--;
			}
			if (i < j) {
				arr[i] = arr[j];
			}
			while (i < j && arr[i] <= base) {
				i++;
			}
			if (i < j) {
				arr[j] = arr[i];
			}
		}
		arr[i] = base;
		quickSort(arr, left, i - 1);
		quickSort(arr, j + 1, right);
	}	

平均耗时：50毫秒

我这里求重复元素的思路

3.发现问题以及改进
上面代码发现有个bug，如果i没有走完，而j先走完了，a[i] < b[j] 比较时会抛索引越界异常。当时没有考虑到存在b数组最大值小于a数组最大值这种情况，现做如下修改：

public static void compare1(int[] a, int[] b) {
        quickSort(a, 0 , a.length - 1);
        quickSort(b, 0 , b.length - 1);
//      System.out.println(Arrays.toString(a));
//      System.out.println(Arrays.toString(b));
//      System.out.println("----------------------");
        
        int i = 0;
        int j = 0;
        while (i < a.length) {
            while (i + 1 < a.length && a[i] == a[i + 1]) {
                i++;
            }
            if (j == b.length) 
                break;
            if (a[i] < b[j]) {
                i++;
                continue;
            }    
            while (j < b.length) {
                while (j + 1 < b.length && b[j] == b[j + 1]) {
                    j++;
                }
                if (a[i] < b[j]) 
                    break;
                if (a[i] == b[j]) {
                    System.out.println(a[i]);
//                  set.add(a[i]);
                    j++;
                    break;
                }
                j++;
            }
            i++;
        }
    }

当j先走完，b数组不会存在再和a数组内重复的元素了，a数组内剩余元素无需再比较，直接结束。
有问题欢迎大佬指出