I found a bug in the arrayToTree function, I tried to modify the logic of arrayToTree, but it didn't solve the problem, please help me！Here are the details:

• input

const arr = [1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15];

• wrong output

        /——— 7
       |    \——— 12
    /——— 3
   |    \——— 6
——— 1
    \——— 2
       |    /——— 9
        \——— 4
           |    /——— 15
            \——— 8

• The correct output should be

            /——— 15
        /——— 7
    /——— 3
   |    \——— 6
   |        \——— 12
——— 1
    \——— 2
       |    /——— 9
        \——— 4
            \——— 8

• The location of the arrayToTree function

hello-algo/codes/javascript/modules/TreeNode.js

• my question
  If you want to pass the above case, how to modify the logic of the arrayToTree function？

Firefox browser

Edge browser

Contributing Guideline

• Select a reference language: Python or Java are the preferred reference languages since their codebase has been thoroughly tested.
• Maintain code consistency: Align your code structure, naming conventions, and comments with those in the reference language to minimize discrepancies.
• Test the code: Ensure your code produces the same output as the reference code. Recommend utilizing tools like Diffchecker to compare the outputs.
• Format the code: Before opening the pull request, check your code formatting against existing chapters for consistent indentation, comment style, and naming conventions. Standard code formatting tools are recommended.
• PR examples:
  • #632
  • #681
  • #696

Code Reviewers

If you have extensive programming experience and are interested in reviewing code, please reach out via WeChat at krahets-jyd . We dedicate our thanks to all code reviewers on the landing page and of this project.

作者是否有考虑给本书制作一个英文翻译版本？我可以提供英文翻译。

浅谈一下读完本书的感想以及为什么需要一个英文版本：

本人是算法小白，之前接触过一些算法的知识，但是都是不系统的学习，要用到什么就学什么，导致整个知识体系非常零散。最近由于要开始准备一些面试和考试才开始系统性地学，之前选中这本书就是因为讲解通俗易懂而且内容简洁，篇幅普遍不长，对初学者非常友好。我大概花了不到一周就集中把整本书啃完了，收获良多，算法至少是入门了。这本书和我看过的别的材料最大的不同就是这本书给了我看完的勇气和毅力，之前从来没有认认真真地从头到尾看完过一本CS的书，大部分CS的书籍真的太臃肿且晦涩了，这本书真的是面向小白的最佳材料。

我正在国外某所学校学习CS，然而即使是国外大学所谓“先进”的CS教学，他们的算法课程也真的很烂，内容臃肿，重点不清，讲解混乱，从头到尾糊里糊涂地就混过去了（一学期下来的效果还不如我一周看完这本书），而和我一起上课的大部分外国学生也是学的云里雾里。当然国外也有和这本书类似的面向初学者的材料，但是这些材料通常都不开源且要收费，而国外教材费真的非常高昂，一套书的价格甚至可能和一部手机一样贵，网上的教程和材料也同样需要购买。所以我认为如果本书有一个英文版本的话真的会非常有意义（我认为本书可以参考李沐老师的d2l课程材料类似的模式）。

Now, our sorting chapter is mainly composed of three parts：

• 算法流程
• 算法特性
• 效率优化
  

I want to add a new category. It's called 小练习? 😁
e.g Bubble sort

小练习

• 283. 移动零
• 剑指 Offer 45. 把数组排成最小的数

We need your help translating the code to Rust.

Please check the contribution guidelines in #15.

• Computational Complexity @Loner1024
• • Performance Evaluation
• • Time Complexity
• • Space Complexity
• • Space Time Tradeoff
• Array And LinkedList
• • Array
• • LinkedList
• • List
• Stack And Queue
• • Stack
• • Queue
• • Deque
• Hashing
• • Hash Map
• • Hash Collision
• Tree
• • Binary Tree
• • Binary Tree Types
• • Binary Search Tree
• • AVL Tree
• Searching
• • Linear Search
• • Binary Search
• • Hash Search
• Sorting
• • Bubble Sort
• • Insertion Sort
• • Quick Sort
• • Merge Sort

You can comment on the tasks you want to receive below, and I will assign them to you.
Notice: please use "part of" not "resolves" or "fixes", or it will close this original issue

你可以在下面评论你想要收到的任务，我会把它们分配给你。
注意：请使用“part of”而不是“resolves”或“fixes”，否则将关闭此原始问题

