Rename the common modules in Java, C++ and C.

codes/cpp/utils/CMakeLists.txt

@@ -0,0 +1,4 @@
+add_executable(utils
+        common.hpp print_utils.hpp
+        list_node.hpp tree_node.hpp
+        vertex.hpp)

codes/cpp/utils/common.hpp

@@ -0,0 +1,28 @@
+/**
+ * File: common.hpp
+ * Created Time: 2021-12-19
+ * Author: Krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <algorithm>
+#include <chrono>
+#include <deque>
+#include <iostream>
+#include <list>
+#include <queue>
+#include <random>
+#include <set>
+#include <stack>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "list_node.hpp"
+#include "print_utils.hpp"
+#include "tree_node.hpp"
+#include "vertex.hpp"
+
+using namespace std;

codes/cpp/utils/list_node.hpp

@@ -0,0 +1,48 @@
+/**
+ * File: list_node.hpp
+ * Created Time: 2021-12-19
+ * Author: Krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <iostream>
+using namespace std;
+
+/* Definition for a singly-linked list node */
+struct ListNode {
+    int val;
+    ListNode *next;
+    ListNode(int x) : val(x), next(nullptr) {
+    }
+};
+
+/* Generate a linked list with a vector */
+ListNode *vecToLinkedList(vector<int> list) {
+    ListNode *dum = new ListNode(0);
+    ListNode *head = dum;
+    for (int val : list) {
+        head->next = new ListNode(val);
+        head = head->next;
+    }
+    return dum->next;
+}
+
+/* Get a list node with specific value from a linked list */
+ListNode *getListNode(ListNode *head, int val) {
+    while (head != nullptr && head->val != val) {
+        head = head->next;
+    }
+    return head;
+}
+
+/* Free the memory allocated to a linked list */
+void freeMemoryLinkedList(ListNode *cur) {
+    // 释放内存
+    ListNode *pre;
+    while (cur != nullptr) {
+        pre = cur;
+        cur = cur->next;
+        delete pre;
+    }
+}

codes/cpp/utils/print_utils.hpp

@@ -0,0 +1,229 @@
+/**
+ * File: print_utils.hpp
+ * Created Time: 2021-12-19
+ * Author: Krahets (krahets@163.com), msk397 (machangxinq@gmail.com), LoneRanger(836253168@qq.com)
+ */
+
+#pragma once
+
+#include "list_node.hpp"
+#include "tree_node.hpp"
+#include <climits>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+/* Expose the underlying storage of the priority_queue container */
+template <typename T, typename S, typename C> S &Container(priority_queue<T, S, C> &pq) {
+    struct HackedQueue : private priority_queue<T, S, C> {
+        static S &Container(priority_queue<T, S, C> &pq) {
+            return pq.*&HackedQueue::c;
+        }
+    };
+    return HackedQueue::Container(pq);
+}
+
+/* Find an element in a vector */
+template <typename T> int vecFind(const vector<T> &vec, T ele) {
+    int j = INT_MAX;
+    for (int i = 0; i < vec.size(); i++) {
+        if (vec[i] == ele) {
+            j = i;
+        }
+    }
+    return j;
+}
+
+/* Concatenate a vector with a delim */
+template <typename T> string strJoin(const string &delim, const T &vec) {
+    ostringstream s;
+    for (const auto &i : vec) {
+        if (&i != &vec[0]) {
+            s << delim;
+        }
+        s << i;
+    }
+    return s.str();
+}
+
+/* Repeat a string for n times */
+string strRepeat(string str, int n) {
+    ostringstream os;
+    for (int i = 0; i < n; i++)
+        os << str;
+    return os.str();
+}
+
+/* Print an Array */
+template <typename T> void printArray(T *arr, int n) {
+    cout << "[";
+    for (int i = 0; i < n - 1; i++) {
+        cout << arr[i] << ", ";
+    }
+    if (n >= 1)
+        cout << arr[n - 1] << "]" << endl;
+    else
+        cout << "]" << endl;
+}
+
+/* Get the Vector String object */
+template <typename T> string getVectorString(vector<T> &list) {
+    return "[" + strJoin(", ", list) + "]";
+}
+
+/* Print a vector */
+template <typename T> void printVector(vector<T> list) {
+    cout << getVectorString(list) << '\n';
+}
+
+/* Print a vector matrix */
+template <typename T> void printVectorMatrix(vector<vector<T>> &matrix) {
+    cout << "[" << '\n';
+    for (vector<T> &list : matrix)
+        cout << "  " + getVectorString(list) + "," << '\n';
+    cout << "]" << '\n';
+}
+
+/* Print a linked list */
+void printLinkedList(ListNode *head) {
+    vector<int> list;
+    while (head != nullptr) {
+        list.push_back(head->val);
+        head = head->next;
+    }
+
+    cout << strJoin(" -> ", list) << '\n';
+}
+
+/**
+ * This tree printer is borrowed from TECHIE DELIGHT
+ * https://www.techiedelight.com/c-program-print-binary-tree/
+ */
+struct Trunk {
+    Trunk *prev;
+    string str;
+    Trunk(Trunk *prev, string str) {
+        this->prev = prev;
+        this->str = str;
+    }
+};
+
+/* Helper function to print branches of the binary tree */
+void showTrunks(Trunk *p) {
+    if (p == nullptr) {
+        return;
+    }
+
+    showTrunks(p->prev);
+    cout << p->str;
+}
+
+/* Print a binary tree */
+void printTree(TreeNode *root, Trunk *prev, bool isLeft) {
+    if (root == nullptr) {
+        return;
+    }
+
+    string prev_str = "    ";
+    Trunk trunk(prev, prev_str);
+
+    printTree(root->right, &trunk, true);
+
+    if (!prev) {
+        trunk.str = "———";
+    } else if (isLeft) {
+        trunk.str = "/———";
+        prev_str = "   |";
+    } else {
+        trunk.str = "\\———";
+        prev->str = prev_str;
+    }
+
+    showTrunks(&trunk);
+    cout << " " << root->val << endl;
+
+    if (prev) {
+        prev->str = prev_str;
+    }
+    trunk.str = "   |";
+
+    printTree(root->left, &trunk, false);
+}
+
+/* The interface of the tree printer */
+void printTree(TreeNode *root) {
+    printTree(root, nullptr, false);
+}
+
+/* Print a stack */
+template <typename T> void printStack(stack<T> stk) {
+    // Reverse the input stack
+    stack<T> tmp;
+    while (!stk.empty()) {
+        tmp.push(stk.top());
+        stk.pop();
+    }
+    // Generate the string to print
+    ostringstream s;
+    bool flag = true;
+    while (!tmp.empty()) {
+        if (flag) {
+            s << tmp.top();
+            flag = false;
+        } else
+            s << ", " << tmp.top();
+        tmp.pop();
+    }
+    cout << "[" + s.str() + "]" << '\n';
+}
+
+/* Print a queue */
+template <typename T> void printQueue(queue<T> queue) {
+    // Generate the string to print
+    ostringstream s;
+    bool flag = true;
+    while (!queue.empty()) {
+        if (flag) {
+            s << queue.front();
+            flag = false;
+        } else
+            s << ", " << queue.front();
+        queue.pop();
+    }
+    cout << "[" + s.str() + "]" << '\n';
+}
+
+/* Print a deque */
+template <typename T> void printDeque(deque<T> deque) {
+    // Generate the string to print
+    ostringstream s;
+    bool flag = true;
+    while (!deque.empty()) {
+        if (flag) {
+            s << deque.front();
+            flag = false;
+        } else
+            s << ", " << deque.front();
+        deque.pop_front();
+    }
+    cout << "[" + s.str() + "]" << '\n';
+}
+
+/* Print a HashMap */
+// 定义模板参数 TKey 和 TValue，用于指定键值对的类型
+template <typename TKey, typename TValue> void printHashMap(unordered_map<TKey, TValue> map) {
+    for (auto kv : map) {
+        cout << kv.first << " -> " << kv.second << '\n';
+    }
+}
+
+/* Print a Heap (PriorityQueue) */
+template <typename T, typename S, typename C> void printHeap(priority_queue<T, S, C> &heap) {
+    vector<T> vec = Container(heap);
+    cout << "堆的数组表示：";
+    printVector(vec);
+    cout << "堆的树状表示：" << endl;
+    TreeNode *root = vecToTree(vec);
+    printTree(root);
+    freeMemoryTree(root);
+}

