更新了102题 105题 106题 215题的代码

LuYanFCP · LuYanFCP · commit 1fd7be0524fc · 2020-02-19T03:06:09.000+08:00
diff --git a/cpp/102.py b/cpp/102.py
@@ -0,0 +1,16 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+import Queue
+
+class Solution(object):
+    def levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+        q = Queue.Queue
diff --git a/cpp/105.cpp b/cpp/105.cpp
@@ -0,0 +1,43 @@
+#include <vector>
+#include <algorithm>
+using std::find;
+using std::vector;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+/**
+  * time: 20 ms
+  * Memory: 22.3 MB 
+  */
+
+class Solution {
+public:
+    TreeNode* 
+    buildTree(vector<int>& preorder, vector<int>& inorder) {
+        if (preorder.size() != 0) {
+            auto p_begin = preorder.begin();
+            TreeNode* rs = pi2T(p_begin, inorder.begin(), inorder.end());
+            return rs;
+        }
+        return nullptr;
+    }
+
+    TreeNode*
+    pi2T(vector<int>::const_iterator &p_begin,  vector<int>::const_iterator i_begin, vector<int>::const_iterator i_end) {
+        if (i_begin != i_end) {
+            int val = *p_begin;
+            p_begin++; // 向后走
+            auto mid = find(i_begin, i_end, val);
+            TreeNode* node = new TreeNode(val);
+            node->left = pi2T(p_begin, i_begin, mid);
+            node->right = pi2T(p_begin, mid+1, i_end);
+            return node;
+        }
+        return nullptr;
+    }
+};
+
diff --git a/cpp/106.cpp b/cpp/106.cpp
@@ -0,0 +1,43 @@
+#include <vector>
+#include <algorithm>
+using std::find;
+using std::vector;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+/**
+  * time: 20 ms
+  * Memory: 22.3 MB 
+  */
+
+class Solution {
+public:
+    TreeNode* 
+    buildTree(vector<int>& inorder, vector<int>& postorder) {
+        if (0 != inorder.size()) {
+            auto p_rbegin = postorder.rbegin();
+            TreeNode* rs = ip2T(p_rbegin, inorder.cbegin(), inorder.cend());
+            return rs;
+        }
+        return nullptr;
+    }
+
+    TreeNode*
+    ip2T(vector<int>::reverse_iterator &p_rbegin,  vector<int>::const_iterator i_begin, vector<int>::const_iterator i_end) {
+        if (i_begin != i_end) {
+            int val = *p_rbegin;
+            p_rbegin++; // 向前
+            auto mid = find(i_begin, i_end, val);
+            TreeNode* node = new TreeNode(val);
+            node->right = ip2T(p_rbegin, mid+1, i_end);
+            node->left = ip2T(p_rbegin, i_begin, mid);
+            return node;
+        }
+        return nullptr;
+    }
+};
+
diff --git a/cpp/215.cpp b/cpp/215.cpp
@@ -0,0 +1,90 @@
+#include <vector>
+#include <cstdio>
+#include <algorithm>
+using std::vector;
+using std::partition;
+using std::printf;
+
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        if (nums.size() == 1)
+            return nums[0];
+        int i = 0;
+        int j = nums.size() - 1;
+        int len = nums.size(); // 末尾
+        // 题目不需要判断
+        int p_index = -1;
+        while (i <= j) {
+                      
+            int diff = len - p_index; 
+            if (diff > k) { // 偏前了
+                i = p_index + 1;    // 去后面找
+            } else if (diff < k) {
+                j = p_index - 1;
+            } else {  // 相等
+                return nums[p_index];
+            }
+            p_index = partition(nums, i, j);
+        }
+        return 0;
+    }
+    int partition(vector<int>& nums, int begin, int end) {
+        if (end == begin) {
+            return begin;
+        }
+        int pivot = find_pivot_mid3(nums, begin, end);
+        
+        printf("\n [");
+        for (auto i : nums)
+            printf("%d, ", i);
+        printf("]\n");
+        int i = begin;
+        int j = end - 1;
+        while(1) {
+            while (i < j && nums[i] < pivot) i++;
+            while (i < j && nums[j] >= pivot) j--;
+            if (i < j)  //如果满足则证明还没碰面
+                swap(nums[i], nums[j]);
+            else
+                break;
+        }
+        swap(nums[i], nums[end-1]);
+        printf("\n [");
+        for (auto i : nums)
+            printf("%d, ", i);
+        printf("]\n");
+        return i;
+    }
+
+    int find_pivot_mid3(vector<int>& nums, int begin, int end) {
+        int mid = (end - begin) / 2 + begin;
+        if (nums[mid] < nums[begin]) 
+            swap(nums[mid], nums[begin]);
+        if (nums[end] < nums[mid])
+            swap(nums[end], nums[mid]);
+        if (nums[mid] < nums[begin])
+            swap(nums[mid], nums[begin]);
+
+        swap(nums[mid], nums[end-1]);// 把中间值交换到后面
+        return nums[end-1];
+    }
+
+
+    void swap(int& a, int& b) {
+        int c = a;
+        a = b;
+        b = c;
+    }
+
+};
+
+int main()
+{
+    Solution s;
+    vector<int> vec = {3,2,1,5,6,4};
+    printf("->%d \n", s.findKthLargest(vec, 2));
+    for (auto i : vec)
+        printf("%d. \n", i);
+    
+}
diff --git a/cpp/215_2.cpp b/cpp/215_2.cpp
@@ -0,0 +1,88 @@
+#include <vector>
+#include <cstdio>
+#include <algorithm>
+#include <iterator>
+#include <iostream>
+using std::vector;
+using std::partition_point;
+using std::printf;
+
+class Solution {
+public:
+    int findKthLargest(vector<int>& nums, int k) {
+        if (nums.size() == 1)
+            return nums[0];
+        auto i = nums.begin();
+        auto j = nums.end();
+        auto begin = nums.begin();
+        auto end = nums.end();
+
+        // 题目不需要判断
+        auto p_index = nums.begin() - 1;
+        int mid_val = *i;
+        int diff;
+
+
+        while (i < j) {
+
+            diff = end - p_index;
+            if (diff > k) { // 偏前了
+                i = p_index + 1;    // 去后面找
+            } else if (diff < k) {
+                j = p_index; // 容易出死循环
+            } else {  // 相等
+                // printf("diff: %d", diff);
+                // return 0;
+                return *p_index;
+            }
+            // mid_val = mid(*i, *(j-1), *((j - i) / 2 + i) );
+            int mid_val = *i;
+            // printf("{mid=%d}: ", mid_val);
+            // printf("i=%d----", *i);
+            p_index = partition(i+1, j, [mid_val](int a){return  a < mid_val;});  // 使用很麻烦
+            p_index--;
+            swap(*p_index, *i);
+            // std::copy(begin, p_index, std::ostream_iterator<int>(std::cout, " "));
+            // printf("*");
+            // std::copy(p_index, end, std::ostream_iterator<int>(std::cout, " "));
+            // printf(" p_index=%d", *p_index);
+            // printf(" diff=%d\n", diff);
+
+            // printf("===mid_val: {%d} ===\n", mid_val);
+
+            // int debug;
+            // std::cin >> debug;
+        }
+        return 0;
+    }
+    int mid(int a, int b, int c) {
+        if (a > b)
+            swap(a, b);
+        if (b > c)
+            swap(b, c);
+        if (a > b)
+            swap(a, b);
+        return b;
+    }
+    void swap(int& a, int& b) {
+        int c = a;
+        a = b;
+        b = c;
+    }
+
+};
+
+int main()
+{
+    Solution s;
+    // vector<int> vec1 = {3,2,3,1,2,4,5,5,6};
+    // printf("->%d \n", s.findKthLargest(vec1, 4));
+    // vector<int> vec2 = {3,2,1,5,6,4};
+    // printf("->%d \n", s.findKthLargest(vec2, 2));
+    vector<int> vec3 = {2, 1};
+    printf("->%d \n", s.findKthLargest(vec3, 2));
+    // for (auto i : vec)
+    //     printf("%d. \n", i);
+
+    
+}
diff --git a/python/1.py b/python/1.py
diff --git a/python/215.py b/python/215.py
@@ -0,0 +1,45 @@
+class Solution:
+    """
+    1040 ms	14.71%
+    13.1 MB 100%
+    """
+    def findKthLargest(self, nums, k):
+        i = 0
+        length = len(nums)
+        j = length - 1
+        pivot = -1
+        while i < j:
+            print(nums, i, j, pivot)
+            diff = length - pivot 
+            if diff > k:
+                i = pivot + 1
+            elif diff < k:
+                j = pivot - 1
+            else:
+                return nums[pivot]
+            pivot = self.partition(nums, i, j)
+        return nums[i]
+
+    def partition(self, nums, i, j):
+        if i == j:
+            return i
+        pivot = nums[i]
+        l = i + 1
+        r = j
+        while 1:
+            while l <= r and nums[l] < pivot: 
+                l += 1
+            while l <= r and nums[r] >= pivot:
+                r -= 1
+            if l <= r:
+                nums[l], nums[r] = nums[r], nums[l]
+            else:
+                break
+
+        nums[r], nums[i] = nums[i], nums[r]
+        return r
+
+s = Solution()
+print(s.findKthLargest([3,2,1,5,6,4], 2))
+
+ 