Could you help us translate the code to JavaScript:

Please check the contribution guidelines at #15.

• Computational Complexity

• • Time Complexity #196(@RiverTwilight)
• • Space Complexity #331(@justin-tse)
• • Space Time Tradeoff #116(@gyt95) #780(@wenjianmin)

• Array And LinkedList

• • Array #34(@IsChristina) #95(@justin-tse)
• • LinkedList #93(@IsChristina) #95(@justin-tse)
• • List #93(@IsChristina) #95(@justin-tse)

• Stack And Queue

• • Stack @S-N-O-R-L-A-X #70(@S-N-O-R-L-A-X) #81(@S-N-O-R-L-A-X) #163(@S-N-O-R-L-A-X)
• • Queue @S-N-O-R-L-A-X #77(@S-N-O-R-L-A-X) #139(@S-N-O-R-L-A-X) #325(@justin-tse)
• • Deque #267(@zhuoqinyue)

• Hashing

• • Hash Map #174(@justin-tse)
• • Hash Collision #675(@yuan0221)
• • Hash Algorithm #675(@yuan0221)

• Tree

• • Binary Tree #71(@IsChristina) #104(@justin-tse) #179(@DullSword)
• • Binary Tree Types #71(@IsChristina) #104(@justin-tse)
• • Array Binary Tree #681(@yuan0221)
• • Binary Search Tree #71(@IsChristina) #104(@justin-tse)
• • AVL Tree #323(@what-is-me)

• Heap

• • Max Heap #339(@what-is-me)
• • Top K #686(@justin-tse)

• Graph

• • Graph Operations #355(@zhuoqinyue) #358(@justin-tse) #370(@zhuoqinyue)
• • Graph Traversal #377(@zhuoqinyue)

• Searching

• • Linear Search #157(@JoseHung)
• • Binary Search #157(@JoseHung) #236(@[JoseHung)
• • Binary Search Edge #545(@justin-tse)
• • Hash Search #187(@zhuoqinyue)

• Sorting

• • Selection Sort #545(@justin-tse)
• • Bubble Sort #57(@IsChristina) #257(@justin-tse)
• • Insertion Sort #57(@IsChristina) #257(@justin-tse)
• • Quick Sort #57(@IsChristina) #257(@justin-tse) #785(@reeswell)
• • Merge Sort #57(@IsChristina) #257(@justin-tse)
• • Heap Sort #545(@justin-tse)
• • Bucket Sort #451(@justin-tse)
• • Counting Sort #451(@justin-tse)
• • Radix Sort #451(@justin-tse)

• Divide and Conquer

• • Binary Search by Recursion #667(@yuan0221)
• • Build Tree #667(@yuan0221)
• • Hanota #667(@yuan0221)

• Backtracking

• • Preorder Traversal Compact #490(@justin-tse)
• • Permutations #494(@justin-tse)
• • Subset Sum #667(@yuan0221) #784(@justin-tse)
• • N Queens #494(@justin-tse)

https://github.com/krahets/hello-algo/blob/main/codes/cpp/chapter_hashing/hash_map_chaining.cpp#L94
The removal is done by creating a new object, and the original object pointer is not deleted.

chapter_sorting/merge_sort/

Your first book to learn Data Structure And Algorithm.

https://www.hello-algo.com/chapter_sorting/merge_sort/

Originally posted by @giscus in #61

hello , How to use this Git To deploy our website

If an argument of 0 is passed, all nodes of the tree will have the value 0. Should the parameter n be passed?

I need a coder for Android business.

关于此处char 的类型 在大多数语言中 是 char 可以看做是int8 所以 正常来说 符号是从 0-127表示的 ASICII码
而且是区分 unsigned 和 signed， 所以这里直接是2 bytes char 还有 默认是unsigned的 我是不认同的。

还有此处没有将原码 反码 补码的情况下， 我认为在计算机中存储的就是补码。默认的整数在不区分unsigned 和signed 的情况下我更倾向于signed int32数据类型，则补码表示的负数 会比 正数多一个。

https://github.com/krahets/hello-algo/blob/7ca27c3df1bfc981fc7faa4528dadb410457d221/docs/chapter_data_structure/data_and_memory.md?plain=1#LL36C4-L36C65

