Polish the chapter of graph, hashing, appendix

codes/dart/chapter_stack_and_queue/linkedlist_stack.dart

@@ -8,7 +8,7 @@ import '../utils/list_node.dart';
 
 /* 基于链表类实现的栈 */
 class LinkedListStack {
-  ListNode? _stackPeek; // 将头节点作为栈顶
+  ListNode? _stackPeek; // 将头结点作为栈顶
   int _stkSize = 0; // 栈的长度
 
   LinkedListStack() {

codes/dart/chapter_tree/binary_search_tree.dart

@@ -15,7 +15,7 @@ void binarySearchTree(List<int> nums) {
   root = buildTree(nums, 0, nums.length - 1); // 构建二叉搜索树
 }
 
-/* 获取二叉树的根节点 */
+/* 获取二叉树的根结点 */
 TreeNode? getRoot() {
   return root;
 }
@@ -146,7 +146,7 @@ void main() {
 
   /* 插入结点 */
   node = insert(16);
-  print("\n插入节点 16 后，二叉树为\n");
+  print("\n插入结点 16 后，二叉树为\n");
   printTree(getRoot());
 
   /* 删除结点 */

codes/dart/chapter_tree/binary_tree.dart

@@ -25,7 +25,7 @@ void main() {
 
   /* 插入与删除结点 */
   TreeNode p = TreeNode(0);
-  // 在 n1 -> n2 中间插入节点 p
+  // 在 n1 -> n2 中间插入结点 p
   n1.left = p;
   p.left = n2;
   print("\n插入结点 P 后\n");

codes/dart/chapter_tree/binary_tree_bfs.dart

@@ -10,7 +10,7 @@ import '../utils/tree_node.dart';
 
 /* 层序遍历 */
 List<int> levelOrder(TreeNode? root) {
-  // 初始化队列，加入根节点
+  // 初始化队列，加入根结点
   Queue<TreeNode?> queue = Queue();
   queue.add(root);
   // 初始化一个列表，用于保存遍历序列
@@ -18,8 +18,8 @@ List<int> levelOrder(TreeNode? root) {
   while (queue.isNotEmpty) {
     TreeNode? node = queue.removeFirst(); // 队列出队
     res.add(node!.val); // 保存结点值
-    if (node.left != null) queue.add(node.left); // 左子节点入队
-    if (node.right != null) queue.add(node.right); // 右子节点入队
+    if (node.left != null) queue.add(node.left); // 左子结点入队
+    if (node.right != null) queue.add(node.right); // 右子结点入队
   }
   return res;
 }

codes/dart/chapter_tree/binary_tree_dfs.dart

@@ -13,7 +13,7 @@ List<int> list = [];
 /* 前序遍历 */
 void preOrder(TreeNode? node) {
   if (node == null) return;
-  // 访问优先级：根节点 -> 左子树 -> 右子树
+  // 访问优先级：根结点 -> 左子树 -> 右子树
   list.add(node.val);
   preOrder(node.left);
   preOrder(node.right);
@@ -22,7 +22,7 @@ void preOrder(TreeNode? node) {
 /* 中序遍历 */
 void inOrder(TreeNode? node) {
   if (node == null) return;
-  // 访问优先级：左子树 -> 根节点 -> 右子树
+  // 访问优先级：左子树 -> 根结点 -> 右子树
   inOrder(node.left);
   list.add(node.val);
   inOrder(node.right);
@@ -31,7 +31,7 @@ void inOrder(TreeNode? node) {
 /* 后序遍历 */
 void postOrder(TreeNode? node) {
   if (node == null) return;
-  // 访问优先级：左子树 -> 右子树 -> 根节点
+  // 访问优先级：左子树 -> 右子树 -> 根结点
   postOrder(node.left);
   postOrder(node.right);
   list.add(node.val);

codes/rust/chapter_tree/binary_tree.rs

@@ -24,7 +24,7 @@ fn main() {
     println!("\n初始化二叉树\n");
     print_util::print_tree(&n1);
 
-    // 插入节点与删除节点
+    // 插入结点与删除结点
     let p = TreeNode::new(0);
     // 在 n1 -> n2 中间插入结点 P
     p.borrow_mut().left = Some(Rc::clone(&n2));