feat: add stack gif image, update coding style

Author: chachaxw

.vscode/settings.json

@@ -22,5 +22,8 @@
   "C_Cpp.errorSquiggles": "Disabled",
   "fileheader.LastModifiedBy": "Chacha",
   "fileheader.Author": "Chacha",
-  "editor.tabSize": 4
+  "editor.tabSize": 4,
+  "cSpell.words": [
+    "inorder"
+  ]
 }

basic_data_structure/heap/heap.cpp

@@ -0,0 +1,6 @@
+/**
+ * @Author: Chacha
+ * @Date: 2021-03-03 16:06:05
+ * @Last Modified by: Chacha
+ * @Last Modified time: 2021-03-03 17:30:01
+ */

basic_data_structure/linked_list/linked_list.cpp

@@ -1,20 +1,21 @@
 /**
- * @Author: Chacha 
- * @Date: 2018-12-30 13:12:05 
+ * @Author: Chacha
+ * @Date: 2018-12-30 13:12:05
  * @Last Modified by: Chacha
  * @Last Modified time: 2018-12-30 17:00:28
  */
 
 #include<iostream>
 using namespace std;
 
-/** 
+/**
  * Struct definition for singly-linked list(单向链表)
  * Source: https://zh.wikipedia.org/wiki/链表
  */
 struct ListNodeA {
     int val;
     ListNodeA *next;
+
     ListNodeA(int x) : val(x), next(NULL) {}
 };
 
