数据结构章节更新

Author: Librazy

data-structure/binary_tree.md

@@ -3,54 +3,66 @@
 ## 二叉树简介
 在计算机科学中，二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree）和“右子树”（right subtree）。二叉树常被用于实现二叉查找树和二叉堆。
 
-1. 二叉树**左节点的值通常少于父亲节点的值**。
-2. 二叉树**右节点的值通常大于父亲节点的值**。
+>二叉查找树的子节点与父节点的键一般满足一定的顺序关系，习惯上，左节点的键少于父亲节点的键，右节点的键大于父亲节点的键。
+
+>二叉堆是一种特殊的堆，二叉堆是完全二元树（二叉树）或者是近似完全二元树（二叉树）。二叉堆有两种：最大堆和最小堆。最大堆：父结点的键总是大于或等于任何一个子节点的键；最小堆：父结点的键总是小于或等于任何一个子节点的键。
 
 >二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n_0，度为2的结点数为n_2，则n_0=n_2+1。
 
 >一棵深度为k，且有2^k-1个节点称之为满二叉树；深度为k，有n个节点的二叉树，当且仅当其每一个节点都与深度为k的满二叉树中，序号为1至n的节点对应时，称之为完全二叉树。
 
 ## 二叉树与树的区别
-二叉树不是树的一种特殊情形，尽管其与树有许多相似之处，但树和二叉树有两个主要差别：
+二叉树*不是*树的一种特殊情形，尽管其与树有许多相似之处，但树和二叉树有两个主要差别：
 
 1. 树中结点的最大度数没有限制，而二叉树结点的最大度数为2。
 2. 树的结点无左、右之分，而二叉树的结点有左、右之分。
 
 ## 定义二叉树的结构
+二叉树的每个节点由键key、值value与左右子树left/right组成，这里我们把节点声明为一个泛型结构。
 ```rust
-type TreeNode = Option<Box<Node>>;
-type BinaryTree = Node;
-
+type TreeNode<K,V> = Option<Box<Node<K,V>>>;
 #[derive(Debug)]
-struct Node {
-   left: TreeNode,
-   right: TreeNode,
-   value: i32,
+struct Node<K,V: std::fmt::Display> {
+   left: TreeNode<K,V>,
+   right: TreeNode<K,V>,
+   key: K,
+   value: V,
 }
 ```
-## 实现二叉树的插入和初始化
+## 实现二叉树的初始化与二叉查找树的插入
+由于二叉查找树要求键可排序，我们要求K实现PartialOrd
 ```rust
-impl Node {
-    fn new(value: i32) -> Self {
-        Node {
+trait BinaryTree<K,V> {
+	fn pre_order(&self);
+	fn in_order(&self);
+	fn pos_order(&self);
+}
+trait BinarySearchTree<K:PartialOrd,V>:BinaryTree<K,V> {
+	fn insert(&mut self, key:K,value: V);
+}
+impl<K,V:std::fmt::Display> Node<K,V> {
+    fn new(key: K,value: V) -> Self {
+        Node{
             left: None,
             right: None,
             value: value,
+			key: key,
         }
     }
-
-    fn insert(&mut self, value: i32) {
-        if self.value < value {
+}
+impl<K:PartialOrd,V:std::fmt::Display> BinarySearchTree<K,V> for Node<K,V>{
+    fn insert(&mut self, key:K,value:V) {
+        if self.key < key {
             if let Some(ref mut right) = self.right {
-                right.insert(value);
+                right.insert(key,value);
             } else {
-                self.right = Some(Box::new(Node::new(value)));
+                self.right = Some(Box::new(Node::new(key,value)));
             }
         } else {
             if let Some(ref mut left) = self.left {
-                left.insert(value);
+                left.insert(key,value);
             } else {
-                self.left = Some(Box::new(Node::new(value)));
+                self.left = Some(Box::new(Node::new(key,value)));
             }
         }
     }
@@ -64,7 +76,7 @@ impl Node {
 
 下面是代码实现：
 ```rust
-impl Node {
+impl<K,V:std::fmt::Display> BinaryTree<K,V> for Node<K,V> {
     fn pre_order(&self) {
         println!("{}", self.value);
 
@@ -98,19 +110,21 @@ impl Node {
 ```
 ## 测试代码
 ```rust
+type BST<K,V> = Node<K,V>;
+
 fn test_insert() {
-    let mut root = BinaryTree::new(3);
-    root.insert(2);
-    root.insert(4);
-    root.insert(5);
-    root.insert(6);
-    root.insert(1);
+    let mut root = BST::<i32,i32>::new(3,4);
+    root.insert(2,3);
+    root.insert(4,6);
+    root.insert(5,5);
+    root.insert(6,6);
+    root.insert(1,8);
     if let Some(ref left) = root.left {
-        assert_eq!(left.value, 2);
+        assert_eq!(left.value, 3);
     }
 
     if let Some(ref right) = root.right {
-        assert_eq!(right.value, 4);
+        assert_eq!(right.value, 6);
         if let Some(ref right) = right.right {
             assert_eq!(right.value, 5);
         }
@@ -119,7 +133,6 @@ fn test_insert() {
     root.pre_order();
     println!("In Order traversal");
     root.in_order();
-    println!("\n");
     println!("Pos Order traversal");
     root.pos_order();
 }
@@ -131,5 +144,3 @@ fn main() {
 
 ## 练习
 基于以上代码，修改成二叉堆的形式。
-
->二叉堆是一种特殊的堆，二叉堆是完全二元树（二叉树）或者是近似完全二元树（二叉树）。二叉堆有两种：最大堆和最小堆。最大堆：父结点的键值总是大于或等于任何一个子节点的键值；最小堆：父结点的键值总是小于或等于任何一个子节点的键值。

data-structure/linked_list.md

@@ -1,9 +1,9 @@
 # 链表
 
 ## 链表简介
-链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。
+链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 由于不必须按顺序存储，链表在给定位置插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是在有序数据中查找一个节点或者访问特定下标的节点则需要O(n)的时间，而线性表相应的时间复杂度分别是O(logn)和O(1)。
 
->使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在记忆体或磁盘上顺序，数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。
+>使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。链表最明显的好处就是，常规数组排列关联项目的方式可能不同于这些数据项目在内存或磁盘上的顺序，数据的存取往往要在不同的排列顺序中转换。链表允许插入和移除表上任意位置上的节点，但是不允许随机存取。链表有很多种不同的类型：单向链表，双向链表以及循环链表。
 
 下面看我们一步步实现链表：
 

data-structure/priority_queue.md

@@ -20,7 +20,7 @@ struct PriorityQueue<T> where T: PartialOrd + Clone {
 ```
 第二行的`where T: PartialOrd + Clone`指的是 PriorityQueue 存储的泛型 T 是满足 `PartialOrd` 和 `Clone` trait 约束的，意味着泛型 T 是可排序和克隆的。
 
-后面是一些基本的方法实现，比较简单，就直接看代码吧。
+后面是一些基本的方法实现，比较简单，就直接看代码吧。这个优先队列是基于Vec实现的，有O(1)的插入和O(n)的最大/最小值出列。
 ```rust
 impl<T> PriorityQueue<T> where T: PartialOrd + Clone {
     fn new() -> PriorityQueue<T> {
@@ -153,3 +153,6 @@ fn main() {
     test_keep_min();
 }
 ```
+
+## 练习
+基于二叉堆实现一个优先队列，以达到O(1)的出列和O(log n)的入列