大佬你好，最近看您的书籍快速排序部分时，在一次循坏结束时，也就是这一步
swap(nums, i, left); // 将基准数交换至两子数组的分界线
这一步代码里面好像是直接的值交换，而不是把基准值放到左子数组跟右子数组的分界线处，图解部分也是直接做值交换的，但是会不会有可能基准值比被交换值要小的情况呢，如果是这样的话，直接交换就出问题了，我是自己用java写的发现这个问题，不知道c语言是不是这样，初学算法，希望大佬指出。

大陆电信网访问网站显示关闭连接，使用最新版Edge浏览器。如图所示：

There are some Go codes translated from Java codes, someone needs to help with adding them to docs.

Please feel free to drop your comments and expectations about this book to us.

方便离线观看或者修改章节后可以看看修改后的效果再提交代码
我通过以下命令成功的启动了本地服务

pip install mkdocs mkdocs-material
mkdir docs/overrides
mkdocs build
mkdocs serve

可以考虑提供Dockerfile或者现成的镜像

@krahets 您好，这本算法书里的插图画的很漂亮，但是是以静态的幻灯片的形式展示出来的。
您有没有考虑过在算法书中插入一些动画？这样在演示算法的运行过程会更加生动和直观。
如果您感兴趣的话，可以了解一下我最近在开发的一款基于 Python 的算法动画引擎 algviz Github 仓库

例如下面的动画都是用这款引擎渲染出来的：

• 冒泡排序算法:
  

• N 皇后问题:
  

• Prim 最小生成树算法:
  

更多算法可以直接点击下面的按钮在线运行体验一波，所有的动画都会根据您的输入以及算法的运行实时渲染：

期待您的回复！

我试着贡献一点代码，但尝试参与遇到的问题，

1：Docker渲染下网页代码部分无法渲染，只是出现

[class]{}-[func]{randomAccess}

2：使用对应版本的mkdocs等，发现所有的网页都是404
`pip install --upgrade pip
pip install mkdocs-material==9.0.13
mkdocs serve

INFO - [11:42:16] Watching paths for changes: 'build', 'mkdocs.yml'
INFO - [11:42:16] Serving on http://127.0.0.1:8000/
WARNING - [11:42:18] "GET / HTTP/1.1" code 404
WARNING - [11:42:18] "GET /stylesheets/extra.css HTTP/1.1" code 404
WARNING - [11:42:18] "GET /assets/images/logo.png HTTP/1.1" code 404
WARNING - [11:42:19] "GET /javascripts/mathjax.js HTTP/1.1" code 404
`

/codes/python/include/binary_tree.py 中的list_to_tree(arr)用的时候会报list index out of range

本问题发现于 C 和 C++ 中，其他语言不了解，不清楚有没有问题。

C 和 C++ 从来没有规定 byte, char short, int, long 等的具体大小，而只要求了一个大小范围，也没有要求 1 byte == 8 bits，如果不指明这一点，可能给不了解的读者带来错误印象：我在交流中已发现有人因为这样的错误印象（不一定是由本书造成的）而犯错。

TL;DR 建议做一下补充以下两点：

• 指出在部分语言标准（如 C、C++）中，这些类型没有固定的大小，而因实现、平台而异。
• 指明所使用的 data model 为 LP64，这能与目前的表格对应。

byte:

C: — addressable unit of data storage large enough to hold any member of the basic character set of the
execution environment. 3.6

C++: A byte is at least large enough to contain the ordinary literal encoding of any element of the basic literal character set and the eight-bit code units of the Unicode UTF-8 encoding form and is composed of a contiguous sequence of bits, the number of which is implementation-defined. ... Every byte has a unique address. [intro.memory]/1

可见并没有要求 1 byte == 8bits。

以下仅查找 C++ 标准，C 标准查起来太麻烦了，但根据 cppreference 是差不多的。

char:

char 是字符类型，而 signed char 和 unsigned char 是与它不同的类型，char 所使用的内置类型是 signed char 还是 unsigned char 由实现决定。

narrow character type: The three types char, signed char, and unsigned char are collectively called ordinary character types. The ordinary character types and char8_t are collectively called narrow character types. [basic.fundamentals]/7

sizeof 返回什么: The sizeof operator yields the number of bytes occupied by a non-potentially-overlapping object of the type of its operand. [expr.sizeof]/1

sizeof(narrow character type): The result of sizeof applied to any of the narrow character types is 1. [expr.sizeof]/1

