Leetcode算法解析101+

<center>#104 Maximum Depth of Binary Tree</center>

link
Description:
- Given a binary tree, find its maximum depth.
- The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
Solution:
- 遞歸，以當前節(jié)點為根的樹最大深度是左右子樹中深度更高的那一棵加一

Code:

# code block
public int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int left = maxDepth(root.left);
    int right = maxDepth(root.right);
    return Math.max(left, right) + 1;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#118 Pascal's Triangle</center>

link
Description:
- Given numRows, generate the first numRows of Pascal's triangle.
Input: 5

Output:

[
     [1],
    [1,1],
   [1,2,1],
  [1,3,3,1],
 [1,4,6,4,1]
]

Solution:
- 模擬題，根據(jù)圖上的規(guī)律來進行循環(huán)
- 注意防止數(shù)組越界

Code:

# code block
public List<List<Integer>> generate(int numRows) {
    List<List<Integer>> result = new ArrayList<>();
    if (numRows <= 0) {
        return result;
    }
    List<Integer> firstRow = new ArrayList<Integer>();
    firstRow.add(1);
    result.add(firstRow);
    for (int i = 2; i <= numRows; i++) {
        List<Integer> ithRow = new ArrayList<>();
        List<Integer> lastRow = result.get(result.size() - 1);
        for (int j = 0; j < i; j++) {
            if (j == 0 || j == i - 1) {
                ithRow.add(1);
            } else {
                ithRow.add(lastRow.get(j - 1) + lastRow.get(j));
            }
        }
        result.add(ithRow);
    }
    return result;
}

<center>#119 Pascal's Triangle II</center>

link
Description:
- Given an index k, return the kth row of the Pascal's triangle.
Input: 3
Output: [1,3,3,1]
Assumptions:
- Could you optimize your algorithm to use only O(k) extra space?
Solution:
- Pascal's Triangle 的follow up，重點在于O(k)的空間復雜度
- 通過滾動數(shù)組的方式可以達到O(k)的空間復雜度

Code:

# code block
public List<Integer> getRow(int rowIndex) {
    Integer[][] rows = new Integer[2][rowIndex + 1];
    rows[0][0] = 1;
    rows[1][0] = 1;
    for (int i = 0; i <= rowIndex; i++) {
        for (int j = 1; j < i; j++) {
            rows[i % 2][j] = rows[(i + 1) % 2][j - 1] + rows[(i + 1) % 2][j];
        }
        rows[i % 2][i] = 1;
    }
    List<Integer> result = Arrays.asList(rows[rowIndex % 2]);
    return result;
}

Time Complexity: O(k ^ 2)
Space Complexity: O(k)

<center>#119 Pascal's Triangle II</center>

link
Description:
- Given an index k, return the kth row of the Pascal's triangle.
Input: 3
Output: [1,3,3,1]
Assumptions:
- Could you optimize your algorithm to use only O(k) extra space?
Solution:
- Pascal's Triangle 的follow up，重點在于O(k)的空間復雜度
- 通過滾動數(shù)組的方式可以達到O(k)的空間復雜度

Code:

# code block
public List<Integer> getRow(int rowIndex) {
    Integer[][] rows = new Integer[2][rowIndex + 1];
    rows[0][0] = 1;
    rows[1][0] = 1;
    for (int i = 0; i <= rowIndex; i++) {
        for (int j = 1; j < i; j++) {
            rows[i % 2][j] = rows[(i + 1) % 2][j - 1] + rows[(i + 1) % 2][j];
        }
        rows[i % 2][i] = 1;
    }
    List<Integer> result = Arrays.asList(rows[rowIndex % 2]);
    return result;
}

Time Complexity: O(k ^ 2)
Space Complexity: O(k)

<center>#121 Best Time to Buy and Sell Stock</center>

link
Description:
- Say you have an array for which the ith element is the price of a given stock on day i.
- If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
Input: [7, 1, 5, 3, 6, 4]
Output: 5
Solution:
- 記錄當前遇到的最小值，每次將當前賣出與最小值買入所得利潤與最大利潤進行比較

Code:

# code block
public int maxProfit(int[] prices) {
    if (prices == null || prices.length <= 1) {
        return 0;
    }
    int profit = 0;
    int min = prices[0];
    for (int i = 1; i < prices.length; i++) {
        if (prices[i] > min && prices[i] - min > profit) {
            profit = prices[i] - min;
        }
        min = Math.min(min, prices[i]);
    }
    return profit;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#122 Best Time to Buy and Sell Stock II</center>

link
Description:
- Say you have an array for which the ith element is the price of a given stock on day i.
- Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
Input: [1,2,3,1,6]
Output: 7
Solution:
- 這題可以簡化為找到所有的遞增區(qū)間的總增長

Code:

# code block
public int maxProfit(int[] prices) {
    int profit = 0;
    if (prices == null || prices.length <= 1) {
        return profit;
    }
    for (int i = 1; i < prices.length; i++) {
        if (prices[i] > prices[i - 1]) {
            profit = profit + prices[i] - prices[i - 1];
        }
    }
    return profit;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#125 Valid Palindrome</center>

link
Description:
- Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
Input: "A man, a plan, a canal: Panama"
Output: true
Solution:
- 相向型的兩根指針題
- 熟悉Java的Character和String的API會很容易做

Code:

# code block
public boolean isPalindrome(String s) {
    if (s == null || s.length() == 0) {
        return true;
    }
    int start = 0, end = s.length() - 1;
    char[] sc = s.toCharArray();
    while (start < end) {
        while (start < end && !Character.isLetterOrDigit(sc[start])) {
            start++;
        }
        while (start < end && !Character.isLetterOrDigit(sc[end])) {
            end--;
        }
        if (start < end) {
            char startL = Character.toLowerCase(sc[start]);
            char endL = Character.toLowerCase(sc[end]);
            if (startL != endL) {
                return false;
            }
            start++;
            end--;
        }
    }
    return true;
}

Time Complexity: O(n)

<center>#141 Linked List Cycle</center>

link
Description:
- Given a linked list, determine if it has a cycle in it.
- Follow up:
  - Can you solve it without using extra space?
Solution:
- 最簡單的想法就是用HashSet存訪問過的點，再遇到就返回true
- 不用額外空間的話，就最好使用快慢指針，如果快指針走到底了，就說明無環(huán)，如果快慢指針相遇了，就是有環(huán)

Code:

# code block
public boolean hasCycle(ListNode head) {
    if (head == null || head.next == null) {
        return false;
    }
    ListNode slow = head.next;
    ListNode fast = head.next.next;
    while (fast != null && fast.next != null) {
        if (fast == slow) {
            return true;
        }
        fast = fast.next.next;
        slow = slow.next;
    }
    return false;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#Find Minimum in Rotated Sorted Array</center>

link
Description:
- Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.(i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
- Find the minimum element.
Input: [4 5 6 7 0 1 2]
Output: 4
Assumptions:
- You may assume no duplicate exists in the array.
Solution:
- rotated排序數(shù)組，無重復，滿足使用二分法的條件。取中點的值，如果小于最后一個值，說明從中點到最后一個值為遞增，中間不會有最小值，反之則在。
- 注意點：
  - Corner case：數(shù)組是一個未翻轉(zhuǎn)的排序數(shù)組。

Code:

# code block
public int findMin(int[] nums) {
    if (nums == null || nums.length == 0) {
        return 0;
    }
    int start = 0, end = nums.length - 1;
    while (start < end - 1) {
        int mid = start + (end - start) / 2;
        if (nums[mid] < nums[end]) {
            end = mid;
        } else {
            start = mid;
        }
    }
    return nums[start] < nums[end] ? nums[start] : nums[end];
}

Time Complexity: O(lg n)
Space Complexity: O(1)

<center>#154 Find Minimum in Rotated Sorted Array II</center>

link
Description:
- Follow up for "Find Minimum in Rotated Sorted Array":
  - What if duplicates are allowed?
  - Would this affect the run-time complexity? How and why?
- Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
  (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
- Find the minimum element.
Input: [4 5 6 7 0 0 1 2]
Output: 4
Assumptions:
- The array may contain duplicates.
Solution:
- 復雜度上升到O(n)，不能用二分法。這題重點是不能使用二分法的原因。
- 二分法的本質(zhì)是通過每一次判斷舍棄一半的不可能為答案的值，或者保留有可能是答案的那一半的值。
- 假設(shè)一個數(shù)組全是0，其中有一個-1. 當我們嘗試做二分，不可能在O(1)的時間內(nèi)發(fā)現(xiàn)答案會在哪一邊。
- Code:
```
# code block
public int findMin(int[] nums) {
    int result = Integer.MAX_VALUE;
    for (int i = 0; i < nums.length; i++) {
        result = Math.min(nums[i], result);
    }
    return result;
}
```
Time Complexity: O(n)
Space Complexity: O(1)

<center>#160 Intersection of Two Linked Lists</center>

link
Description:
- Write a program to find the node at which the intersection of two singly linked lists begins.

Input:

A:          a1 → a2
                   ↘
                     c1 → c2 → c3
                   ↗
B:     b1 → b2 → b3

Output: c1
Solution:
- 這道題的基礎(chǔ)解法是使用hashtable遍歷其中一條鏈表，存儲經(jīng)過的節(jié)點，在與另一個鏈表一一比較
- 最優(yōu)的解法請參考如下solution，從算法的角度來講記下來就好，如果有興趣做數(shù)學證明的也可以嘗試一下

Code:

# code block
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if (headA == null || headB == null) {
        return null;
    }
    ListNode pt = headA;
    while (pt.next != null) {
        pt = pt.next;
    }
    pt.next = headB;
    ListNode slow = headA.next;
    ListNode fast = headA.next.next;
    while (fast != null && fast.next != null && slow != fast) {
        fast = fast.next.next;
        slow = slow.next;
    }
    if (fast == null || fast.next == null) {
        pt.next = null;
        return null;
    }
    while (slow != headA) {
        slow = slow.next;
        headA = headA.next;
    }
    pt.next = null;
    return slow;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#162 Find Peak Element</center>

link
Description:
- A peak element is an element that is greater than its neighbors.
- Given an input array where num[i] ≠ num[i+1], find a peak element and return its index.
- The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.
Input: [1, 2, 3, 1]
Output: 2
Assumptions:
- You may imagine that num[-1] = num[n] = -∞.
Solution:
- 二分法，如果中間值大于左右鄰居則為peak，如果中間值小于右鄰居，則保證右邊肯定有peak，如果中間值小于左鄰居，則保證左邊肯定有peak，保留有peak的一半。

Code:

# code block
public int findPeakElement(int[] nums) {
    if (nums == null || nums.length == 0) {
        return -1;
    }
    int start = 0, end = nums.length - 1;
    while (start < end - 1) {
        int mid = start + (end - start) / 2;
        if (nums[mid] > nums[mid - 1] && nums[mid] > nums[mid + 1]) {
            return mid;
        } else if (nums[mid] > nums[mid - 1]) {
            start = mid;
        } else {
            end = mid;
        }
    }
    return nums[start] > nums[end] ? start : end;
}

Time Complexity: O(lg n)
Space Complexity: O(1)

<center>#167 Two Sum II - Input array is sorted </center>

link
Description:
- Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.
- The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.
- You may assume that each input would have exactly one solution and you may not use the same element twice.
Input: numbers={2, 7, 11, 15}, target=9
Output: index1=1, index2=2
Assumptions:
- each input would have exactly one solution
- you may not use the same element twice
Solution:
- Two Sum 的題一般有兩種解法，一種是用hash，一種是用兩根指針。
- 對于本題來說，在排序數(shù)組中兩根指針時間復雜度為O(n)與hash相同，空間復雜度為O(1)優(yōu)于hash的O(n)。
- 所以Two Sum加排序數(shù)組就意味著最優(yōu)解是使用兩根指針.初始化左指針left指向數(shù)組起始，初始化右指針right指向數(shù)組結(jié)尾。根據(jù)已排序這個特性:
  *如果numbers[left]與numbers[right]的和value小于target，說明應(yīng)該增加value,因此left右移指向一個較大的值。
  *如果value大于target，說明應(yīng)該減小value,因此right左移指向一個較小的值。
  *value等于target，則找到，返回left+1和right+1。
  *注意點：
  *注意返回值是1-based索引，不是0-based索引
  *兩個int相加可能會溢出，但是使用int可以通過leetcode的test case，用long更優(yōu)

Code:

# code block
public int[] twoSum(int[] numbers, int target) {
    if (numbers == null || numbers.length < 2) {
        return new int[0];
    }
    int[] result = new int[0];
    // 初始化兩根指針
    int left = 0, right = numbers.length - 1;
    while (left < right) {
        int val = numbers[left] + numbers[right];
        if (val == target) {
            // find the answer and return it
            result = new int[2];
            // the result should be 1-based index not the 0-based
            result[0] = left + 1;
            result[1] = right + 1;
            return result;
        } else if (val > target) {
            // drop the right
            right--;
        } else {
            // drop the left
            left++;
        }
    }
    return result;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#175 Combine Two Tables</center>

link
Description:
- Write a SQL query for a report that provides the following information for each person in the Person table, regardless if there is an address for each of those people:
- FirstName, LastName, City, State

Input:

Table: Person
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| PersonId    | int     |
| FirstName   | varchar |
| LastName    | varchar |
+-------------+---------+
PersonId is the primary key column for this table.
Table: Address
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| AddressId   | int     |
| PersonId    | int     |
| City        | varchar |
| State       | varchar |
+-------------+---------+
AddressId is the primary key column for this table.

Solution:
- 因為每個人不管地址存不存在都要在新表中，所以用person表左外連接address表

Code:

# code block
SELECT a.FirstName, a.LastName, b.City, b.State
FROM Person a
LEFT OUTER JOIN Address b
on a.PersonId = b.PersonId;

<center>#189 Rotate Array</center>

link
Description:
- Rotate an array of n elements to the right by k steps.
- For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].
  Could you do it in-place with O(1) extra space?
Input: [1,2,3,4,5,6,7] 3
Output: [5,6,7,1,2,3,4]
Assumptions:
- 三步翻轉(zhuǎn)法，原理可以通過折紙來模擬。解決O(n)時間O(1)空間數(shù)組或者字符串左右移的最優(yōu)方法。
Solution:

Code:

# code block
public void rotate(int[] nums, int k) {
    if (nums == null || nums.length < 2) {
        return;
    }
    int n = nums.length;
    k = k % n;
    if (k == 0) {
        return;
    }
    reverse(nums, 0, n - k - 1);
    reverse(nums, n - k, n - 1);
    reverse(nums, 0, n - 1);
}

private void reverse(int[] nums, int start, int end) {
    while (start < end) {
        int tmp = nums[start];
        nums[start] = nums[end];
        nums[end] = tmp;
        start++;
        end--;
    }
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#206 Reverse Linked List</center>

link
Description:
- Reverse a singly linked list.
Input: [1,2,3,4]
Output: [4,3,2,1]
Solution:
- 鏈表頭的next記得置null

Code:

# code block
public ListNode reverseList(ListNode head) {
    if (head == null || head.next == null) {
        return head;
    }
    ListNode prev = head;
    ListNode next = head.next;
    while (next != null) {
        ListNode tmp = next.next;
        next.next = prev;
        prev = next;
        next = tmp;
    }
    head.next = null;
    return prev;
}

Time Complexity: O(n)
Space Complexity: O(1)

<center>#216 Combination Sum III</center>

link
Description:
- Find all possible combinations of k numbers that add up to a number n, given that only numbers from 1 to 9 can be used and each combination should be a unique set of numbers.
Input: k = 3, n = 9
Output: [[1,2,6], [1,3,5], [2,3,4]]
Solution:
- 典型的隱式圖DFS遍歷，與combination sum的區(qū)別在于多了combination元素個數(shù)的限制，解決方案是在dfsHelper中加入一個變量記錄還需要的元素的數(shù)量。

Code:

# code block
public List<List<Integer>> combinationSum3(int k, int n) {
    List<List<Integer>> result = new ArrayList<>();
    if (k == 0 || n <= 0) {
        return result;
    }
    dfsHelper(1, n, k, new ArrayList<Integer>(), result);
    return result;
}

private void dfsHelper(int start, int n, int k, List<Integer> state, List<List<Integer>> result) {
    if (k == 0 && n == 0) {
        result.add(new ArrayList<Integer>(state));
        return;
    }
    if (k <= 0 || n <= 0) {
        return;
    }
    for (int i = start; i <= 9; i++) {
        if (i <= n) {
            state.add(i);
            dfsHelper(i + 1, n - i, k - 1, state, result);
            state.remove(state.size() - 1);
        }
    }
}

<center>#217 Contains Duplicate</center>

link
Description:
- Given an array of integers, find if the array contains any duplicates. Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
Input: [1,1]
Output: true
Solution:
- 判斷重復使用哈希表

Code:

# code block
public boolean containsDuplicate(int[] nums) {
    if (nums == null || nums.length <= 1) {
        return false;
    }
    Set<Integer> set = new HashSet<>();
    for (int i = 0; i < nums.length; i++) {
        if (set.contains(nums[i])) {
            return true;
        }
        set.add(nums[i]);
    }
    return false;
}

Time Complexity: O(n)
Space Complexity: O(n)

<center>#283 Move Zeroes</center>

link
Description:
- Given an array nums, write a function to move all 0's to the end of it while maintaining the relative order of the non-zero elements.
Input: [0, 1, 0, 3, 12]
Output: [1, 3, 12, 0, 0]
Assumptions:
- You must do this in-place without making a copy of the array.
- Minimize the total number of operations.
Solution:
- 最基本的兩根指針問題，要求in-place并且最小化操作數(shù)量。最能理解的方法是循環(huán)一遍，去零，再將后面意義置零。假設(shè)這個數(shù)組大部分都是零，那么總操作數(shù)就大約是兩次循環(huán)。
- 優(yōu)化的辦法是使用快慢指針。定義左指針左邊的數(shù)不是零，遍歷數(shù)組，一旦遇到不是零的就將左右指針的值交換，是零就將右指針又移一格。這樣就只遍歷數(shù)組一遍。
- 該算法保證了如果右指針大于左指針，那么左指針向右（包含左指針），右指針向左（不包含右指針）的區(qū)域內(nèi)全部都是0.

Code:

# code block
public void moveZeroes(int[] nums) {
    if (nums == null || nums.length == 0) {
        return;
    }
    int left = 0, right = 0;
    while (right < nums.length) {
        if (nums[right] != 0) {
            int tmp = nums[right];
            nums[right] = nums[left];
            nums[left] = tmp;
            left++;
        }
        right++;
    }
}

Time Complexity: O(n)
Space Complexity: O(1)

最后編輯于：2018.08.18 13:15:33

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點，簡書系信息發(fā)布平臺，僅提供信息存儲服務(wù)。

人面猴
序言：七十年代末，一起剝皮案震驚了整個濱河市，隨后出現(xiàn)的幾起案子，更是在濱河造成了極大的恐慌，老刑警劉巖，帶你破解...
沈念sama閱讀 229,327評論 6贊 537
死咒
序言：濱河連續(xù)發(fā)生了三起死亡事件，死亡現(xiàn)場離奇詭異，居然都是意外死亡，警方通過查閱死者的電腦和手機，發(fā)現(xiàn)死者居然都...
沈念sama閱讀 98,996評論 3贊 423
救了他兩次的神仙讓他今天三更去死
文/潘曉璐我一進店門，熙熙樓的掌柜王于貴愁眉苦臉地迎上來，“玉大人，你說我怎么就攤上這事。” “怎么了？”我有些...
開封第一講書人閱讀 177,316評論 0贊 382
道士緝兇錄：失蹤的賣姜人
文/不壞的土叔我叫張陵，是天一觀的道長。經(jīng)常有香客問我，道長，這世上最難降的妖魔是什么？我笑而不...
開封第一講書人閱讀 63,406評論 1贊 316
?港島之戀（遺憾婚禮）
正文為了忘掉前任，我火速辦了婚禮，結(jié)果婚禮上，老公的妹妹穿的比我還像新娘。我一直安慰自己，他們只是感情好，可當我...
茶點故事閱讀 72,128評論 6贊 410
惡毒庶女頂嫁案：這布局不是一般人想出來的
文/花漫我一把揭開白布。她就那樣靜靜地躺著，像睡著了一般。火紅的嫁衣襯著肌膚如雪。梳的紋絲不亂的頭發(fā)上，一...
開封第一講書人閱讀 55,524評論 1贊 324
城市分裂傳說
那天，我揣著相機與錄音，去河邊找鬼。笑死，一個胖子當著我的面吹牛，可吹牛的內(nèi)容都是我干的。我是一名探鬼主播，決...
沈念sama閱讀 43,576評論 3贊 444
雙鴛鴦連環(huán)套：你想象不到人心有多黑
文/蒼蘭香墨我猛地睜開眼，長吁一口氣：“原來是場噩夢啊……” “哼！你這毒婦竟也來了？” 一聲冷哼從身側(cè)響起，我...
開封第一講書人閱讀 42,759評論 0贊 289
萬榮殺人案實錄
序言：老撾萬榮一對情侶失蹤，失蹤者是張志新（化名）和其女友劉穎，沒想到半個月后，有當?shù)厝嗽跇淞掷锇l(fā)現(xiàn)了一具尸體，經(jīng)...
沈念sama閱讀 49,310評論 1贊 335
?護林員之死
正文獨居荒郊野嶺守林人離奇死亡，尸身上長有42處帶血的膿包…… 初始之章·張勛以下內(nèi)容為張勛視角年9月15日...
茶點故事閱讀 41,065評論 3贊 356
?白月光啟示錄
正文我和宋清朗相戀三年，在試婚紗的時候發(fā)現(xiàn)自己被綠了。大學時的朋友給我發(fā)了我未婚夫和他白月光在一起吃飯的照片。...
茶點故事閱讀 43,249評論 1贊 371
活死人
序言：一個原本活蹦亂跳的男人離奇死亡，死狀恐怖，靈堂內(nèi)的尸體忽然破棺而出，到底是詐尸還是另有隱情，我是刑警寧澤，帶...
沈念sama閱讀 38,821評論 5贊 362
?日本核電站爆炸內(nèi)幕
正文年R本政府宣布，位于F島的核電站，受9級特大地震影響，放射性物質(zhì)發(fā)生泄漏。R本人自食惡果不足惜，卻給世界環(huán)境...
茶點故事閱讀 44,479評論 3贊 347
男人毒藥：我在死后第九天來索命
文/蒙蒙一、第九天我趴在偏房一處隱蔽的房頂上張望。院中可真熱鬧，春花似錦、人聲如沸。這莊子的主人今日做“春日...
開封第一講書人閱讀 34,909評論 0贊 28
一樁弒父案，背后竟有這般陰謀
文/蒼蘭香墨我抬頭看了看天上的太陽。三九已至，卻和暖如春，著一層夾襖步出監(jiān)牢的瞬間，已是汗流浹背。一陣腳步聲響...
開封第一講書人閱讀 36,140評論 1贊 290
情欲美人皮
我被黑心中介騙來泰國打工，沒想到剛下飛機就差點兒被人妖公主榨干…… 1. 我叫王不留，地道東北人。一個月前我還...
沈念sama閱讀 51,984評論 3贊 395
代替公主和親
正文我出身青樓，卻偏偏與公主長得像，于是被迫代替她去往敵國和親。傳聞我的和親對象是個殘疾皇子，可洞房花燭夜當晚...
茶點故事閱讀 48,228評論 2贊 375

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Leetcode算法解析101+

Leetcode算法解析101+

<center>#104 Maximum Depth of Binary Tree</center>

<center>#118 Pascal's Triangle</center>

<center>#119 Pascal's Triangle II</center>

<center>#119 Pascal's Triangle II</center>

<center>#121 Best Time to Buy and Sell Stock</center>

<center>#122 Best Time to Buy and Sell Stock II</center>

<center>#125 Valid Palindrome</center>

<center>#141 Linked List Cycle</center>

<center>#Find Minimum in Rotated Sorted Array</center>

<center>#154 Find Minimum in Rotated Sorted Array II</center>

<center>#160 Intersection of Two Linked Lists</center>

<center>#162 Find Peak Element</center>

<center>#167 Two Sum II - Input array is sorted </center>

<center>#175 Combine Two Tables</center>

<center>#189 Rotate Array</center>

<center>#206 Reverse Linked List</center>

<center>#216 Combination Sum III</center>

<center>#217 Contains Duplicate</center>

<center>#283 Move Zeroes</center>

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Leetcode算法解析101+

<center>#104 Maximum Depth of Binary Tree</center>

<center>#118 Pascal's Triangle</center>

<center>#119 Pascal's Triangle II</center>

<center>#119 Pascal's Triangle II</center>

<center>#121 Best Time to Buy and Sell Stock</center>

<center>#122 Best Time to Buy and Sell Stock II</center>

<center>#125 Valid Palindrome</center>

<center>#141 Linked List Cycle</center>

<center>#Find Minimum in Rotated Sorted Array</center>

<center>#154 Find Minimum in Rotated Sorted Array II</center>

<center>#160 Intersection of Two Linked Lists</center>

<center>#162 Find Peak Element</center>

<center>#167 Two Sum II - Input array is sorted </center>

<center>#175 Combine Two Tables</center>

<center>#189 Rotate Array</center>

<center>#206 Reverse Linked List</center>

<center>#216 Combination Sum III</center>

<center>#217 Contains Duplicate</center>

<center>#283 Move Zeroes</center>

推薦閱讀更多精彩內(nèi)容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频