Add C++ implementation

Signed-off-by: begeekmyfriend <[email protected]>

Author: begeekmyfriend

0030_substring_with_concatenation_of_all_words/concatenation.c

@@ -3,48 +3,67 @@
 #include <stdbool.h>
 #include <string.h>
 
+
 #define container_of(ptr, type, member) \
     ((type *)((char *)(ptr) - (size_t)&(((type *)0)->member)))
 
 #define list_entry(ptr, type, member) \
     container_of(ptr, type, member)
 
-#define hlist_for_each(pos, head) \
-    for (pos = (head)->first; pos; pos = pos->next)
-
-struct hlist_node;
+#define list_for_each_entry(pos, head, member) \
+    for (pos = list_entry((head)->next, typeof(*pos), member); \
+         &(pos)->member != (head); \
+         pos = list_entry((pos)->member.next, typeof(*pos), member))
 
-struct hlist_head {
-    struct hlist_node *first;
+struct list_head {
+    struct list_head *next, *prev;
 };
 
-struct hlist_node {
-    struct hlist_node *next, **pprev;
+struct word_node {
+    char *word;
+    int index;
+    struct list_head link;
 };
 
-static inline void INIT_HLIST_HEAD(struct hlist_head *h) {
-    h->first = NULL;
+static inline void INIT_LIST_HEAD(struct list_head *list)
+{
+    list->next = list->prev = list;
 }
 
-static inline int hlist_empty(struct hlist_head *h) {
-    return !h->first;
+static inline int list_empty(const struct list_head *head)
+{
+    return (head->next == head);
 }
 
-static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+static inline void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)
 {
-    if (h->first != NULL) {
-        h->first->pprev = &n->next;
-    }
-    n->next = h->first;
-    n->pprev = &h->first;
-    h->first = n;
+    next->prev = new;
+    new->next = next;
+    new->prev = prev;
+    prev->next = new;
 }
 
-struct word_node {
-    struct hlist_node node;
-    char *word;
-    int index;
-};
+static inline void list_add(struct list_head *_new, struct list_head *head)
+{
+    __list_add(_new, head, head->next);
+}
+
+static inline void list_add_tail(struct list_head *_new, struct list_head *head)
+{
+    __list_add(_new, head->prev, head);
+}
+
+static inline void __list_del(struct list_head *entry)
+{
+    entry->next->prev = entry->prev;
+    entry->prev->next = entry->next;
+}
+
+static inline void list_del(struct list_head *entry)
+{
+    __list_del(entry);
+    entry->next = entry->prev = NULL;
+}
 
 static inline int BKDRHash(char *s, size_t size)
 {
@@ -56,26 +75,23 @@ static inline int BKDRHash(char *s, size_t size)
     return hash % size;
 }
 
-static int find(char *word, struct hlist_head *heads, int size)
+static int find(char *word, struct list_head *heads, int size)
 {
+    struct word_node *wn;
     int hash = BKDRHash(word, size);
-    struct hlist_node *pos;
-    hlist_for_each(pos, &heads[hash]) {
-        struct word_node *wn = list_entry(pos, struct word_node, node);
+    list_for_each_entry(wn, &heads[hash], link) {
         if (!strcmp(wn->word, word)) {
             return wn->index;
         }
     }
     return -1;
 }
 
-static void add(char **words, int index, struct hlist_head *heads, int size, int *freqs)
+static void add(char **words, int index, struct list_head *heads, int size, int *freqs)
 {
-    int hash = BKDRHash(words[index], size);
-    struct hlist_node *pos;
     struct word_node *wn;
-    hlist_for_each(pos, &heads[hash]) {
-        wn = list_entry(pos, struct word_node, node);
+    int hash = BKDRHash(words[index], size);
+    list_for_each_entry(wn, &heads[hash], link) {
         if (!strcmp(wn->word, words[index])) {
             freqs[wn->index]++;
             return;
@@ -84,7 +100,7 @@ static void add(char **words, int index, struct hlist_head *heads, int size, int
     wn = malloc(sizeof(*wn));
     wn->word = words[index];
     wn->index = index;
-    hlist_add_head(&wn->node, &heads[hash]);
+    list_add(&wn->link, &heads[hash]);
     freqs[wn->index]++;
 }
 
@@ -101,9 +117,9 @@ static int *findSubstring(char *s, char **words, int wordsSize, int *returnSize)
 
     int i, j, cap = 10000, count = 0;
     int hash_size = wordsSize;
-    struct hlist_head *heads = malloc(hash_size * sizeof(*heads));
+    struct list_head *heads = malloc(hash_size * sizeof(*heads));
     for (i = 0; i < hash_size; i++) {
-        INIT_HLIST_HEAD(&heads[i]);
+        INIT_LIST_HEAD(&heads[i]);
     }
 
     int *freqs = malloc(wordsSize * sizeof(int));

0105_construct_binary_tree_from_preorder_and_inorder_traversal/binary_tree_build.c

@@ -1,71 +1,67 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
 #define container_of(ptr, type, member) \
     ((type *)((char *)(ptr) - (size_t)&(((type *)0)->member)))
 
 #define list_entry(ptr, type, member) \
     container_of(ptr, type, member)
 
-#define hlist_for_each(pos, head) \
-    for (pos = (head)->first; pos; pos = pos->next)
+#define list_for_each_entry(pos, head, member) \
+    for (pos = list_entry((head)->next, typeof(*pos), member); \
+         &(pos)->member != (head); \
+         pos = list_entry((pos)->member.next, typeof(*pos), member))
 
-struct hlist_node;
+struct list_head {
+    struct list_head *next, *prev;
+};
 
-struct hlist_head {
-    struct hlist_node *first;
+struct TreeNode {
+    int val;
+    struct TreeNode *left;
+    struct TreeNode *right;
 };
 
-struct hlist_node {
-    struct hlist_node *next, **pprev;
+struct order_node {
+    struct list_head link;
+    int val;
+    int index;
 };
 
-static inline void INIT_HLIST_HEAD(struct hlist_head *h) {
-    h->first = NULL;
+static inline void INIT_LIST_HEAD(struct list_head *list)
+{
+    list->next = list->prev = list;
 }
 
-static inline int hlist_empty(struct hlist_head *h) {
-    return !h->first;
+static inline int list_empty(const struct list_head *head)
+{
+    return (head->next == head);
 }
 
-static inline void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
+static inline void __list_add(struct list_head *new, struct list_head *prev, struct list_head *next)
 {
-    if (h->first != NULL) {
-        h->first->pprev = &n->next;
-    }
-    n->next = h->first;
-    n->pprev = &h->first;
-    h->first = n;
+    next->prev = new;
+    new->next = next;
+    new->prev = prev;
+    prev->next = new;
 }
 
-static inline void hlist_del(struct hlist_node *n)
+static inline void list_add(struct list_head *_new, struct list_head *head)
 {
-    struct hlist_node *next = n->next;
-    struct hlist_node **pprev = n->pprev;
-    *pprev = next;
-    if (next != NULL) {
-        next->pprev = pprev;
-    }
+    __list_add(_new, head, head->next);
 }
 
-struct TreeNode {
-    int val;
-    struct TreeNode *left;
-    struct TreeNode *right;
-};
-
-struct order_node {
-    struct hlist_node node;
-    int val;
-    int index;
-};
+static inline void list_add_tail(struct list_head *_new, struct list_head *head)
+{
+    __list_add(_new, head->prev, head);
+}
 
-static int find(int num, int size, struct hlist_head *heads)
+static int find(int num, int size, struct list_head *heads)
 {
-    struct hlist_node *p;
+    struct order_node *on;
     int hash = (num < 0 ? -num : num) % size;
-    hlist_for_each(p, &heads[hash]) {
-        struct order_node *on = list_entry(p, struct order_node, node);
+    list_for_each_entry(on, &heads[hash], link) {
         if (num == on->val) {
             return on->index;
         }
@@ -74,7 +70,7 @@ static int find(int num, int size, struct hlist_head *heads)
 }
 
 static struct TreeNode *dfs(int *preorder, int pre_low, int pre_high, int *inorder,
-                            int in_low, int in_high, struct hlist_head *in_heads, int size)
+                            int in_low, int in_high, struct list_head *in_heads, int size)
 {
     if (in_low > in_high || pre_low > pre_high) {
         return NULL;
@@ -87,21 +83,21 @@ static struct TreeNode *dfs(int *preorder, int pre_low, int pre_high, int *inord
     return tn;
 }
 
-static void node_add(int val, int index, int size, struct hlist_head *heads)
+static void node_add(int val, int index, int size, struct list_head *heads)
 {
     struct order_node *on = malloc(sizeof(*on));
     on->val = val;
     on->index = index;
     int hash = (val < 0 ? -val : val) % size;
-    hlist_add_head(&on->node, &heads[hash]);
+    list_add(&on->link, &heads[hash]);
 }
 
-static struct TreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize)
+struct TreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize)
 {
     int i;
-    struct hlist_head *in_heads = malloc(inorderSize * sizeof(*in_heads));
+    struct list_head *in_heads = malloc(inorderSize * sizeof(*in_heads));
     for (i = 0; i < inorderSize; i++) {
-        INIT_HLIST_HEAD(&in_heads[i]);
+        INIT_LIST_HEAD(&in_heads[i]);
     }
     for (i = 0; i < inorderSize; i++) {
         node_add(inorder[i], i, inorderSize, in_heads);