因此 sizeof(char) == 1，即 C++ 中 char 的大小为 1 byte。

其他文中提及的类型:

• minimum_bits(signed char) == 8, minimum_bits(short int) == 16, minimum_bits(int) == 16, minimum_bits(long int) == 32.
• 1 == sizeof(char) ≤ sizeof(short) ≤ sizeof(int) ≤ sizeof(long) ≤ sizeof(long long).

Translating codes from Java to Golang.

`
java title="bubble_sort.java"

[class]{bubble_sort}-[func]{bubbleSort}
`

I can not render it correctly in my local environment and the docker

PC端： 评论模块异常

手机端（安卓）： 评论正常显示

AsciiDoc适合出版,语法比MarkDown要丰富

目前为止所有文章的评论都显示为json

老哥 java的循环队列 写错了，rear不能等于front。

随着支持的语言越来越多，正文在多人协作时可能会遇到先后顺序导致的合并冲突。依据本书把 Java 语言作为范本的共识，建议按照 Java / C / C++ / C# / Go / JavaScript / Python / Swift / TypeScript / Zig 进行排序，确保首选语言不出现空白和减少合并冲突。

注：除 Java 外，其余语言顺序来自 codes 文件夹在 GitHub 中的展示顺序。

在使用邻接表添加边这里有问题， 如果边已经存在那么他还是会添加进去

 /* 添加边 */
    public void addEdge(Vertex vet1, Vertex vet2) {
        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
            throw new IllegalArgumentException();
        // 添加边 vet1 - vet2
        adjList.get(vet1).add(vet2);
        adjList.get(vet2).add(vet1);
    }

我做的修改是

    public void addEdge(Vertex vet1, Vertex vet2) {
        if (!adjList.containsKey(vet1) || !adjList.containsKey(vet2) || vet1 == vet2)
            throw new IllegalArgumentException();
        // 添加边 vet1 - vet2
        if (!adjList.get(vet1).contains(vet2)){
            adjList.get(vet1).add(vet2);
        }   
        if (!adjList.get(vet2).contains(vet1)){
            adjList.get(vet2).add(vet1);
        }
        
        
    }

I used google translate to view the book's contents and found it helpful. But the problem is that google translate is limited to the translation of text only not images, so it is tough for me to understand the code.

如下截图中红色框选部分所示：

这会给第一次使用网站的人以一种不好的体验，好像这个网站已经没有人维护了一样

Icons not loaded on the homepage of the website affect the aesthetics and use experience

```
""" 线性对数阶 """
def linear_log_recur(n):
    if n <= 1: return 1
    count = linear_log_recur(n // 2) + \
            linear_log_recur(n // 2)
    for _ in range(n):
        count += 1
    return count
```

• 当n为浮点数时，for循环报错

TypeError: 'float' object cannot be interpreted as an integer

• 我更改了一版，麻烦看一下可以不,可以的话我提交pr

""" 线性对数阶 """
def linear_log_recur(n):
    if n <= 1: return 1
    count = linear_log_recur(n / 2) + \
            linear_log_recur(n / 2)
    i = 0
    while i < n:
        count += 1
        i += 1
    return count

原文：

单向链表：即上述介绍的普通链表。单向链表的节点包含值和指向下一节点的引用两项数据。我们将首个节点称为头节点，将最后一个节点成为尾节点，尾节点指向空 None。

应该是：将最后一个节点称为（而不是 “成为”）尾节点，尾节点指向空 None。

1. 将目录结构重构为横版
2. 将栈队列，数据结构，哈希等内容合并为数据结构一览
3. 重构文件夹

We need your help translating the code to C.

Please check the contribution guidelines at #15

TODO List

• Computational Complexity

• • Time Complexity #204 (@sjinzh)
• • Space Complexity #456 (@Gonglja )
• • Space Time Tradeoff #299 (@Reanon)

• Array And LinkedList

• • Array #154 (@MolDuM)
• • LinkedList #244 (@Gonglja)
• • List #253 (@Gonglja)

• Stack And Queue

• • Stack #289 #299 (@Gonglja , @Reanon , @krahets )
• • Queue #300 #413 (@Gonglja , @krahets )
• • Deque #412 (@Gonglja)

• Hashing

• • Hash Map #424 (@Guanngxu )
• • Hash Collision
• • Hash Algorithm #730 (@Gonglja )

