yangxiaohei / algorithms Goto Github PK

/**
 * @author ZZY
 */
public class Ex12 {

    /**
     * 使用 hashmap，元素为键。
     * O(N)
     */
    public static void printCommon(int[] a, int[] b) {
        Map<Integer, Integer> valueMap = new HashMap<>(16);
        //先循环一个数组存入 hashmap，所有键对应的值都是 1
        for (Integer i : a
        ) {
            int count = 1;
            valueMap.put(i, count);
        }
        //再循环第二个数组，如果有重复的键，就直接打印
        for (Integer i : b
        ) {
                if (valueMap.containsKey(i)) {
                    StdOut.print(i + " ");
                    //已经打印过的就删除防止二次打印
                    valueMap.remove(i);
                }
        }
    }

    /**
     * 不使用 hashmap，当数组中元素有重复时，就可能重复打印公共元素,例如：
     *
     * 两个数组的元素：
     * 2 5 6 7 16 20 21 28 34 41 47 69 74 84 87 92 96 97 97 98
     * 8 12 19 24 25 26 28 30 33 33 54 58 63 82 84 89 93 93 97 97
     * 公共元素：
     * 28 84 97
     * 28 84 97 97
     *
     * 因为数组 a 中有相邻相等的元素 97，且数组 b 中也有相邻相等的元素 97，结果会打印两次 97
     *
     * O(N)
     */
    public static void printCommon2(int[] a, int[] b) {
        if (a == null || b == null) {
            throw new NullPointerException();
        }
        int i = 0, j = 0;
        while (i < a.length && j < b.length) {
            //此时，b 中索引小于 j 的都不可能是公共元素
            if (a[i] > b[j]) {
                j++;
                //此时，a 中索引小于 i 的都不可能是公共元素
            } else if (a[i] < b[j]) {
                i++;
                //a[i] == b[j] 时，打印元素
            } else {
                StdOut.print(a[i] + " ");
                i++;
                j++;
            }
        }
    }

    public static int[] sourceArr(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = StdRandom.uniform(0, 100);
        }
        Arrays.sort(arr);
        return arr;
    }

    public static void main(String[] args) {
        int[] a = sourceArr(20);
        int[] b = sourceArr(20);
        System.out.println("两个数组的元素：");
        for (int i : a
        ) {
            System.out.print(i + " ");
        }
        System.out.println();
        for (int i : b
        ) {
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println("公共元素：");
        printCommon(a, b);
        System.out.println();
        printCommon2(a, b);
    }
}  

1.4.15:
```java
/**
 * 快速 3-sum，要求：
 * 线性级别，和为 0 的整数对的个数
 * 前提：数组有序
 * <p>
 * 先实现线性级别的 twosum，再实现平方级别的 3-sum
 */
public class Ex15 {

    /**
     * 思路：和为零说明两个数一正一负或者都为零，数组有序，负数在左侧正数在右侧，
     * 两个索引一个从零开始，一个从数组尾开始向中间遍历
     */
    public static int twoSumCount(int[] a) {
        if (a == null || a[0] > 0){
            return 0;
        }
        int first = 0;
        int last = a.length - 1;
        int count = 0;
        while (last > first) {
            if (a[last] + a[first] < 0) {
                first++;
            } else if (a[last] + a[first] > 0) {
                last--;
            } else {
                //相等时，last 向左推进找到所有与 a[last] 相等的正数，计数为 positiveCount
                //first 向右推进找到所有与 a[first] 相等的负数，计数为 negativeCount
                //整数对的个数为 positiveCount * negativeCount
                int preFirst = first;
                int preLast = last;
                int positiveCount;
                int negativeCount;

                //如果该数组中有 0，则当两指针相等且均为 0 时，计算 0 的个数并得到整数对的个数，最后返回 count
                if (a[first] == 0) {
                    int zeroNum = last - first + 1;
                    count += zeroNum * (zeroNum - 1) / 2;
                    return count;
                }
                while (a[first] == a[preFirst]) {
                    first++;
                }
                while (a[last] == a[preLast]) {
                    last--;
                }
                positiveCount = preLast - last;
                negativeCount = first - preFirst;
                count += positiveCount * negativeCount;
            }
        }
        return count;
    }

    /**
     * 原答案
     * */
    public static int count(int[] a) {
        if (a == null || a.length == 0 || a[0] > 0) {
            return 0;
        }
        int cnt = 0, N = a.length, lo = 0, hi = N - 1;
        while (lo <= hi) {
            if 		(a[lo] + a[hi] < 0) {
                lo++;
            } else if (a[lo] + a[hi] > 0) {
                hi--;
            } else 	{ cnt++; lo++; hi--; }
        }
        return cnt;
    }

    public static int[] sourceArr(int n) {
        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i] = StdRandom.uniform(-10, 10);
        }
        Arrays.sort(arr);
        return arr;
    }
/**
     * -9 -9 -8 -8 -7 -6 -5 -5 -3 -3 -1 0 0 1 3 3 3 4 7 7 
     * 10
     * 5
     * */
    public static void main(String[] args) {
        int[] a = sourceArr(20);
        for (int i : a
        ) {
            System.out.print(i + " ");
        }
        System.out.println();
        System.out.println(twoSumCount(a));
        System.out.println();
        System.out.println(count(a));
    }
}