convert-sorted-list-to-binary-search-tree

Author: ArcPi

Algorithms/README.md

@@ -0,0 +1,40 @@
+# Implementing the operations
+1. Find query: check if two objects are in the same component.
+2. Union command: Replacce components containing two objects with their union.
+
+# Union-find data type(API)
+1. Design efficient data structure for union-find
+2. Number of objects N can be huge.
+3. Number of operations M can be huge.
+4. Find quries and union commands may be intermixed.
+
+```java
+public class UF {
+    public UF(int N){ // initialize union-find data structure with N objects
+
+    }
+    public void union(int p, int q){ // add connection between p nad q
+
+    }
+    public boolean connected(int p, int q){ // are p and q in the same component?
+
+    }
+    public int find(int p){ // component identifier for p
+
+    }
+    public int count(){ // number of components
+
+    }
+}
+```
+# Data structure
+1. Integer array id[] of size N
+2. Interpretation: p and q are connected iff they have same id.
+   
+# Quick Find
+1. Find: check if p and q have the same id
+2. Union: To merge components containing p and q. change all entries whose id quals id[p] to id[q].
+
+# Quick Union
+1. Find: Check if p and q have the same root.
+2. Union: To merge components containing p and q, set the id of p's root to the id of q's root.

Algorithms/Union-Find.md

@@ -0,0 +1,96 @@
+# 题目描述
+Given a singly linked list where elements are sorted in ascending order, convert it to a height balanced BST.
+
+# 思想
+找出中间节点，然后断开，构造出二分查找树
+
+# 代码一
+对于中间节点的处理：直接令成nullptr
+```c
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *sortedListToBST(ListNode *head) {
+		if (head == nullptr)
+			return nullptr;
+		if (head->next == nullptr)
+			return new TreeNode(head->val);
+		ListNode *preMid = nullptr;
+		ListNode *mid = head;
+        ListNode *end = head;
+        while(end != nullptr && end->next != nullptr)
+        {
+            preMid = mid;
+            mid = mid->next;
+            end = end->next->next;
+        }
+		TreeNode *root = new TreeNode(mid->val);
+		preMid->next = nullptr;
+
+		root->left = sortedListToBST(head);
+		root->right = sortedListToBST(mid->next);
+
+		return root;
+	}
+};
+```
+
+# 代码二
+对于中间节点的处理：记录下来。换句话说，不令成nullptr，知道是中间节点即可
+```c
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+/**
+ * Definition for binary tree
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    TreeNode *sortedListToBST(ListNode *head) {
+        return makeBST(head, nullptr);
+    }
+    
+    TreeNode *makeBST(ListNode *head, ListNode *end){
+        if(head == end)
+            return nullptr;
+        ListNode *mid = head;
+        ListNode *fast = head;
+        while(fast != end && fast->next != end){
+            mid = mid->next;
+            fast = fast->next->next;
+        }
+        TreeNode *root = new TreeNode(mid->val);
+        root->left = makeBST(head, mid);
+        root->right = makeBST(mid->next, end);
+        
+        return root;
+    }
+};
+```

LeetCode/README.md

@@ -1,2 +1,4 @@
 # Algorithm
 记录刷题历程。。。
+# List
+1.