docs: 修改冲突 feat: add BinaryTree (MrXujiang#50)

* docs: 修改(prettier/prettier) 报错

* docs: update README.md

* docs: update no-console 报 error

* docs: update no-constant-condition 报 error

* docs: update no-constant-condition 报 error

* docs: 添加 IPv6 正则表达式

* docs: 添加 IPv6 正则表达式

* docs: delete no-console

* docs: dele ipv6

* feat: 添加数据脱敏

* feat: 添加数据脱敏

* feat: 添加数据脱敏

* feat: 添加 双向链表

* fix:  修改冲突

* feat: add 表单数据转成JSON

* feat: add 表单数据转成JSON

* fix: 修改build报错

* docs: prefer-const

* docs: add BothLinkedList index.md

* feat: add BinaryTree

* feat: add BinaryTree

.eslintrc

@@ -20,7 +20,7 @@
     "@typescript-eslint/no-explicit-any": "off",
     "no-constant-condition": "off",
     "@typescript-eslint/no-this-alias": "off",
-    "prefer-const": "off",
+    "prefer-const": "off"
   },
   "ignorePatterns": ["**/*.test.js"]
 }

src/BinaryTree/index.md

@@ -0,0 +1,50 @@
+---
+title: BinaryTree - 二叉树
+nav:
+  title: 使用文档
+  path: /lib
+group:
+  path: /format
+  title: 数据结构相关
+  order: 2
+---
+
+## BinaryTree
+
+> 二叉树
+>
+> bt.insert(param):&emsp; param 是 需要插入的元素    <br>
+> bt.find(param):&emsp; param 是 需要寻找的元素，返回值为所找到的节点   <br>
+> bt.removeNode(param):&emsp; param 需要删除的元素   <br>
+> bt.getRoot():&emsp; 获取二叉树的根节点  <br>
+> bt.getMinNode():&emsp; 获取二叉树 某个节点的最小值  <br>
+> bt.getMaxNode():&emsp; 获取二叉树 某个节点的最小值  <br>
+> bt.preOrderTraversal(bt.getRoot()):&emsp; 需要传入进行遍历的节点,  遍历结束之后, 可以通过  bt.getRoot().preOrder  获取先序遍历的结果集  <br>
+> bt.centerOrderTraversal(bt.getRoot()):&emsp;需要传入进行遍历的节点, 遍历结束之后, 可以通过  bt.getRoot().centerOrder  获取中序遍历的结果集 <br>
+> bt.postOrderTraversal(bt.getRoot()):&emsp;需要传入进行遍历的节点, 遍历结束之后, 可以通过  bt.getRoot().postOrder 获取后序遍历的结果集  <br>
+
+Demo:
+
+```tsx | pure
+import { BinaryTree } from 'xijs';
+const bt = new BinaryTree();
+bt.insert(1);
+bt.insert(2);
+bt.insert(0);
+// bt.insert(4);
+// bt.insert(-1);
+
+const res = bt.find(2);
+console.log('find: ', res)
+bt.removeNode(2)
+console.log('getRoot: ', bt.getRoot())
+console.log('getMinNode: ', bt.getMinNode())
+console.log('getMaxNode: ', bt.getMaxNode())
+bt.preOrderTraversal(bt.getRoot())
+bt.centerOrderTraversal(bt.getRoot())
+bt.postOrderTraversal(bt.getRoot())
+console.log(`preOrder: `, bt.getRoot().preOrder)
+console.log(`centerOrder: `, bt.getRoot().centerOrder)
+console.log(`postOrder: `, bt.getRoot().postOrder)
+
+```

src/BinaryTree/index.ts

