第一周作业

70works/week1/day5_mergeTwoLists.js

+
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+
+/*
+* 解法一：迭代法
+* */
+function ListNode(val, next) {
+    this.val = (val===undefined ? 0 : val)
+    this.next = (next===undefined ? null : next)
+}
+var mergeTwoLists = function(l1, l2) {
+    let newList = new ListNode(-1);
+    let ptr = newList;
+    while(l1 !== null && l2 !== null){
+        if(l1.val <= l2.val) {
+            ptr.next = l1;
+            l1 = l1.next;
+        } else {
+            ptr.next = l2;
+            l2 = l2.next;
+        }
+        ptr = ptr.next;
+    }
+    ptr.next = l1 === null? l2:l1;
+    return newList.next;
+};

70works/week1/day5_rotateArray.js

+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {void} Do not return anything, modify nums in-place instead.
+ * 解题思路:使用反转数组实现
+ */
+var rotate = function(nums, k) {
+    let n = k % nums.length;
+    reverse(nums,0, nums.length-1);
+    reverse(nums,0, n-1);
+    reverse(nums, n, nums.length-1);
+    return nums;
+};
+var reverse = function (nums,start, end) {
+    while(start　< end){
+        let tmp = nums[start];
+        nums[start] = nums[end];
+        nums[end] = tmp;
+        start ++;
+        end--;
+    }
+}

70works/week1/day6_ mergeSortedArray.cpp

+//解题思路：三指针法，每个数组从后往前遍历
+// p从m+n-1开始 
+// p1为Nums1元素的下标;p2为Nums2元素的下标
+// 遍历结束后将Nums2的剩余元素加进Nums1
+
+class Solution {
+public:
+    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
+    int p1 = m-1;
+    int p2  = n-1;
+    int p = m+n-1;
+    
+    while(p1 >=0 && p2>=0) {
+        if (nums1[p1] > nums2[p2]){
+            nums1[p--] = nums1[p1--];
+        } else {
+            nums1[p--] = nums2[p2--];
+        }
+    }
+    while (p2 >= 0)
+    {
+        /* code */
+        nums1[p--] = nums2[p2--];
+    }
+    
+    }
+};
\ No newline at end of file

70works/week1/day6_moveZero .cpp

+// 两次遍历法：
+// 一次遍历：只要不是非零元素都往前拷贝一份, 用j表示0元素开始存放的位置;
+//  
+class Solution {
+public:
+    void moveZeroes(vector<int>& nums) {
+        int j = 0;
+        for (int i = 0; i < nums.size(); i++)
+        {
+            /* code */
+            if (nums[i] != 0) {
+                nums[j++] = nums[i];
+            }
+        }
+        for(int i =j;i <nums.size();i++) {
+            nums[i] = 0;
+        }
+    }
+};
\ No newline at end of file

70works/week1/day7_trapping_rain_water.js

+/**
+*解题思路:双指针 头尾各一个指针
+ * @param {number[]} height
+ * @return {number}
+ */
+var trap = function(height) {
+let left_max = 0;
+let right_max  =0;
+let ans =0;
+let left = 0;
+let right =  height.length - 1;
+while(left< right) {
+    if(height[left] < height[right]) {
+        height[left]>=left_max?left_max = height[left]:ans += left_max-height[left];left++;
+    }else {
+        height[right] >= right_max? right_max=height[right]:ans += right_max - height[right];right--;  
+    }
+}
+return ans;
+};
\ No newline at end of file

70works/week1/week1_note.md

+### 数组，链表，跳表
+
+* 三者的基本特性：
+    * 数组：可以随机访问，访问速度很快，一般是O(1)；缺点：插入删除操作时间复杂度高
+    * 链表：为了弥补数组增删操作的缺点，用指针去指向下一个元素，以此类推串联成一个链表。删除操作时间复杂度为O(1)。但是访问一个节点的复杂度为O(n）
+    * 跳表：
+        * 结合链表和数组的优点；只能用于元素有序的情况，在一些项目里可以替代平衡树
+        * 有序链表加速的方法
+            * 添加n级索引
+            * 查询的时间复杂度为O(logn
+            * 空间复杂度为O(n)
+
+### 栈 队列 优先队列 双端队列
+
+* 栈：先进后出，添加，删除O(1)
+* 队列：先进先出, 添加，删除O(1)
+* 优先队列：通过设置优先级来实现对元素的访问
+    * javascript没有想java等语言有封装好的函数可供使用，但通过理论知识可以自己手动实现封装一个优先队列的对象。
+* 双端队列：两边可进可出的队列，想象成是栈和队列的结合
+###   关于本周完成作业的理解和收获
+
+* 解题方法
+    * 双指针法：比如移动零，合并数组这种的题，可以在遍历中使用两个指针
+    * 递归法：递归是我一看就会，一写就废的经典代表了，要理解的是，递归本身就是一种循环，通过拆解最近重复子问题，每一次循环都执行同样的工作。还要相应设置好终止条件。旋转数组就可以使用递归方法去解
\ No newline at end of file