revise

Author: zhongn2

Container With Most Water.cpp

@@ -0,0 +1,14 @@
+
+// main idea: find the max of (j - i) * min(ai, aj)
+class Solution {
+public:
+    int maxArea(vector<int> &height) {
+        int i = 0, j = height.size() - 1;
+        int container = 0;
+        while(i < j){
+            container = max(container, (j - i) * min(height[i], height[j]));
+            (height[i] > height[j])? j-- : i++;
+        }
+        return container;
+    }
+};

Partition List.cpp

@@ -17,24 +17,23 @@
 class Solution {
 public:
     ListNode *partition(ListNode *head, int x) {
-        ListNode stdummy(-1);
-        ListNode nddummy(-1);
-        auto l = &stdummy;
-        auto r = &nddummy;
-        for(ListNode *curr = head;curr; curr = curr -> next){
-            if(curr -> val < x){
-                l -> next = curr;
-                l = curr; // move the l pointer
+        if(head == NULL) return head;
+        ListNode *dummy1 = new ListNode(-1);
+        ListNode *dummy2 = new ListNode(-1);
+        ListNode *node1 = dummy1;
+        ListNode *node2 = dummy2;
+        while(head){
+            if(head -> val < x){
+                node1 -> next = head;
+                node1 = node1 -> next;
             }else{
-                r -> next = curr;
-                r = curr;
+                node2 -> next = head;
+                node2 = node2 -> next;
             }
+            head = head -> next;
         }
-        
-        l -> next = nddummy.next;
-        //nddummy.next = NULL;//stupid mistake. how can this happen??
-		r -> next = NULL;
-        return stdummy.next;
+        node2 -> next = NULL; // end flag
+        node1 -> next = dummy2 -> next; // point dummy2 to the end of node1 list
+        return dummy1 -> next;
     }
-
 };

Remove Duplicates from Sorted List.cpp

@@ -0,0 +1,40 @@
+//Remove Duplicates from Sorted List 
+class Solution {
+public:
+    ListNode *deleteDuplicates(ListNode *head) {
+        if(head == NULL) return head;
+        ListNode *node = head;
+        while(node -> next){ // we need to compare with the next val, so here we should consider about the next node not node!!
+            int v = node -> val;
+            if(node -> next -> val == v){
+                node -> next = node -> next -> next;
+            }else{
+                node = node -> next;
+            }
+        }
+        return head;
+    }
+};
+
+//Remove Duplicates from Sorted List ii
+
+ class Solution {
+public:
+    ListNode *deleteDuplicates(ListNode *head) {
+        if(head == NULL || head -> next == NULL) return head;
+       ListNode *dummy = new ListNode(-1);
+       dummy -> next = head; 
+       ListNode *node = dummy;
+       while(node -> next && node -> next -> next){
+           if(node -> next -> next -> val == node -> next -> val){
+                int v = node -> next -> val;
+                while(node -> next && node -> next -> val == v){
+                   node -> next = node -> next -> next;
+               }
+           }else{
+               node = node -> next;
+           }
+       }
+       return dummy -> next;
+    }
+};

Reverse list.cpp

@@ -0,0 +1,30 @@
+// reverse a linked list
+// reverse a linked list. first thing we need to do is to store the value for the next node
+// and then give previous node to the head next, then move head to the next level. meanwhile, prev will be the head compare with the tmp
+
+void reverse(Node *&head){
+	if(head == NULL) return;
+	Node *prev = NULL;
+	Node *tmp = NULL;
+	while(head){
+		tmp = head -> next;
+		head -> next = prev;
+		prev = head;
+		head = tmp;
+	}
+	
+
+//find the middle of the linked list
+// we have two pointers and move one step by step, another one two steps each time
+ListNode *findMid(ListNode *head){
+	ListNode slow = head, fast = head -> next;
+	while(fast != NULL && fast -> next != NULL){ // it has to be fast, it's fast than slow pointer
+		fast = fast -> next -> next;
+		slow = slow -> next;
+	}
+	return slow;
+}
+
+
+
+	 

Trapping Rain Water.cpp

@@ -0,0 +1,26 @@
+class Solution {
+public:
+    int trap(int A[], int n) {
+        if(n < 2) return 0;
+        int *left = new int[n];
+        int *right = new int[n];
+        // find the max height on the left for each state
+        left[0] = 0;
+        for(int i = 1; i < n; i++){
+            left[i] = max(left[i-1], A[i-1]);
+        }
+        // find the max height on the right
+        right[n -1] = 0;
+        for(int j = n - 2; j >= 0; j--){
+            right[j] = max(right[j+1], A[j+1]);
+        }
+        int trapWater = 0;
+        for(int i = 0; i < n; i++){
+            if(min(left[i], right[i]) - A[i] > 0)
+                trapWater += min(left[i], right[i]) - A[i];
+        }
+        delete left;
+        delete right;
+        return trapWater;
+    }
+};