basic_code

Author: qieguo2016

.gitignore

@@ -2,4 +2,5 @@
 
 .idea
 .history
-.vscode
+.vscode
+**.o

cpp/basic/main.cpp

@@ -0,0 +1,10 @@
+
+#include "sort.h"
+
+int main(int argc, const char **argv) {
+  basic::Sort s;
+  std::vector<int> arr = {3, 8, 9, 1, 8, 3, 4, 2};
+  basic::PrintVector("origin: ", arr);
+  s.QuickSort(arr);
+  basic::PrintVector("sorted: ", arr);
+}

cpp/basic/sort.h

@@ -0,0 +1,35 @@
+#include "util.h"
+#include <vector>
+namespace basic {
+
+class Sort {
+private:
+  void quickSortImp(std::vector<int> &arr, int left, int right) {
+    if (left >= right) {
+      return;
+    }
+    int datum = arr[left];
+    int i = left, j = right;
+    while (i < j) { // 每次循环交换两个数
+      // 因为arr[left]已经缓存到datum，先找右侧比基准小的，直接将arr[left]换掉
+      while (i < j && arr[j] >= datum) {
+        j--;
+      }
+      arr[i] = arr[j];
+      while (i < j && arr[i] < datum) {
+        i++;
+      }
+      arr[j] = arr[i];
+    }
+    arr[i] = datum;
+    quickSortImp(arr, left, i - 1);
+    quickSortImp(arr, i + 1, right);
+  }
+
+public:
+  void QuickSort(std::vector<int> &arr) {
+    return quickSortImp(arr, 0, arr.size() - 1);
+  }
+};
+
+} // namespace basic

cpp/basic/util.h

@@ -0,0 +1,13 @@
+
+#include <iostream>
+#include <string>
+#include <vector>
+namespace basic {
+static void PrintVector(const std::string &msg, const std::vector<int> &input) {
+  std::cout << msg << "[";
+  for (const auto &item : input) {
+    std::cout << item << ",";
+  }
+  std::cout << "]" << std::endl;
+}
+} // namespace basic

cpp/concurrent/blocking_queue.h

@@ -0,0 +1,46 @@
+
+#include <array>
+#include <condition_variable>
+#include <cstdint>
+#include <mutex>
+#include <utility>
+namespace concurrent {
+template <typename T, std::size_t cap> class BlockingQueue {
+public:
+  BlockingQueue(){};
+
+  ~BlockingQueue(){};
+
+  // block while full
+  void push(const T &val) {
+    std::unique_lock<std::mutex> lock(mutex_);
+    producer_cond_.wait(lock, [this] { return w_idx_ - r_idx_ < cap; });
+    data_[w_idx_ % cap] = val;
+    w_idx_++;
+    consumer_cond_.notify_one();
+  };
+
+  // block while empty
+  T pop() {
+    std::unique_lock<std::mutex> lock(mutex_);
+    consumer_cond_.wait(lock, [this] { return w_idx_ > r_idx_; });
+    auto idx = r_idx_ % cap;
+    r_idx_++;
+    producer_cond_.notify_one();
+    return data_[idx];
+  };
+
+  int size() {
+    std::lock_guard<std::mutex> lock(mutex_);
+    return w_idx_ - r_idx_;
+  }
+
+private:
+  std::array<T, cap> data_;
+  std::int64_t r_idx_ = 0;
+  std::int64_t w_idx_ = 0;
+  std::mutex mutex_;
+  std::condition_variable producer_cond_;
+  std::condition_variable consumer_cond_;
+};
+} // namespace concurrent

cpp/concurrent/main.cpp

@@ -0,0 +1,39 @@
+
+#include "blocking_queue.h"
+#include <chrono>
+#include <cstdio>
+#include <iostream>
+#include <thread>
+
+int main() {
+  constexpr int num = 2;
+  std::thread consumers[num], producers[num];
+  concurrent::BlockingQueue<std::int32_t, 5> bq;
+  for (int i = 0; i < num; ++i) {
+    consumers[i] = std::thread([i, &bq] {
+      int n = bq.pop();
+      while (n > 0) {
+        std::printf("---- cc (%d) ---- : %d \n", i, n);
+        n = bq.pop();
+      }
+    });
+    producers[i] = std::thread([i, &bq] {
+      int n = 1;
+      while (n < 10) {
+        std::printf("---- pp (%d) ---- : %d \n", i, i * 100 + n);
+        bq.push(i * 100 + n);
+        n++;
+        std::this_thread::sleep_for(std::chrono::milliseconds(500));
+      }
+      bq.push(-1);
+    });
+  }
+
+  // join them back:
+  for (int i = 0; i < num; ++i) {
+    producers[i].join();
+    consumers[i].join();
+  }
+
+  return 0;
+}

cpp/leetcode/407.接雨水-ii.cpp

@@ -53,22 +53,27 @@
  *
  */
 
+#include <algorithm>
+#include <array>
+#include <functional>
 #include <queue>
+#include <utility>
 #include <vector>
-
 // @lc code=start
 class Solution {
   using pii = std::pair<int, int>;
 
- public:
+public:
   int trapRainWater(std::vector<std::vector<int>> &heightMap) {
+    int res = 0;
     if (heightMap.size() < 3 || heightMap[0].size() < 3) {
-      return 0;
+      return res;
     }
-    std::priority_queue<pii, std::vector<pii>, std::greater<pii>> q;
     int m = heightMap.size();
     int n = heightMap[0].size();
     std::vector<bool> visited(m * n, false);
+    std::priority_queue<pii, std::vector<pii>, std::greater<pii>> q;
+
     // check edge
     for (int i = 0; i < m; i++) {
       for (int j = 0; j < n; j++) {
@@ -80,23 +85,20 @@ class Solution {
       }
     }
 
-    // check all block
-    int res = 0;
-    int dir[] = {-1, 0, 1, 0, -1};  // left/bottom/right/top
+    int dirs[] = {-1, 0, 1, 0, -1};
+    // check every grid
     while (!q.empty()) {
-      pii cur = q.top();
+      auto cur = q.top();
       q.pop();
-      for (int k = 0; k < 4; k++) {
-        int x = cur.second / n + dir[k];
-        int y = cur.second % n + dir[k + 1];
-        int xyi = x * n + y;
-        if (x >= 0 && x < m && y >= 0 && y < n &&
-            !visited[xyi]) {  // not edge
-          if (heightMap[x][y] < cur.first) {
-            res += cur.first - heightMap[x][y];
-          }
-          visited[xyi] = true;
-          q.push({std::max(heightMap[x][y], cur.first), xyi});
+
+      for (int k = 0; k < 4; k++) { // check left/down/right/up
+        int x = cur.second / n + dirs[k];
+        int y = cur.second % n + dirs[k + 1];
+        int idx = x * n + y;
+        if (x >= 0 && x < m && y >= 0 && y < n && !visited[idx]) {
+          res += cur.first > heightMap[x][y] ? cur.first - heightMap[x][y] : 0;
+          visited[idx] = true;
+          q.push({std::max(heightMap[x][y], cur.first), idx});
         }
       }
     }