Improve

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

Author: begeekmyfriend

005_longest_palindromic_substring/longest_palindromic_substring.c

@@ -2,21 +2,61 @@
 #include <stdlib.h>
 #include <string.h>
 
-static void find(char *s, int len, int low, int high, int *max_size, char *palindrome) {
-    while (low >= 0 && high < len && s[low] == s[high]) {
-        low--;
-        high++;
-    }
-    low++;
-    high--;
+static inline int min(int a, int b)
+{
+    return a < b ? a : b;
+}
+
+static int manacher(char *s, char output[])
+{
+    int i, j;
+    char s2[1000] = { '\0' };
 
-    if (high - low + 1 > *max_size) {
-        *max_size = high - low + 1;
-        memcpy(palindrome, s + low, *max_size);
+    s2[0] = '$';
+    for (i = 0; s[i] != '\0'; i++) {
+        s2[(i<<1)+1] = '#';
+        s2[(i<<1)+2] = s[i];
     }
+    s2[(i<<1)+1] = '#';
+    int len = (i<<1)+2;
+    s2[len] = '\0';
+    
+    int p[1000] = { 0 }; // 以s2中某一点为中心的回文半径
+    int id = 0; // 回文的中心点
+    int limit = 0; // 最长回文的右边界点
+    int maxLen = 0; // 最大回文长度
+    int maxId = 0; // 最长回文的中心点
+    for (i = 1; i < len; i++) {
+        if (i < limit) {
+            p[i] = min(p[2*id-i], limit-i);
+        } else {
+            p[i] = 1;
+        }
+        
+        while (s2[i+p[i]] == s2[i-p[i]]) {
+            p[i]++;
+        }
+        
+        if (i+p[i] > limit) {
+            limit = i+p[i];
+            id = i;
+        }
+        if (maxLen < p[i]-1) {
+            maxLen = p[i]-1;
+            maxId = i;
+        }
+    }
+    
+    for (j = 0, i = maxId - maxLen; i <= maxId+maxLen; i++) {
+        if (s2[i] != '#') {
+            output[j++] = s2[i];
+        }
+    }
+    return maxLen;
 }
 
-static char *longestPalindrom(char *s) {
+static char *longestPalindrom(char *s)
+{
     int i;
     if (s == NULL) {
         return NULL;
@@ -30,13 +70,8 @@ static char *longestPalindrom(char *s) {
     char *palindrome = malloc(1000);
     memset(palindrome, 0, sizeof(palindrome));
 
-    int max_size = 0;
-    for (i = 0; i < len; i++) {
-        /* start from the middle and scan both two sides */
-        find(s, len, i, i, &max_size, palindrome);
-        find(s, len, i, i + 1, &max_size, palindrome);
-    }
-
+    int size = manacher(s, palindrome);
+    palindrome[size] = '\0';
     return palindrome;
 }
 

070_climbing_stairs/climb_stairs.c

@@ -2,18 +2,18 @@
 #include <stdlib.h>
 #include <string.h>
 
-static int recursive(int n, int *count)
+static int dfs(int n, int *count)
 {
     if (n == 0) {
         return 0;
     } else if (count[n] > 0) {
         return count[n];
     } else {
         if (n >= 1) {
-            count[n] += recursive(n - 1, count);
+            count[n] += dfs(n - 1, count);
         }
         if (n >= 2) {
-            count[n] += recursive(n - 2, count);
+            count[n] += dfs(n - 2, count);
         }
         return count[n];
     }
@@ -25,7 +25,7 @@ static int climbStairs(int n)
     memset(count, 0, (n + 1) * sizeof(int));
     count[1] = 1;
     count[2] = 2;
-    return recursive(n, count);
+    return dfs(n, count);
 }
 
 int main(int argc, char **argv)

087_scramble_string/scramble_string.c

@@ -49,10 +49,9 @@ static bool scramble(char *s1, int low1, int high1, char *s2, int low2, int high
     }
 }
 
-static bool isScramble(char* s1, char* s2) {
-    int len1 = strlen(s1);
-    int len2 = strlen(s2);
-    return scramble(s1, 0, len1 - 1, s2, 0, len2 - 1);
+static bool isScramble(char* s1, char* s2)
+{
+    return scramble(s1, 0, strlen(s1) - 1, s2, 0, strlen(s2) - 1);
 }
 
 int main(int argc, char **argv)

105_construct_binary_tree_from_preorder_and_inorder_traversal/binary_tree_build.c

@@ -1,6 +1,15 @@
 #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)
+
 struct hlist_node;
 
 struct hlist_head {
@@ -15,11 +24,6 @@ static inline void INIT_HLIST_HEAD(struct hlist_head *h) {
     h->first = NULL;
 }
 
-static inline void INIT_HLIST_NODE(struct hlist_node *n) {
-    n->next = NULL;
-    n->pprev = NULL;
-}
-
 static inline int hlist_empty(struct hlist_head *h) {
     return !h->first;
 }
@@ -44,15 +48,6 @@ static inline void hlist_del(struct hlist_node *n)
     }
 }
 
-#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 TreeNode {
     int val;
     struct TreeNode *left;
@@ -87,18 +82,17 @@ static struct TreeNode *node_new(int val)
     return tn;
 }
 
-static struct TreeNode *recursive(int *preorder, int pre_low, int pre_high,
-                                  int *inorder, int in_low, int in_high,
-                                  struct hlist_head *in_heads, int size)
+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)
 {
     if (in_low > in_high || pre_low > pre_high) {
         return NULL;
     }
     struct TreeNode *tn = malloc(sizeof(*tn));
     tn->val = preorder[pre_low];
     int index = find(preorder[pre_low], size, in_heads);
-    tn->left = recursive(preorder, pre_low + 1, pre_low + (index - in_low), inorder, in_low, index - 1, in_heads, size);
-    tn->right = recursive(preorder, pre_high - (in_high - index - 1), pre_high, inorder, index + 1, in_high, in_heads, size);
+    tn->left = dfs(preorder, pre_low + 1, pre_low + (index - in_low), inorder, in_low, index - 1, in_heads, size);
+    tn->right = dfs(preorder, pre_high - (in_high - index - 1), pre_high, inorder, index + 1, in_high, in_heads, size);
     return tn;
 }
 
@@ -122,49 +116,7 @@ static struct TreeNode *buildTree(int *preorder, int preorderSize, int *inorder,
         node_add(inorder[i], i, inorderSize, in_heads);
     }
 
-#if 0
-    struct hlist_head *pre_heads = malloc(preorderSize * sizeof(*pre_heads));
-    for (i = 0; i < preorderSize; i++) {
-        INIT_HLIST_HEAD(&pre_heads[i]);
-    }
-    for (i = 0; i < inorderSize; i++) {
-        node_add(preorder[i], i, preorderSize, pre_heads);
-    }
-
-    int last_index, level = 0;
-    struct TreeNode **stack = malloc(preorderSize * sizeof(*stack));
-    struct TreeNode *tn, *root = NULL;
-    for (i = 0; i < preorderSize; i++) {
-        if (i == 0) {
-            tn = root = node_new(preorder[0]);
-            last_index = find(preorder[0], inorderSize, in_heads);
-            stack[level++] = root;
-        } else {
-            int index = find(preorder[i], inorderSize, in_heads);
-            if (index < last_index) {
-                tn->left = node_new(preorder[i]);
-                tn = tn->left;
-            } else {
-                for (j = index - 1; j >= 0; j--) {
-                    if (find(inorder[j], preorderSize, pre_heads) < i) {
-                        break;
-                    }
-                }
-                /* find the parent of the right child */
-                while (stack[--level]->val != inorder[j]) {}
-                tn = stack[level++];
-                tn->right = node_new(preorder[i]);
-                tn = tn->right;
-            }
-            stack[level++] = tn;
-            last_index = index;
-        }
-    }
-
-    return root;
-#else
-    return recursive(preorder, 0, preorderSize - 1, inorder, 0, inorderSize - 1, in_heads, inorderSize);
-#endif
+    return dfs(preorder, 0, preorderSize - 1, inorder, 0, inorderSize - 1, in_heads, inorderSize);
 }
 
 static void dump(struct TreeNode *node)

106_construct_binary_tree_from_inorder_and_postorder_traversal/binary_tree_build.c

@@ -1,6 +1,15 @@
 #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)
+
 struct hlist_node;
 
 struct hlist_head {
@@ -15,11 +24,6 @@ static inline void INIT_HLIST_HEAD(struct hlist_head *h) {
     h->first = NULL;
 }
 
-static inline void INIT_HLIST_NODE(struct hlist_node *n) {
-    n->next = NULL;
-    n->prev = NULL;
-}
-
 static inline int hlist_empty(struct hlist_head *h) {
     return !h->first;
 }
@@ -44,15 +48,6 @@ static inline void hlist_del(struct hlist_node *n)
     }
 }
 
