LeetCode刷題之路

開門見山：向量 vector 是一種對象實體, 能夠容納許多其他類型相同的元素, 因此又被稱爲容器。 與string相同, vector 同屬於STL(Standard Template Library, 標準模板庫)中的一種自定義的數據類型, 可以廣義上認爲是數組的增強版。不過向量能根據需要進行隨意大小的調整。
在向量這兒遍歷可以採取一種迭代器的方法：類型爲iterator，遍歷器不但表示位置，還可以表示前後移動.

 vector<int>::iterator t ;
    for(t=a.begin(); t!=a.end(); t++)
        cout<<*t<<" " ;

插入一個學習向量vector的博客：https://www.cnblogs.com/aminxu/p/4686332.html

爲了運行時間複雜度的優化，選擇一種更有效的方法來檢查數組中是否存在目標元素，如果存在，找出它的索引，保持數組中每個元素與其索引相互對應的最好方法是哈希表常以空間換速度的方式
https://blog.csdn.net/u013468917/article/details/51362156
學到一個原理：ArrayList使用的是數組來存儲數據，HashMap是用哈希表來存儲，兩者運行時間的差距在contains和containsKey方法上。

public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        map.put(nums[i], i);
    }
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i];
        if (map.containsKey(complement) && map.get(complement) != i) {
            return new int[] { i, map.get(complement) };
        }
    }
    throw new IllegalArgumentException("No two sum solution");
}

或者【更加簡單：在進行迭代並將元素插入到表中的同時，我們還會回過頭來檢查表中是否已經存在當前元素所對應的目標元素。如果它存在，那我們已經找到了對應解，並立即將其返回。】：

public int[] twoSum(int[] nums, int target) {        
	HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();               
		 for(int i=0; i<nums.length; i++){         
			 if(map.containsKey(target-nums[i])){         
 				 return new int[]{map.get(target-nums[i]), i};         
 			}         
  			map.put(nums[i], i);        
		 }       
 	  return null;   
 }

今天偶遇大佬，學到了c++中的一個比較全面的庫，stl，（linklist），學習到其中有好多已經寫好的各種數據結構內容，例如鏈表之類的都是已經寫好的，向量的本質今天算是記清楚了，此容器主要的特點是可以改變大小的，無需設置大小於初始化，可以直接push_back.
蒟蒻入門：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        ListNode *l3;
        ListNode *l4;
        int jinwei=0;
        while(l1!=NULL||l2!=NULL||jinwei!=0){
            int sum=(l1==NULL?0:l1->val)+(l2==NULL?0:l2->val)+jinwei;
            jinwei=sum/10;
        ListNode *newNode = new ListNode(sum%10);
         if (l3 == NULL) {
          l3 = newNode;
          l4 = newNode;
         } else{
          l4->next = newNode;   
          l4 = l4->next;
        }
            l1=l1==NULL?NULL:l1->next;
            l2=l2==NULL?NULL:l2->next;
        }
        return l3;
    }
};

未知錯誤，算是服氣了！！！（不知代碼問題何在）
不過根據題解學到了一種方法，不一定建立鏈表就必須非得按頭節點輸出，完全可以返回head.next，或者這種方法等價於設置空頭，然後在最後的時候將其delete掉
如下：

class Solution {
public:
    ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
        int carry = 0;//進位位
        ListNode *head = new ListNode(0);//這個空頭，後面要刪掉
        ListNode *nextTemp= head;
        while (l1 != nullptr || l2 != nullptr|| carry)
        {
            nextTemp->next = new ListNode(0);//新建一個節點
            nextTemp = nextTemp->next;
            int x = (l1) ? l1->val : 0;
            int y = (l2) ? l2->val : 0;
            int temp = carry + x + y;
            nextTemp->val = temp % 10;
            carry = temp / 10;
            if(l1) l1 = l1->next;
            if(l2) l2 = l2->next;
        }
        ListNode *returnVal = head->next;
        delete head;//頭結點沒有用
        return returnVal;
    }
};

標準答案：

class Solution {
public:
ListNode *addTwoNumbers(ListNode *l1, ListNode *l2) {
ListNode preHead(0), *p = &preHead;
int carry = 0;
while (l1 || l2 || carry) {
int sum = (l1 ? l1->val : 0) + (l2 ? l2->val : 0) + carry;
carry = sum / 10;
p->next = new ListNode(sum % 10);
p = p->next;
l1 = l1 ? l1->next : l1;
l2 = l2 ? l2->next : l2;
}
return preHead.next;
};

**注：**竟然找到了C語言產生隨機數【C語言中語句scrand((time(NULL));表示設置一個隨機種子，每次運行都能保證隨機種子不同，在C語言中rand()函數可以用來產生隨機數，但並不是真正意義上的隨機數，是一個僞隨機數，它是根據一個數，稱爲種子，爲基準以某個遞推公式推算出來的係數

楊輝三角問題：
118~~~~~

 public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> result = new ArrayList<>();
        if(numRows<1) return result;
        for(int i=0;i<numRows;++i){
            List<Integer> list = Arrays.asList(new Integer[i+1]);
            list.set(0,1);list.set(i,1);
            for(int j=1;j<i;j++){
                list.set(j,result.get(i-1).get(j-1)+result.get(i-1).get(j));
            }
            result.add(list);
        }
        return result;
    }

List 是一種非常好用的數據結構，需要將一個數組轉換爲List，可以使用 java.util 包下的 Array.asList方法，在程序中有體現。(對於使用指南，直接點擊上邊的Array List)。
此處對楊輝三角的部分特點進行揭示：：

1. 首先看第n行數：1，11，121，1331…都是11次冪
2. 再看第n行的和：1，2，4，8…都是2次冪
3. 斜列的和爲拐角處元素的值
4. 隱藏了斐波那契數列：1，1，2，3，5，8…

上邊的這道題算是對楊輝三角的整體的遍歷，還收藏了一道關於楊輝三角的單行查詢的題
119~~~~~~

public List<Integer> getRow(int rowIndex) {
        List<Integer>res = new ArrayList<>(rowIndex+1);
        long index=1;
        for(int i=0;i<=rowIndex;i++){
            res.add((int)index);
            index = index*(rowIndex-i)/(i+1);
        }
        return res;
    }

算法~數學 ^ _ ^
通過了解楊輝三角的內在特點，想到一種方法，通過計算11^n來計算所要求的行的數字串，然後提取各個位上的數字，進行存儲輸出……
首先插入計算11的n次冪的代碼：

int pow(int n){
int sum = 1; int tmp = 11;
while(n!=0){
  if(n&1==1){ sum*=tmp;}
  tmp*=tmp; n=n>>1;
  }
  return result;}

之後即可進行11的次冪運算
此處有兩種方法進行提取操作：

• 依次提取計算結果的每位上的數字，通過十六進制&和>>運算，存進向量——可以執行
• 直接將數字轉化爲字符串

 sprintf(temp, "%d", num);
 for (register int i=0; i<strlen(temp); i++) {cout << temp[i] << endl;}

————完成