Add comments to explain the solutions

haoel · haoel · commit e2be44a8e04e · 2014-10-31T15:37:20.000+08:00
diff --git a/src/3Sum/3Sum.cpp b/src/3Sum/3Sum.cpp
@@ -29,11 +29,26 @@
 using namespace std;
 
 
-//solution:  http://en.wikipedia.org/wiki/3SUM
+/*
+ *   Simlar like "Two Number" problem, we can have the simlar solution.
+ *
+ *   Suppose the input array is S[0..n-1], 3SUM can be solved in O(n^2) time on average by 
+ *   inserting each number S[i] into a hash table, and then for each index i and j,  
+ *   checking whether the hash table contains the integer - (s[i]+s[j])
+ *
+ *   Alternatively, the algorithm below first sorts the input array and then tests all 
+ *   possible pairs in a careful order that avoids the need to binary search for the pairs 
+ *   in the sorted list, achieving worst-case O(n^n)
+ *
+ *   Solution:  Quadratic algorithm
+ *   http://en.wikipedia.org/wiki/3SUM
+ *
+ */
 vector<vector<int> > threeSum(vector<int> &num) {
 
     vector< vector<int> > result;
 
+    //sort the array, this is the key
     sort(num.begin(), num.end());
 
     int n = num.size();
diff --git a/src/4Sum/4Sum.cpp b/src/4Sum/4Sum.cpp
@@ -29,6 +29,11 @@ using namespace std;
 
 vector<vector<int> > threeSum(vector<int> num, int target); 
 
+/*
+ * 1) Sort the array,
+ * 2) traverse the array, and solve the problem by using "3Sum" soultion.
+ */
+
 vector<vector<int> > fourSum(vector<int> &num, int target) {
     vector< vector<int> > result;
     if (num.size()<4) return result;
@@ -51,7 +56,7 @@ vector<vector<int> > fourSum(vector<int> &num, int target) {
 vector<vector<int> > threeSum(vector<int> num, int target) {
 
     vector< vector<int> > result;
-
+    //sort the array (if the qrray is sorted already, it won't waste any time)
     sort(num.begin(), num.end());
 
     int n = num.size();
diff --git a/src/linkedListCycle/linkedListCycle.II.cpp b/src/linkedListCycle/linkedListCycle.II.cpp
@@ -46,6 +46,12 @@ class Solution {
         
     }  
     
+    /* 
+     * So, the idea is:
+     *   1) Using the cycle-chcking algorithm.
+     *   2) Once p1 and p1 meet, then reset p1 to head, and move p1 & p2 synchronously
+     *      until p1 and p2 meet again, that place is the cycle's start-point 
+     */
     ListNode *detectCycle(ListNode *head) {
         
         if (hasCycle(head)==false){
diff --git a/src/linkedListCycle/linkedListCycle.cpp b/src/linkedListCycle/linkedListCycle.cpp
@@ -12,6 +12,13 @@
 *               
 **********************************************************************************/
 
+/*
+ * if there is a cycle in the list, then we can use two pointers travers the list.
+ *
+ * one pointer traverse one step each time, another one traverse two steps each time.
+ *
+ * so, those two pointers meet together, that means there must be a cycle inside the list.
+ */
 
 bool hasCycle(ListNode *head) {
     ListNode* p1;
diff --git a/src/swapNodesInPairs/swapNodesInPairs.cpp b/src/swapNodesInPairs/swapNodesInPairs.cpp
@@ -28,12 +28,18 @@ class Solution {
     Solution(){
         srand(time(NULL));
     }
+    /*
+     * Here we have two ways to solve this problem:
+     * 1) keep the list's nodes no change. only swap the data in the list node.
+     * 2) swap the list node physically.
+     */
     ListNode *swapPairs(ListNode *head) {
         if(random()%2){
             return swapPairs1(head);
         }
         return swapPairs2(head);
     }
+    /*just swap the node's value instead of node*/
     ListNode *swapPairs1(ListNode *head) {
         for (ListNode *p = head; p && p->next; p = p->next->next) {
             int n = p->val;
@@ -42,18 +48,22 @@ class Solution {
         }
         return head;
     }
-    
+    /*swap the list nodes physically*/ 
     ListNode *swapPairs2(ListNode *head) {
         ListNode *h = NULL;
+        //using `*p` to traverse the linked list
         for (ListNode *p = head; p && p->next; p = p->next) {
+            //`n` is `p`'s next node, and swap `p` and `n` physcially
             ListNode *n = p->next;
             p->next = n->next;
             n->next = p;
+            //using `h` as `p`'s previous node
             if (h){
                 h->next = n;
             }
             h=p;
             
+            //determin the really 'head' pointer
             if (head == p){
                 head = n;
             }
diff --git a/src/twoSum/twoSum.cpp b/src/twoSum/twoSum.cpp
@@ -20,13 +20,45 @@
 
 class Solution {
 public:
+    /*
+     *   The easy solution is O(n^2) run-time complexity.
+     *   ```
+     *       foreach(item1 in array) {
+     *           foreach(item2 in array){
+     *               if (item1 + item2 == target) {
+     *                   return result
+     *               }
+     *           }
+     *   ```
+     *   
+     *   We can see the nested loop just for searching, 
+     *   So, we can use a hashmap to reduce the searching time complexity from O(n) to O(1)
+     *   (the map's `key` is the number, the `value` is the position)
+     *   
+     *   But be careful, if there are duplication numbers in array, 
+     *   how the map store the positions for all of same numbers?
+     *
+     */
+
+
+    //
+    // The implementation as below is bit tricky. but not difficult to understand
+    //
+    //  1) Traverse the array one by one
+    //  2) just put the `target - num[i]`(not `num[i]`) into the map
+    //     so, when we checking the next num[i], if we found it is exisited in the map.
+    //     which means we found the second one.
+    //      
     vector<int> twoSum(vector<int> &numbers, int target) {
         map<int, int> m;
         vector<int> result;
         for(int i=0; i<numbers.size(); i++){
-            if (m.find(numbers[i])==m.end() ) { // not found
-                m[target - numbers[i]] = i;
-            }else { // found
+            // not found the second one
+            if (m.find(numbers[i])==m.end() ) { 
+                // store the first one poisition into the second one's key
+                m[target - numbers[i]] = i; 
+            }else { 
+                // found the second one
                 result.push_back(m[numbers[i]]+1);
                 result.push_back(i+1);
                 break;