@@ -0,0 +1,206 @@
+/**
+ * 定义二叉树的结构
+ */
+class TreeNode<T> {
+  data: T;
+  left: TreeNode<T> | undefined;
+  right: TreeNode<T> | undefined;
+  count = 0;
+  preOrder: Array<T> = [];
+  centerOrder: Array<T> = [];
+  postOrder: Array<T> = [];
+  constructor(
+    data: T,
+    left: TreeNode<T> | undefined,
+    right: TreeNode<T> | undefined,
+  ) {
+    this.data = data;
+    this.left = left;
+    this.right = right;
+  }
+}
+
+/**
+ * 定义二叉树的操作
+ */
+class BinaryTree<T> {
+  root: TreeNode<T> | undefined;
+
+  constructor() {
+    this.root = undefined;
+  }
+
+  insert(data: T): void {
+    const newTreeNode: TreeNode<T> = new TreeNode(data, undefined, undefined);
+    if (this.root === undefined) {
+      this.root = newTreeNode;
+      this.root.count++;
+    } else {
+      let curNode = this.root;
+      let parentNode = undefined;
+      while (true) {
+        parentNode = curNode;
+        if (curNode.data > data) {
+          curNode = curNode.left!;
+          if (!curNode) {
+            parentNode.left = newTreeNode;
+            this.root.count++;
+            break;
+          }
+        } else if (curNode.data < data) {
+          curNode = curNode.right!;
+          if (!curNode) {
+            parentNode.right = newTreeNode;
+            this.root.count++;
+            break;
+          }
+        } else if (newTreeNode.data === curNode.data) {
+          // 如果给定的数据再次出现，就更新计数值
+          curNode.count++;
+          break;
+        }
+      }
+    }
+  }
+
+  /**
+   * 根据元素值 寻找 节点
+   * @param data
+   */
+  find(data: T): TreeNode<T> | undefined {
+    let currNode: TreeNode<T> | undefined = this.root;
+    while (currNode) {
+      if (currNode.data == data) {
+        return currNode;
+      } else if (data < currNode.data) {
+        currNode = currNode.left;
+      } else {
+        currNode = currNode.right;
+      }
+    }
+    return undefined;
+  }
+
+  /**
+   * 获取根节点
+   */
+  getRoot(): TreeNode<T> | undefined {
+    return this.root;
+  }
+
+  /**
+   * 删除节点
+   */
+  removeNode(data: T) {
+    this._removeNode(this.root, data);
+  }
+  _removeNode(
+    curNode: TreeNode<T> | undefined,
+    data: T,
+  ): TreeNode<T> | undefined {
+    if (curNode === undefined) {
+      return undefined;
+    }
+    if (curNode.data === data) {
+      /**
+       * 左子树和右子树都为空，说明是叶子节点，可以直接删除
+       */
+      if (curNode.left === undefined && curNode.right === undefined) {
+        return undefined;
+      }
+      if (curNode.left === undefined) {
+        return curNode.right;
+      }
+      if (curNode.right === undefined) {
+        return curNode.left;
+      }
+      /**
+       * 如果两个节点都存在，则需要寻找右子树上的最小值，因为二叉树从左子树到根节点再到右子树，是从小到大排序
+       */
+      let tmpNode = this.getMinNode(curNode.right);
+      curNode.data = tmpNode.data;
+      curNode.right = this._removeNode(curNode.right, tmpNode.data);
+      this.root!.count--;
+      return curNode;
+    } else if (curNode.data > data) {
+      /**
+       * 如果当前节点值 > 需要寻找的 data，则需要在左子树继续寻找
+       */
+      curNode.left = this._removeNode(curNode.left, data);
+      this.root!.count--;
+      return curNode;
+    } else if (curNode.data < data) {
+      /**
+       * 如果当前节点值 < 需要寻找的 data，则需要在右子树继续寻找
+       */
+      curNode.right = this._removeNode(curNode.right, data);
+      this.root!.count--;
+      return curNode;
+    }
+  }
+
+  /**
+   * 获取最大节点
+   * @param curNode
+   */
+  getMaxNode(node = this.root!) {
+    let curNode = node;
+    while (curNode.right) {
+      curNode = curNode.right;
+    }
+    return curNode;
+  }
+
+  /**
+   * 获取最小节点
+   * @param curNode
+   */
+  getMinNode(node = this.root!) {
+    let curNode = node;
+    while (curNode.left) {
+      curNode = curNode.left;
+    }
+    return curNode;
+  }
+
+  /**
+   * 先序遍历，遍历结束之后，可以通过 bt.getRoot().preOrder 获取遍历以后的元素数组
+   * @param root
+   */
+  preOrderTraversal(root: TreeNode<T>) {
+    if (root === undefined) {
+      return undefined;
+    }
+    this.preOrderTraversal(root.left!);
+    this.root!.preOrder.push(root.data);
+    this.preOrderTraversal(root.right!);
+  }
+
+  /**
+   * 中序遍历，遍历结束之后，可以通过 bt.getRoot().centerOrder 获取遍历以后的元素数组
+   * @param root
+   */
+  centerOrderTraversal(root: TreeNode<T>) {
+    if (root === undefined) {
+      return undefined;
+    }
+    this.root!.centerOrder.push(root.data);
+    this.centerOrderTraversal(root.left!);
+    this.centerOrderTraversal(root.right!);
+  }
+
+  /**
+   * 后序遍序遍历，遍历结束之后，可以通过 bt.getRoot().postOrder 获取遍历以后的元素数组
+   * @param root
+   */
+  postOrderTraversal(root: TreeNode<T>) {
+    if (root === undefined) {
+      return undefined;
+    }
+    this.postOrderTraversal(root.left!);
+    this.postOrderTraversal(root.right!);
+    this.root!.postOrder.push(root.data);
+  }
+}
+
+export default BinaryTree;

src/BothLinkedList/index.md

@@ -0,0 +1,44 @@
+---
+title: bothLinkedList - 双向链表
+nav:
+  title: 使用文档
+  path: /lib
+group:
+  path: /format
+  title: 数据结构相关
+  order: 2
+---
+
+## bothLinkedList
+
+> 双向链表
+>
+> bothLinkedList.insertHead(param): param 是 需要插入的元素，插入到元素链表尾部    <br>
+> bothLinkedList.insertIndex(param, index): param 是 需要插入的元素，index： 需要插入的位置    <br>
+> bothLinkedList.getHead(): 从头开始遍历链表   <br>
+> bothLinkedList.getTail(): 从尾开始遍历链表   <br>
+> bothLinkedList.getData(index): index: 通过索引获取元素值   <br>
+> bothLinkedList.getSize(): 获取链表长度   <br>
+> bothLinkedList.deleteFrom(index): index 通过索引删除元素节点   <br>
+> bothLinkedList.deleteData(param): index 通过元素值删除元素节点   <br>
+>
+> 返回值：Node 类型:
+>
+> { data: 1, next: undefined, prev: undefined }
+
+Demo:
+
+```tsx | pure
+import { BothLinkedList } from 'xijs';
+
+let bothLinkedList = new BothLinkedList()
+bothLinkedList.insertHead(1);
+bothLinkedList.insertHead(2);
+// bothLinkedList.insertHead(3)
+console.log(bothLinkedList.getHead())
+bothLinkedList.deleteFrom(1)
+bothLinkedList.deleteData(1)
+console.log(bothLinkedList.getHead())
+// console.log(bothLinkedList.getTail())
+// console.log(bothLinkedList.getData(3))
+```