• Tree

• • Binary Tree #234 (@Reanon)
• • Binary Tree Types
• • Array Binary Tree #664 (@Gonglja )
• • Binary Search Tree #234 (@Reanon)
• • AVL Tree #260 (@Reanon)

• Heap

• • Max Heap #261 (@Reanon )
• • Top K

• Graph

• • Graph Operations
• • Graph Traversal #601 (@NI-SW )

• Searching

• • Linear Search #426 (@Guanngxu )
• • Binary Search #426 (@Guanngxu )
• • Hash Search #458 (Gonglja)

• Sorting

• • Selection Sort
• • Bubble Sort #166 (@L-Super )
• • Insertion Sort #191 (@L-Super )
• • Quick Sort #273 (@Reanon )
• • Merge Sort #434 (@Guanngxu )
• • Heap Sort
• • Bucket Sort
• • Counting Sort #430 (@Reanon @Guanngxu )
• • Radix Sort #273 (@Reanon )

• Divide and Conquer

• • Binary Search by Recursion
• • Build Tree
• • Hanota

• Backtracking

• • Preorder Traversal Compact
• • Permutations
• • Subset Sum
• • N Queens

halo, K神，双端队列没有做基于数组和双向链表的代码实现，栈和队列都是有这一部分的，双端队列的实现我能帮忙写一下吗？

#![image](https://user-images.githubusercontent.com/121067515/216835735-6b60f6be-2b93-4a26-a638-647dc3b52b46.jpeg

个人认为基数排序是一种区别于其他排序的典型的、具有鲜明特色的排序方法，可以考虑将其加入

Could you help us translate the code to TypeScript:

Please check the contribution guidelines at #15.

• Computational Complexity

• • Time Complexity #196(@RiverTwilight)
• • Space Complexity #331(@justin-tse)
• • Space Time Tradeoff #118(@gyt95) #780(@wenjianmin)

• Array And LinkedList

• • Array #73(@justin-tse) #88(@justin-tse)
• • LinkedList #88(@justin-tse) #95(@justin-tse)
• • List #88(@justin-tse)

• Stack And Queue

• • Stack @S-N-O-R-L-A-X #70(@S-N-O-R-L-A-X) #81(@S-N-O-R-L-A-X) #163(@S-N-O-R-L-A-X)
• • Queue @S-N-O-R-L-A-X #77(@S-N-O-R-L-A-X) #139(@S-N-O-R-L-A-X) #325(@justin-tse)
• • Deque #267(@zhuoqinyue)

• Hashing

• • Hash Map #136(@danielsss)
• • Hash Collision #675(@yuan0221)
• • Hash Algorithm #675(@yuan0221)

• Tree

• • Binary Tree #113(@justin-tse) #180(@DullSword)
• • Binary Tree Types #113(@justin-tse)
• • Array Binary Tree #681(@yuan0221)
• • Binary Search Tree #113(@justin-tse)
• • AVL Tree #342(@justin-tse)

• Heap

• • Max Heap #349(@justin-tse)
• • Top K #686(@justin-tse)

• Graph

• • Graph Operations #355(@zhuoqinyue) #358(@justin-tse) #370(@zhuoqinyue)
• • Graph Traversal #377(@zhuoqinyue)

• Searching

• • Linear Search #216(@danielsss)
• • Binary Search #177(@danielsss)
• • Binary Search Edge #545(@justin-tse)
• • Hash Search #187(@zhuoqinyue)

• Sorting

• • Selection Sort #545(@justin-tse)
• • Bubble Sort #98(@justin-tse)
• • Insertion Sort #98(@justin-tse)
• • Quick Sort #98(@justin-tse) #785(@reeswell)
• • Merge Sort #98(@justin-tse) #257(@justin-tse)
• • Heap Sort #545(@justin-tse)
• • Bucket Sort #451(@justin-tse)
• • Counting Sort #451(@justin-tse)
• • Radix Sort #451(@justin-tse)

• Divide and Conquer

• • Binary Search by Recursion #667(@yuan0221)
• • Build Tree #667(@yuan0221)
• • Hanota #667(@yuan0221)

• Backtracking

• • Preorder Traversal Compact #490(@justin-tse)
• • Permutations #494(@justin-tse)
• • Subset Sum #667(@yuan0221) #784(@justin-tse)
• • N Queens #494(@justin-tse)