-#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 TreeNode {
     int val;
     struct TreeNode *left;
@@ -96,25 +91,23 @@ static void node_add(int val, int index, int size, struct hlist_head *heads)
     hlist_add_head(&on->node, &heads[hash]);
 }
 
-static struct TreeNode *recursive(int *inorder, int in_low, int in_high,
-                                  int *postorder, int post_low, int post_high,
-                                  struct hlist_head *in_heads, int size)
+static struct TreeNode *dfs(int *inorder, int in_low, int in_high, int *postorder,
+                            int post_low, int post_high, struct hlist_head *in_heads, int size)
 {
     if (in_low > in_high || post_low > post_high) {
         return NULL;
     }
     struct TreeNode *tn = malloc(sizeof(*tn));
     tn->val = postorder[post_high];
     int index = find(postorder[post_high], size, in_heads);
-    tn->left = recursive(inorder, in_low, index - 1, postorder, post_low, post_low + (index - 1 - in_low), in_heads, size);
-    tn->right = recursive(inorder, index + 1, in_high, postorder, post_high - (in_high - index), post_high - 1, in_heads, size);
+    tn->left = dfs(inorder, in_low, index - 1, postorder, post_low, post_low + (index - 1 - in_low), in_heads, size);
+    tn->right = dfs(inorder, index + 1, in_high, postorder, post_high - (in_high - index), post_high - 1, in_heads, size);
     return tn;
 }
 
 static struct TreeNode *buildTree(int *inorder, int inorderSize, int *postorder, int postorderSize)
 {
     int i, j;
-
     struct hlist_head *in_heads = malloc(inorderSize * sizeof(*in_heads));
     for (i = 0; i < inorderSize; i++) {
         INIT_HLIST_HEAD(&in_heads[i]);
@@ -123,48 +116,7 @@ static struct TreeNode *buildTree(int *inorder, int inorderSize, int *postorder,
         node_add(inorder[i], i, inorderSize, in_heads);
     }
 
-#if 0
-    struct hlist_head *post_heads = malloc(postorderSize * sizeof(*post_heads));
-    for (i = 0; i < postorderSize; i++) {
-        INIT_HLIST_HEAD(&post_heads[i]);
-    }
-    for (i = 0; i < inorderSize; i++) {
-        node_add(postorder[i], i, postorderSize, post_heads);
-    }
-    int last_index, level = 0;
-    struct TreeNode **stack = malloc(postorderSize * sizeof(*stack));
-    struct TreeNode *tn, *root = NULL;
-    for (i = postorderSize - 1; i >= 0; i--) {
-        if (i == postorderSize - 1) {
-            tn = root = node_new(postorder[i]);
-            last_index = find(postorder[i], inorderSize, in_heads);
-            stack[level++] = root;
-        } else {
-            int index = find(postorder[i], inorderSize, in_heads);
-            if (index > last_index) {
-                tn->right = node_new(postorder[i]);
-                tn = tn->right;
-            } else {
-                for (j = index + 1; j < inorderSize; j++) {
-                    if (find(inorder[j], postorderSize, post_heads) > i) {
-                        break;
-                    }
-                }
-                /* find the parent of the left child */
-                while (stack[--level]->val != inorder[j]) {}
-                tn = stack[level++];
-                tn->left = node_new(postorder[i]);
-                tn = tn->left;
-            }
-            stack[level++] = tn;
-            last_index = index;
-        }
-    }
-
-    return root;
-#else
-    return recursive(inorder, 0, inorderSize - 1, postorder, 0, postorderSize - 1, in_heads, inorderSize);
-#endif
+    return dfs(inorder, 0, inorderSize - 1, postorder, 0, postorderSize - 1, in_heads, inorderSize);
 }
 
 static void dump(struct TreeNode *node)