codes/cpp/utils/tree_node.hpp

@@ -0,0 +1,72 @@
+/**
+ * File: tree_node.hpp
+ * Created Time: 2021-12-19
+ * Author: Krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <limits.h>
+
+/* Definition for a binary tree node */
+struct TreeNode {
+    int val{};
+    int height = 0;
+    TreeNode *parent{};
+    TreeNode *left{};
+    TreeNode *right{};
+    TreeNode() = default;
+    explicit TreeNode(int x, TreeNode *parent = nullptr) : val(x), parent(parent) {
+    }
+};
+
+/* Generate a binary tree with a vector */
+TreeNode *vecToTree(vector<int> list) {
+    if (list.empty())
+        return nullptr;
+
+    auto *root = new TreeNode(list[0]);
+    queue<TreeNode *> que;
+    que.emplace(root);
+    size_t n = list.size(), i = 0;
+    while (!que.empty()) {
+        auto node = que.front();
+        que.pop();
+        if (++i >= n)
+            break;
+        // INT_MAX represent null
+        if (list[i] != INT_MAX) {
+            node->left = new TreeNode(list[i]);
+            que.emplace(node->left);
+        }
+        if (++i >= n)
+            break;
+        if (list[i] != INT_MAX) {
+            node->right = new TreeNode(list[i]);
+            que.emplace(node->right);
+        }
+    }
+
+    return root;
+}
+
+/* Get a tree node with specific value in a binary tree */
+TreeNode *getTreeNode(TreeNode *root, int val) {
+    if (root == nullptr)
+        return nullptr;
+    if (root->val == val)
+        return root;
+    TreeNode *left = getTreeNode(root->left, val);
+    TreeNode *right = getTreeNode(root->right, val);
+    return left != nullptr ? left : right;
+}
+
+/* Free the memory allocated to a tree */
+void freeMemoryTree(TreeNode *root) {
+    if (root == nullptr)
+        return;
+    freeMemoryTree(root->left);
+    freeMemoryTree(root->right);
+    // 释放内存
+    delete root;
+}

codes/cpp/utils/vertex.hpp

@@ -0,0 +1,35 @@
+/**
+ * File: vertex.hpp
+ * Created Time: 2023-03-02
+ * Author: Krahets (krahets@163.com)
+ */
+
+#pragma once
+
+#include <vector>
+using namespace std;
+
+/* 顶点类 */
+struct Vertex {
+    int val;
+    Vertex(int x) : val(x) {
+    }
+};
+
+/* 输入值列表 vals ，返回顶点列表 vets */
+vector<Vertex *> valsToVets(vector<int> vals) {
+    vector<Vertex *> vets;
+    for (int val : vals) {
+        vets.push_back(new Vertex(val));
+    }
+    return vets;
+}
+
+/* 输入顶点列表 vets ，返回值列表 vals */
+vector<int> vetsToVals(vector<Vertex *> vets) {
+    vector<int> vals;
+    for (Vertex *vet : vets) {
+        vals.push_back(vet->val);
+    }
+    return vals;
+}