LeetCode 笔记27 Two Sum III

Design and implement a TwoSum class. It should support the following operations: add and find.

add - Add the number to an internal data structure.
find - Find if there exists any pair of numbers which sum is equal to the value.

这个解法很容易想到，但很容易超时。

基本来说有这样几个途径去解。

第一种，使用一个数组去存所有加入的元素，使用一个Set去存所有的和。在实现Find的时候，遍历数组，把能够得到的和都加到set中去。这样，find的时间复杂度是O(1)了，因为只需要判断value是否在集合里面，但是add就变成了O(n)。实践证明这是行不通的。

第二种，还是使用一个数组去存元素，但是每次加入的时候保持数组有序，这样虽然可以通过二分查找找到插入点，但是插入本身，由于是在数组中，复杂度就变成O(n)了。在实现Find的时候，使用TwoSum标准算法（用两个指针，一前一后遍历）。所以这个也没有好多少，还是会超时。

第三种，不要使用数组了。使用一个Search Tree来存放元素。这样在add的时候可以基本保证O(logn)。

Find怎么办呢？

其实也可以采用TwoSum的那个标准算法，但是需要在TreeNode里面存放一个pre和next指针，分别是排序后的，该节点的前一个和后一个元素。这样你远看是一颗树，近看是双向链表。

在二叉排序树中插入一个节点大家都会，要注意的是如何在插入的过程中，记录pre和next。其实只要是向右搜索，我们就给pre赋值，向左搜索就给next赋值就可以了。

哦，对了，还要在插入过程中注意update 双向链表的head和tail，这个也很容易，只要插入后发现pre是null，那么这个节点肯定是head嘛，next是null就是tail咯。

代码是这个。

public class TwoSumDS {

    private TreeNode root;
    private TreeNode head;
    private TreeNode tail;
    
    //private Set<Integer> seenSum = new HashSet<>();

    public void add(int number) {
        if (root == null) {
            root = new TreeNode(number);
            head = tail = root;
        } else {
            insertIntoTree(number);
        }
    }

    public boolean find(int value) {
        {
            if (head != null && tail != null && head != tail) {
                TreeNode p = head, q = tail;
                while (p != q) {
                    int sum = p.val + q.val;
                    //seenSum.add(sum);
                    if (sum > value) {
                        q = q.pre;
                    } else if (sum < value) {
                        p = p.next;
                    } else {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    private void insertIntoTree(int val) {
        TreeNode p = root;
        TreeNode pre = null;
        TreeNode next = null;
        while (true) {
            //seenSum.add(val + p.val);
            if (val > p.val) {
                pre = p;
                if (p.right != null) {
                    p = p.right;
                } else {
                    p.right = new TreeNode(val);
                    insertInToChain(p.right, pre, next);
                    break;
                }
            } else {
                next = p;
                if (p.left != null) {
                    p = p.left;
                } else {
                    p.left = new TreeNode(val);
                    insertInToChain(p.left, pre, next);
                    break;
                }
            }
        }
    }
    
    private void insertInToChain(TreeNode n, TreeNode pre, TreeNode next) {
        if (pre != null) {
            pre.next = n;
        } else {
            head = n;
        }
        if (next != null) {
            next.pre = n;
        } else {
            tail = n;
        }
        n.pre = pre;
        n.next = next;
    }
    
    private static class TreeNode {
        int val;
        TreeNode right;
        TreeNode left;
        TreeNode pre;
        TreeNode next;
        TreeNode(int val) {
            this.val = val;
        }
    }
    
    public static void main(String[] args) {
        TwoSumDS ts = new TwoSumDS();
        ts.add(1);
        ts.add(3);
        ts.add(5);
        System.out.println(ts.find(4));
        System.out.println(ts.find(7));
    }
}

注意到撸主注释的部分，有一个优化。就是在插入和搜索过程中，沿途找到的sum我们缓存起来，下次说不定可以用。Find的之前可以先在seenset里面看看。

不过这个优化导致了超时，所以就去掉了。看了一下Java doc，并没有gurantee HashSet的存放操作是O(1)的。

看来Java还没有很多人提交哟：>