Merge branch 'main' of https://github.com/nayounsang/relation-map

merge

Author: nayounsang

README.md

@@ -31,6 +31,21 @@
       - [size](#size-1)
       - [get member variables](#get-member-variables-1)
       - [count](#count)
+  - [Tree](#tree)
+    - [Term Explanation](#term-explanation-2)
+    - [Usage](#usage-2)
+      - [create instance](#create-instance-2)
+      - [add child](#add-child)
+      - [search](#search)
+      - [delete](#delete-2)
+      - [replace](#replace)
+      - [root](#root)
+      - [has](#has-2)
+      - [get parent](#get-parent)
+      - [get children](#get-children)
+      - [get depth](#get-depth)
+      - [get all nodes](#get-all-nodes)
+      - [destroy](#destroy)
 <!-- TOC -->
 
 # Relation map
@@ -382,3 +397,94 @@ myMap.set("a", 5);
 myMap.set("b", 20);
 myMap.count(); // {"a" => 2, "b" => 1}
 ```
+
+## Tree
+### Term Explanation
+- node
+- parent
+- children
+- root
+- sub tree
+### Usage
+#### create instance
+```typescript
+const tree = new Tree<number>(1);
+```
+- Construct with the root data.
+- In this example, root is `1`.
+#### add child
+```typescript
+tree.addChild(current, child);
+```
+- Add the new node at child position of current node.
+- Current node should exist in tree. If not exist, it throw the error.
+- Child node should not exist in tree. If exist, it throw the error.
+#### search 
+```typescript
+const subTreeNodes = tree.search(start);
+```
+- Get nodes in subtree.
+- Result's type is `Set<T>`, not `T[]`.
+#### delete
+```typescript
+tree.delete(node);
+```
+- Delete itself and all nodes in its subtree.
+- So, It should not delete root.
+#### replace
+```typescript
+tree.replace(prev, next);
+```
+- A new node replaces the prev node and the structure of tree is maintained.
+- Prev node should exist in tree. If not exist, it throw the error.
+- New node should not exist in tree. If exist, it throw the error.
+#### root
+```typescript
+const tree = new Tree<number>(1);
+console.log(tree.getRoot()) // 1
+console.log(tree.isRoot(2)) // false
+```
+- Use `getRoot` to get root data.
+- Use `isRoot` to know whether the data is root. 
+#### has
+```typescript
+const tree = new Tree<number>(1);
+console.log(tree.has(1)); // true
+console.log(tree.has(2)); // false
+```
+- Check if a value exists.
+#### get parent
+```typescript
+const tree = new Tree<number>(1);
+tree.addChild(1, 2);
+console.log(tree.getParent(1)); // null
+console.log(tree.getParent(2)); // 1
+```
+- Get parent of node.
+- If node is root, this returns `null`.
+- After `destroy()` or node not exists, it returns `undefined`.
+#### get children
+```typescript
+tree.getChildren(node);
+```
+- Get direct children of the node.
+- If node not exists, it returns `undefined`
+#### get depth
+```typescript
+tree.getDepth(node);
+```
+- Get depth of the node.
+- Root's depth is `0`.
+- If node not exists, it returns `undefined`
+#### get all nodes
+```typescript
+tree.getAllNodes();
+```
+- Get all nodes in the tree.
+- It's return type is `T[]`, not `Set<T>`.
+#### destroy
+```typescript
+tree.destroy();
+```
+- If you want to clear memory, call this.
+- After call this, this tree is no longer available.