feat: translation for binary-tree-traversal.md (azl397985856#106)

Author: StoneLyu

README.en.md

@@ -4,6 +4,13 @@
 
 ---
 
+![leetcode.jpeg](./assets/leetcode.jpeg)
+
+This essay records the course of and my emotion to this project from initialisation to 10,000 stars.
+[Milestone for 10,000+ stars](./thanksGiving.md)
+
+If you are interested in this project, do not mean your star. This project will be supported for a long enough time by the comminity. Thanks for every audience and contributor.
+
 ## Introduction
 
 ![leetcode.jpeg](./assets/leetcode.jpeg)
@@ -24,7 +31,13 @@ This repository is divided into five parts for now:
 
 > Only when having mastered the basic data structures and algorithms can you solve complex problems easily.
 
+## About me
+
+I, a programmer, am all passionate about technology.
+
+Used to write `.net` and `Java`, I am a frontend engineer and focused on the engineering, optimization and standardlization for frontend.
 
+If you want to do some contributions or collaborations, just feel free to contact me via [[email protected]].
 
 ## Usage Instructions
 
@@ -218,7 +231,7 @@ The data structures mainly includes:
 
 - [Data Structure](./thinkings/basic-data-structure-en.md) (Drafts)
 - [Basic Algorithm](./thinkings/basic-algorithm.md)Drafts
-- [Binary Tree Traversal](./thinkings/binary-tree-traversal.md)
+- [Binary Tree Traversal](./thinkings/binary-tree-traversal-en.md)
 - [Dynamic Programming](./thinkings/dynamic-programming-en.md)
 - [Huffman Encode and Run Length Encode](./thinkings/run-length-encode-and-huffman-encode.md)
 - [Bloom Filter](./thinkings/bloom-filter.md)

problems/301.remove-invalid-parentheses.md

@@ -38,7 +38,7 @@ Output: [""]
 
 ## 关键点解析
 
-- 广度有限遍历
+- 广度优先遍历
 
 - 使用队列简化操作
 

thinkings/binary-tree-traversal-en.md

@@ -0,0 +1,115 @@
+# Binary Tree Traversal
+
+## Overview
+
+Binary tree is a fundamental data structure. Traversal is a fundamental algorithm. Implementing traversal on binary tree makes a classical solution to problems. Many problems can be solved by trversaling binary tree, directly or indirectly.
+
+> If you have a good understanding of binary tree, it is not hard for you to understand other trees more complicated.
+
+The traversal of binary tree is basically comprised of in-order, pre-order, post-order and level-order traversals.
+
+A tree is typically traversed in two ways:
+
+- BFS (Breadth First Search, or Level Order Search)
+- DFS (Depth First Search)
+    - In-order (Left-Root-Right)
+    - Pre-order (Root-Left-Right)
+    - Post-order (Left-Right-Root)
+
+Some problems can be solved with BFS and DFS, such as [301](../problems\301.remove-invalid-parentheses.md) and [609](../problems\609.find-duplicate-file-in-system.md)
+
+DFS simplifies operations with stack. Meanwhile, a tree is a recursive data structure. It is important to grasp recursion and stack for understanding DFS.
+
+Diagrammatic graph of DFS：
+
+![binary-tree-traversal-dfs](../assets/thinkings/binary-tree-traversal-dfs.gif)
+
+(source: https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/depth-first-search)
+
+The key point of BFS is whether the travesals of each level are completed or not. An identifier bit can be used to represent that.
+
+Then, let's talk about the in-order, pre-oder and post-order traversals.
+
+## Pre-order
+
+example: [144.binary-tree-preorder-traversal](../problems/144.binary-tree-preorder-traversal.md)
+
+order of traversal: `root-left-right`
+
+Algorithm Preorder(tree):
+
+1. visit the root.
+
+2. traverse the left subtree, i.e., call Preorder(left-subtree)
+
+3. traverse the right subtree, i.e., call Preorder(right-subtree)
+
+Summary:
+
+- typically recursive data structure.
+- typycally algorithm which simplifies operations by stack.
+
+Actually, at the macro level, it can be described as `visit all left-side chain in sequence from top to bottom, and then, visit all right-side chain from bottom to top`
+
+If we think from this point of view, the algorithm can be different. All nodes in the left-side chain can be visited recursively from top to bottom directly. And all nodes in the right-side chain can be visited with the help of stack.
+
+The whole process is like this:
+
+![binary-tree-traversal-preorder](../assets/thinkings/binary-tree-traversal-preorder.png)
+
+This idea is something like the `backtrack`. It is important, because this idea can help us to `unify the understanding of three traversal methods`.
+
+## In-order
+
+example: [94.binary-tree-inorder-traversal](../problems/94.binary-tree-inorder-traversal.md)
+
+Order of In-order traversal: `Left-Root-Right`
+
+Algorithm Inorder(tree):
+
+1. Traverse the left subtree, i.e., call Inorder(left-subtree)
+
+2. Visit the root
+
+3. Traverse the right subtree, i.e., call Inorder(right-subtree)
+
+It is worth noting that, the result of traversing a BST (Binary Search Tree) is an ordered array. With this property, some problems can be simplified, such as: [230.kth-smallest-element-in-a-bst](../problems/230.kth-smallest-element-in-a-bst.md) and [98.validate-binary-search-tree](../problems/98.validate-binary-search-tree.md)
+
+## Post-order
+
+example: [145.binary-tree-postorder-traversal](../problems/145.binary-tree-postorder-traversal.md)
+
+Order of Post-order: `Left-Right-Root`
+
+This one is a liitle difficult to understand.
+
+But there is a clever trick to post-order traversal which is recording the trversal status of current node.
+If
+
+1. current node is leaf node or
+2. both left and right subtrees have been traversed
+
+the node can be popped out the stack.
+
+For condition 1, a leaf node is the node with no children (both left and right children are null);
+For condition 2, variables are required for recording the traversal status for each node. Due to the stack,  only one variable is indispensable bacause this variable can be used.
+
+## Level-order
+
+The key point of level-order is recording the traversal status of each level. An identifier bit can be used to represent the status of current level.
+
+![binary-tree-traversal-bfs](../assets/thinkings/binary-tree-traversal-bfs.gif)
+
+(source: https://github.com/trekhleb/javascript-algorithms/tree/master/src/algorithms/tree/breadth-first-search)
+
+Algorithm Level-order(tree):
+
+1. push root into a queue. And put an identifier node into the queue which is null here.
+
+2. pop out one node from the queue.
+
+3. If the popped out node is not null, which means the traversal of current level is not finished, push the left and right node into the queue orderly.
+
+4. If the popped out node is null, which means the traversal of current level is finished. Now if the queue is null, the traversal is done. If the queue is not null, push a null node into the queue.
+
+example: [102.binary-tree-level-order-traversal](../problems/102.binary-tree-level-order-traversal.md)

thinkings/run-length-encode-and-huffman-encode.md

@@ -1,75 +1,75 @@
-## 游程编码和哈夫曼编码
+# 游程编码和哈夫曼编码
 
-### huffman encode(哈夫曼编码)
+## Huffman encode(哈夫曼编码)
 
-huffman 编码的基本思想就是用短的编码表示长的字符序列，用长的编码来表示短的字符序列，从而实现压缩的目的。
-因此huffman编码被广泛地应用于无损压缩领域。
+Huffman 编码的基本思想就是用短的编码表示出现频率高的字符，用长的编码来表示出现频率低的字符，这使得编码之后的字符串的平均长度、长度的期望值降低，从而实现压缩的目的。
+因此 Huffman 编码被广泛地应用于无损压缩领域。
 
-上面提到了他的基本原理就是`用短的编码表示长的字符序列，用长的编码来表示短的字符序列`,
-因此首先要做的就是统一字符序列的出现频率，然后根据统计的频率来构建huffman树（又叫最优二叉树）。
+Huffman 编码的过程包含两个主要部分：
 
-![huffman-tree](../assets/thinkings/huffman-tree.webp)
+- 根据输入字符构建 Huffman 树
+- 遍历 Huffman 树，并将树的节点分配给字符
 
-huffman 树就像是一个堆。  真正执行编码的时候，类似字典树，节点不用来编码，节点的路径用来编码
+上面提到了他的基本原理就是`用短的编码表示出现频率高的字符，用长的编码来表示出现频率低的字符`,
+因此首先要做的就是统计字符的出现频率，然后根据统计的频率来构建 Huffman 树（又叫最优二叉树）。
 
-> 节点的值只是用来构建huffman 树
+![Huffman-tree](../assets/thinkings/huffman-tree.webp)
+
+Huffman 树就像是一个堆。真正执行编码的时候，类似字典树，节点不用来编码，节点的路径用来编码.
+
+> 节点的值只是用来构建 Huffman 树
 
 eg:
 
 我们统计的结果如下：
 
-```
-character   frequency
-    a           5
-    b           9
-    c           12
-    d           13
-    e           16
-    f           45
-
-```
+|character|frequency|
+|:--:|:--:|
+|a|5|
+|b|9|
+|c|12|
+|d|13|
+|e|16|
+|f|45|
 
 - 将每个元素构造成一个节点，即只有一个元素的树。并构建一个最小堆，包含所有的节点，该算法用了最小堆来作为优先队列。
 
-- `选取两个权值最小的节点`，并添加一个权值为5+9=14的节点，作为他们的父节点。并`更新最小堆`，
-现在最小堆包含5个节点，其中4个树还是原来的节点，权值为5和9的节点合并为一个。 
+- `选取两个权值最小的节点`，并添加一个权值为5+9=14的节点，作为他们的父节点。并`更新最小堆`，现在最小堆包含5个节点，其中4个树还是原来的节点，权值为5和9的节点合并为一个。
 
 结果是这样的：
 
 ![huffman-example](../assets/thinkings/huffman-example.png)
 
-```
-character   frequency   encodeing
-    a           5         1100
-    b           9         1110
-    c           12        100
-    d           13        101
-    e           16        111
-    f           45         0
-
-```
+|character|frequency|encoding|
+|:-:|:-:|:-:|
+|a|5|1100|
+|b|9|1110|
+|c|12|100|
+|d|13|101|
+|e|16|111|
+|f|45|0|
 
+## run-length encode(游程编码)
 
-### run-length encode(游程编码)
 游程编码是一种比较简单的压缩算法，其基本思想是将重复且连续出现多次的字符使用（连续出现次数，某个字符）来描述。
 
 比如一个字符串：
 
-```
+```text
 AAAAABBBBCCC
 ```
+
 使用游程编码可以将其描述为：
 
-```
+```text
 5A4B3C
 ```
-5A表示这个地方有5个连续的A，同理4B表示有4个连续的B，3C表示有3个连续的C，其它情况以此类推。
 
+5A表示这个地方有5个连续的A，同理4B表示有4个连续的B，3C表示有3个连续的C，其它情况以此类推。
 
-但是实际上情况可能会非常复杂， 如何提取自序列有时候没有看的那么简单，还是上面的例子，我们
+但是实际上情况可能会非常复杂， 如何提取子序列有时候没有看的那么简单，还是上面的例子，我们
 有时候可以把`AAAAABBBBCCC`整体看成一个子序列， 更复杂的情况还有很多，这里不做扩展。
 
-
 对文件进行压缩比较适合的情况是文件内的二进制有大量的连续重复，
 一个经典的例子就是具有大面积色块的BMP图像，BMP因为没有压缩，
 所以看到的是什么样子存储的时候二进制就是什么样子
@@ -79,10 +79,10 @@ AAAAABBBBCCC
 > 思考一个问题， 如果我们在CDN上存储两个图片，这两个图片几乎完全一样，我们是否可以进行优化呢？
 这虽然是CDN厂商更应该关心的问题，但是这个问题对我们影响依然很大，值得思考
 
-### 总结
+## 总结
 
-实际情况，我们先用游程编码一遍，然后再用huffman 再次编码一次。
+实际情况，我们先用游程编码一遍，然后再用 Huffman 再次编码一次。
 
-### 相关题目
+## 相关题目
 
 [900.rle-iterator](../problems/900.rle-iterator.md)