• Run TestGraphAdjList in graph_adjacency_list_test.go, you will get following result:

=== RUN TestGraphAdjList
初始化后，图为:
邻接表 =
1: 3 5
3: 1 2
5: 1 2 4
2: 3 5 4
4: 2 5

添加边 1-2 后，图为
邻接表 =
1: 3 5 2
3: 1 2
5: 1 2 4
2: 3 5 4 1
4: 2 5

删除边 1-3 后，图为
邻接表 =
1: 3 5 2 # 异常点： 3 应该被移除
3: 1 2 # 异常点：1 应该被移除
5: 1 2 4
2: 3 5 4 1
4: 2 5

添加顶点 6 后，图为
邻接表 =
2: 3 5 4 1
4: 2 5
6:
1: 3 5 2
3: 1 2
5: 1 2 4

删除顶点 3 后，图为
邻接表 =
4: 2 5
6:
1: 3 5 2 # 3 应该被移除
5: 1 2 4
2: 3 5 4 1 # 3 应该被移除

• 暂时未查看其他语言的实现是否存在同样的问题。

I think the binary search in Rust could be written like this:

pub fn binary_search(nums: &[i32], target: i32) -> Option<usize> {
        let mut low = 0;
        let mut high = nums.len();
        while low < high {
            let mid = (high - low) / 2 + low;
            match target.cmp(&nums[mid]) {
                std::cmp::Ordering::Equal => return Some(mid),
                std::cmp::Ordering::Less => high = mid,
                std::cmp::Ordering::Greater => low = mid + 1,
            }
        }
        None
}

This is more in line with Rust's language features， maybe

We need your help translating the code to Go.

Please check the contribution guidelines at #15

TODO List

• Computational Complexity
• • Time Complexity #99 (@msk397)
• • Space Complexity #119 (@Cathay-Chen)
• • Space Time Tradeoff #102 (@Cathay-Chen)
• • Leetcode Two Sum #8 (@Reanon)
• Array And LinkedList
• • Array #178 (@guowei-gong)
• • LinkedList #188 (@Cathay-Chen)
• • List #128 (@msk397)
• Stack And Queue
• • Stack #45 (@Reanon)
• • Queue #45 (@Reanon)
• • Deque #45 (@Reanon)
• Hashing
• • Hash Map #110 (@msk397)
• • Hash Collision
• Tree
• • Binary Tree #20 (@Reanon)
• • Binary Tree Types #29 (@Reanon)
• • Binary Search Tree #29 (@Reanon)
• • AVL Tree #224 (@Reanon)
• Heap
• • Max Heap #246 (@Reanon)
• Searching
• • Linear Search #20 (@Reanon)
• • Binary Search #76 (@Slone123c )
• • Hash Search #96 (@Slone123c)
• Sorting
• • Bubble Sort #80 (@Slone123c)
• • Insertion Sort #92 (@msk397)
• • Quick Sort #94 (@msk397 )
• • Merge Sort #99 (@msk397 )
• Basic Pkg
• • List Node #20 (@Reanon)
• • Tree Node #20 (@Reanon)
• • Print Utils #20 (@Reanon @krahets)

Commit Guidelines

1、Format of the commit message
Refer to AngularJS Git Commit Message Conventions

<type>(<scope>): <subject>

Allowed <type>

• feat: feature, complete a part of the code.
• test: testcase.
• fix: fix some bugs.
• docs: documentation, complete a part of the doc.
• style: formatting, …

Allowed <scope>

• chapter_name/module_name

For example, if you complete the go code of linkedlist_queue in chapter_stack_and_queue, the commit message should be like：

feat(stack_and_queue/linkedlist_queue): add go code.

2、What one commit contains
If you complete two module code, testcase and docs, you commit log should be like:

docs(tree/binary_tree_bfs): add go code.
docs(stack_and_queue): add go code.
feat(stack_and_queue/linkedlist_queue): add go code and testcases.
test(tree/binary_tree_bfs): add go testcases.
feat(tree/binary_tree_bfs): add go code.

If you fix a bug, the commit log should be like :

docs(searching/linear_search): modify go code.
fix(searching/linear_search): fix go code.

Code Style

1、All code should be error-free when run through gofmt and go test.
2、Consistent with existing go code style.
3、Refer to uber/go-style.