@@ -25,6 +26,7 @@ struct ListNodeA {
  public:
     int val;
     ListNodeB *next;
+
     ListNodeB(int val) {
         this->val = val;
         this->next = NULL;
@@ -34,12 +36,13 @@ struct ListNodeA {
 /**
  * Class definition for doubly-linked list(双向链表)
  */
-class DListNode() {
+class DListNode {
 public:
     int val;
-    DListNode prev, next;
+    DListNode *prev, *next;
+
     DListNode(int val) {
-        this.val = val;
-        this.prev = this.next = NULL;
+        this->val = val;
+        this->prev = this->next = NULL;
     }
-}
+};

basic_data_structure/queue/queue.cpp

@@ -1,6 +1,6 @@
 /**
- * @Author: Chacha 
- * @Date: 2018-12-03 17:14:17 
+ * @Author: Chacha
+ * @Date: 2018-12-03 17:14:17
  * @Last Modified by: Chacha
  * @Last Modified time: 2018-12-12 21:50:07
  */
@@ -21,16 +21,21 @@ struct TreeNode {
 class MyQueue {
     private:
         // store elements
-        vector<int> data;       
+        vector<int> data;
         // a pointer to indicate the start position
-        int p_start;            
+        int p_start;
+
     public:
-        MyQueue() {p_start = 0;}
+        MyQueue() {
+            p_start = 0;
+        }
+
         /** Insert an element into the queue. Return true if the operation is successful. */
         bool enQueue(int x) {
             data.push_back(x);
             return true;
         }
+
         /** Delete an element from the queue. Return true if the operation is successful. */
         bool deQueue() {
             if (isEmpty()) {
@@ -39,32 +44,34 @@ class MyQueue {
             p_start++;
             return true;
         };
+
         /** Get the front item from the queue. */
         int Front() {
             return data[p_start];
         };
+
         /** Checks whether the queue is empty or not. */
         bool isEmpty()  {
             return p_start >= data.size();
         }
 };
 
 /***********************************************************************************
- * Design your implementation of the circular queue. 
- * The circular queue is a linear data structure in which the operations 
- * are performed based on FIFO (First In First Out) principle and 
- * the last position is connected back to the first position to make a circle. 
+ * Design your implementation of the circular queue.
+ * The circular queue is a linear data structure in which the operations
+ * are performed based on FIFO (First In First Out) principle and
+ * the last position is connected back to the first position to make a circle.
  * It is also called "Ring Buffer".
  * Your implementation should support following operations:
  *  1. MyCircularQueue(k): Constructor, set the size of the queue to be k.
  *  2. Front: Get the front item from the queue. If the queue is empty, return -1.
  *  3. Rear: Get the last item from the queue. If the queue is empty, return -1.
- *  4. enQueue(value): Insert an element into the circular queue. 
+ *  4. enQueue(value): Insert an element into the circular queue.
  *     Return true if the operation is successful.
  *  5. deQueue(): Delete an element from the circular queue. Return true if the operation is successful.
  *  6. isEmpty(): Checks whether the circular queue is empty or not.
  *  7. isFull(): Checks whether the circular queue is full or not.
- *  
+ *
  * Example:
  *  MyCircularQueue circularQueue = new MyCircularQueue(3); // set the size to be 3
  *  circularQueue.enQueue(1);  // return true
@@ -76,7 +83,7 @@ class MyQueue {
  *  circularQueue.deQueue();  // return true
  *  circularQueue.enQueue(4);  // return true
  *  circularQueue.Rear();  // return 4
- * 
+ *
  * Source： https://leetcode-cn.com/explore/learn/card/queue-stack/216/queue-first-in-first-out-data-structure/865/
 ************************************************************************************/
 
@@ -95,7 +102,7 @@ class MyCircularQueue {
         tail = -1;
         size = k;
     }
-    
+
     /** Insert an element into the circular queue. Return true if the operation is successful. */
     bool enQueue(int value) {
         if (isFull()) {
@@ -109,44 +116,44 @@ class MyCircularQueue {
         data[tail] = value;
         return true;
     }
-    
+
     /** Delete an element from the circular queue. Return true if the operation is successful. */
     bool deQueue() {
         if (isEmpty()) {
             return false;
         }
-        
+
         if (head == tail) {
             head = -1;
             tail = -1;
             return true;
         }
-        
+
         head = (head + 1) % size;
         return true;
     }
-    
+
     /** Get the front item from the queue. */
     int Front() {
         if (isEmpty()) {
             return -1;
         }
         return data[head];
     }
-    
+
     /** Get the last item from the queue. */
     int Rear() {
         if (isEmpty()) {
             return -1;
         }
         return data[tail];
     }
-    
+
     /** Checks whether the circular queue is empty or not. */
     bool isEmpty() {
         return head == -1;
     }
-    
+
     /** Checks whether the circular queue is full or not. */
     bool isFull() {
         return ((tail + 1) % size) == head;
@@ -168,11 +175,11 @@ class MyCircularQueue {
 /**
  * Implement Queue by Two Stacks
  * As the title described, you should only use two stacks to implement a queue's actions.
- * The queue should support push(element), 
+ * The queue should support push(element),
  * pop() and top() where pop is pop the first(a.k.a front) element in the queue.
  * Both pop and top methods should return the value of first element.
  * LIFO + LIFO ==> FIFO
- * 
+ *
  * Example:
  *  For push(1), pop(), push(2), push(3), top(), pop(), you should return 1, 2 and 2
  */
@@ -189,7 +196,7 @@ class MyQueue {
     void push(int element) {
         stack1.push(element);
     }
-    
+
     void adjust() {
         if (stack2.empty()) {
             while (!stack1.empty()) {
@@ -198,7 +205,7 @@ class MyQueue {
             }
         }
     }
-    
+
     int pop() {
         adjust();
         int temp = stack2.top();
@@ -215,9 +222,9 @@ class MyQueue {
 /**
  * BFS - Template 1
  * Return the length of the shortest path between root and target node.
- * 
+ *
  * 1. As shown in the code, in each round, the nodes in the queue are the nodes which are waiting to be processed.
- * 2. After each outer while loop, we are one step farther from the root node. 
+ * 2. After each outer while loop, we are one step farther from the root node.
  *    The variable step indicates the distance from the root node and the current node we are visiting.
  */
 int BFS(TreeNode root, TreeNode target) {
@@ -245,7 +252,7 @@ int BFS(TreeNode root, TreeNode target) {
 /**
  * BFS - Template 2
  * Return the length of the shortest path between root and target node.
- * 
+ *
  * There are two cases you don't need the hash set used:
  *  1. You are absolutely sure there is no cycle, for example, in tree traversal;
  *  2. You do want to add the node to the queue multiple times.
@@ -287,4 +294,4 @@ int main() {
     if (!q.isEmpty()) {
         cout << q.Front() << endl;
     }
-}
+}

basic_data_structure/stack/stack.cpp

@@ -1,35 +1,41 @@
 /**
- * @Author: Chacha 
- * @Date: 2018-12-05 22:58:19 
+ * @Author: Chacha
+ * @Date: 2018-12-05 22:58:19
  * @Last Modified by: Chacha
  * @Last Modified time: 2018-12-08 22:23:42
  */
 
 #include <iostream>
 #include <vector>
+#include <stack>
 using namespace std;
 
 class MyStack {
     private:
         vector<int> data;               // store elements
+
     public:
         /** Insert an element into the stack. */
         void push(int x) {
             data.push_back(x);
         }
+
         /** Checks whether the queue is empty or not. */
         bool isEmpty() {
             return data.empty();
         }
+
         /** Get the top item from the queue. */
         int top() {
             return data.back();
         }
+
         /** Delete an element from the queue. Return true if the operation is successful. */
         bool pop() {
             if (isEmpty()) {
                 return false;
             }
+
             data.pop_back();
             return true;
         }
@@ -41,7 +47,7 @@ class MyStack {
  * 2. pop() -- Removes the element on top of the stack.
  * 3. top() -- Get the top element.
  * 4. getMin() -- Retrieve the minimum element in the stack.
- * 
+ *
  * Example:
  *  MinStack minStack = new MinStack();
  *  minStack.push(-2);
@@ -51,7 +57,7 @@ class MyStack {
  *  minStack.pop();
  *  minStack.top();      --> Returns 0.
  *  minStack.getMin();   --> Returns -2.
- * 
+ *
  * Source: https://leetcode-cn.com/explore/learn/card/queue-stack/218/stack-last-in-first-out-data-structure/877/
 ************************************************************************************/
 class MinStack {
@@ -60,23 +66,23 @@ class MinStack {
         stack<int> s2;
 
     MinStack() {
-        
+
     }
-    
+
     void push(int x) {
         s1.push(x);
         if (s2.empty() || x <= getMin()) s2.push(x);
     }
-    
+
     void pop() {
         if (s1.top() == getMin()) s2.pop();
         s1.pop();
     }
-    
+
     int top() {
         return s1.top();
     }
-    
+
     int getMin() {
         return s2.top();
     }
@@ -96,10 +102,11 @@ int main() {
     s.push(1);
     s.push(2);
     s.push(3);
+
     for (int i = 0; i < 4; ++i) {
         if (!s.isEmpty()) {
             cout << s.top() << endl;
         }
         cout << (s.pop() ? "true" : "false") << endl;
     }
-}
+}