算法模版

1、 二分查找

int left = 0, right = array.length - 1;
while (left <= right) {
    int middle = (left + right) / 2;
    if (array[middle] == target) {
        // find the result
        return middle;
    } else if (array[middle] < target) {
        left = middle + 1;
    } else {
        right = middle - 1;
    }
}

2、广度优先搜索

  void bfs(TreeNode node) {
      Queue<TreeNode> queue = new LinkedList<>();
      Set<TreeNode> visited = new HashSet<>();
      queue.add(node);
      while (!queue.isEmpty()) {
          TreeNode treeNode = queue.poll();
          visited.add(treeNode);
          // 处理当前节点
          process(treeNode);
          // 找到子节点
          List<TreeNode> childNodes = generated(treeNode);
          for (TreeNode childNode : childNodes) {
              if (!visited.contains(childNode)) {
                  queue.offer(childNode);
              }
          }
      }
  }

3、深度优先搜索

递归写法

void dfs(TreeNode node, Set<TreeNode> visited) {

      visited.add(node);

      // process node

      // 查找子节点
      for (childNode in generateNode(node)) {
          if (!visited.contains(childNode)) {
              dfs(childNode, visited);
          }
      }
      visited.remove(node);

  }

非递归写法

  void dfs(TreeNode node) {

      if (node == null) {
          return;
      }
      Stack<TreeNode> stack = new Stack<>();
      Set<TreeNode> visited = new HashSet<>();
      stack.add(node);

      while (!stack.isEmpty()) {
          TreeNode treeNode = stack.pop();
          visited.add(treeNode);
          
          process(node);
          for(childNode in generateNode(node)) {
              stack.push(childNode);
          }
      }

  }

4、字典树

public class Trie208 {

    TrieNode trie;

    public Trie208() {
        trie = new TrieNode();
    }

    public static void main(String[] args) {
        Trie208 trie = new Trie208();
        trie.insert("apple");
        System.out.println(trie.search("apple"));   // 返回 True
        System.out.println(trie.search("app"));     // 返回 False
        System.out.println(trie.startsWith("app")); // 返回 True
        trie.insert("app");
        System.out.println(trie.search("app"));
    }

    public void insert(String word) {
        TrieNode ws = trie;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (ws.childNodes[c - 'a'] == null) {
                ws.childNodes[c - 'a'] = new TrieNode(c);
            }
            ws = ws.childNodes[c - 'a'];
        }
        ws.endOfWord = true;
    }

    public boolean search(String word) {
        TrieNode ws = trie;
        for (int i = 0; i < word.length(); i++) {
            char c = word.charAt(i);
            if (ws.childNodes[c - 'a'] == null) {
                return false;
            }
            ws = ws.childNodes[c - 'a'];
        }
        return ws.endOfWord;
    }

    public boolean startsWith(String prefix) {
        TrieNode ws = trie;
        for (int i = 0; i < prefix.length(); i++) {
            char c = prefix.charAt(i);
            if (ws.childNodes[c - 'a'] == null) {
                return false;
            }
            ws = ws.childNodes[c - 'a'];
        }
        return true;
    }


    static class TrieNode {
        TrieNode[] childNodes;
        boolean endOfWord;
        char val;

        public TrieNode(char val) {
            this();
            this.val = val;
        }

        public TrieNode() {
            childNodes = new TrieNode[26];
            endOfWord = false;
        }
    }

}