Improvement

Signed-off-by: begeekmyfriend <begeekmyfriend@gmail.com>

Author: begeekmyfriend

0023_merge_k_sorted_lists/merge_lists.c

@@ -2,141 +2,94 @@
 #include <stdlib.h>
 #include <string.h>
 
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
 struct ListNode {
     int val;
     struct ListNode *next;
 };
 
-struct PriorityQueue {
-    struct ListNode **nodes;
-    int size;
-};
-
 static inline void swap(struct ListNode **a, struct ListNode **b)
 {
-    struct ListNode *tmp = *a;
+    struct ListNode *t = *a;
     *a = *b;
-    *b = tmp;
+    *b = t;
 }
 
-static inline int left(int i) { return i * 2 + 1; }
-static inline int right(int i) { return left(i) + 1; }
-static inline int parent(int i) { return (i - 1) / 2; }
-
-static void queue_dump(struct PriorityQueue *queue)
+static void min_heapify(struct ListNode **nodes, int size, int parent)
 {
-    int i;
-    for (i = 0; i < queue->size; i++) {
-        printf("%d ", queue->nodes[i]->val);
-    }
-    printf("\n");
-}
+    int i = parent;  /* parent is the root */
+    int l = parent * 2 + 1;
+    int r = parent * 2 + 2;
 
-static void percolate_up(struct ListNode **nodes, int i)
-{
-    while (i >= 0 && nodes[parent(i)]->val > nodes[i]->val) {
-        swap(nodes + parent(i), nodes + i);
-        i = parent(i);
+    if (l < size && nodes[l]->val < nodes[i]->val) {
+        i = l;
     }
-}
 
-static void percolate_down1(struct ListNode **nodes, int size, int child)
-{
-    int i, min;
-    for (i = child; i >= 0; i = parent(i)) {
-        if (right(i) < size) {
-            min = nodes[left(i)]->val < nodes[right(i)]->val ? left(i) : right(i);
-        } else {
-            min = left(i);
-        }
-        if (nodes[min]->val < nodes[i]->val) {
-            swap(nodes + min, nodes + i);
-        } else {
-            break;
-        }
+    if (r < size && nodes[r]->val < nodes[i]->val) {
+        i = r;
     }
-}
 
-static void percolate_down2(struct ListNode **nodes, int size)
-{
-    int i, min;
-    for (i = 0; left(i) < size; i = min) {
-        if (right(i) < size) {
-            min = nodes[left(i)]->val < nodes[right(i)]->val ? left(i) : right(i);
-        } else {
-            min = left(i);
-        }
-        if (nodes[min]->val < nodes[i]->val) {
-            swap(nodes + min, nodes + i);
-        } else {
-            break;
-        }
+    /* percolate up */
+    if (i != parent) {
+        swap(&nodes[i], &nodes[parent]);
+        min_heapify(nodes, size, i);
     }
 }
 
-static void heap_build(struct PriorityQueue *queue)
+static void build_min_heap(struct ListNode **nodes, int size)
 {
     int i;
-    for (i = queue->size / 2 - 1; i > 0; i--) {
-        percolate_down1(queue->nodes, queue->size, i);
-    }
-}
 
-static void put(struct PriorityQueue *queue, struct ListNode *node)
-{
-    queue->nodes[queue->size++] = node;
-    percolate_up(queue->nodes, queue->size - 1);
+    if (size <= 0)  return;
+
+    for (i = size / 2; i >= 0; i--) {
+        min_heapify(nodes, size, i);
+    }
 }
 
-static struct ListNode *get(struct PriorityQueue *queue)
+static struct ListNode *get(struct ListNode **nodes, int size)
 {
-    int i;
-    struct ListNode *p = queue->nodes[0];
-    swap(queue->nodes, queue->nodes + queue->size - 1);
-    queue->size--;
-    percolate_down2(queue->nodes, queue->size);
+    struct ListNode *p = nodes[0];
+    nodes[0] = nodes[--size];
+    min_heapify(nodes, size, 0);
     return p;
 }
 
-static struct PriorityQueue *init(int size)
+static void put(struct ListNode **nodes, int size, struct ListNode *n)
 {
-    struct PriorityQueue *queue = malloc(sizeof(*queue));
-    queue->nodes = malloc(size * sizeof(*queue->nodes));
-    queue->size = 0;
-    return queue;
+    nodes[size++] = n;
+    build_min_heap(nodes, size);
 }
 
-static struct ListNode* mergeKLists(struct ListNode** lists, int listsSize)
+struct ListNode* mergeKLists(struct ListNode** lists, int listsSize)
 {
-    if (listsSize == 0) {
-        return NULL;
-    }
-
-    if (listsSize == 1) {
-        return lists[0];
-    }
-
-    int i;
+    int i, size = 0;
     struct ListNode dummy;
-    struct ListNode *prev;
-    struct PriorityQueue *queue = init(listsSize);
-
-    dummy.next = NULL;
-    prev = &dummy;
+    struct ListNode *p = &dummy;
+    struct ListNode **nodes = malloc(listsSize * sizeof(struct ListNode));
 
     for (i = 0; i < listsSize; i++) {
         if (lists[i] != NULL) {
-            put(queue, lists[i]);
+            nodes[size++] = lists[i];
         }
     }
-    heap_build(queue);
 
-    while (queue->size > 0) {
-        struct ListNode *n = get(queue);
-        prev->next = n;
-        prev = n;
+    build_min_heap(nodes, size);
+
+    while (size > 0) {
+        struct ListNode *n = get(nodes, size);
+        size--;
+        p->next = n;
+        p = p->next;
         if (n->next != NULL) {
-            put(queue, n->next);
+            put(nodes, size, n->next);
+            size++;
         }
         n->next = NULL;
     }

0152_maximum_product_subarray/subarray.c

@@ -2,6 +2,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+
 static inline int min(int a, int b)
 {
     return a < b ? a : b;
@@ -31,8 +32,6 @@ static int maxProduct(int* nums, int numsSize)
 
 int main(int argc, char **argv)
 {
-
-
     int i, count = argc - 1;
     int *nums = malloc(count * sizeof(int));
     for (i = 0; i < count; i++) {

0153_find_minimum_in_rotated_sorted_array/minimum.c

@@ -6,17 +6,15 @@ static int findMin(int* nums, int numsSize)
 {
     int lo = 0;
     int hi = numsSize - 1;
-    int min = INT_MAX;
-    while (lo <= hi) {
+    while (lo < hi) {
         int mid = lo + (hi - lo) / 2;        
-        min = min < nums[mid] ? min : nums[mid];
-        if (nums[mid] > nums[hi]) {
-            lo = mid + 1;
+        if (nums[mid] < nums[hi]) {
+            hi = mid;
         } else {
-            hi = mid - 1;
+            lo = mid + 1;
         }
     }
-    return min;
+    return nums[lo];
 }
 
 int main(int argc, char **argv)

0154_find_minimum_in_rotated_sorted_array_ii/minimum.c

@@ -3,16 +3,21 @@
 
 static int findMin(int* nums, int numsSize)
 {
-    if (numsSize == 1) {
-        return nums[0];
-    }
-    int i, j;
-    for (i = 1; i < numsSize; i++) {
-        if (nums[i] < nums[i - 1]) {
-            return nums[i];
+    int lo = 0;
+    int hi = numsSize - 1;
+
+    while (lo < hi) {
+        int mid = lo + (hi - lo) / 2;
+        if (nums[mid] < nums[hi]) {
+            hi = mid;
+        } else if (nums[mid] > nums[hi]) {
+            lo = mid + 1;
+        } else {
+            hi--;
         }
     }
-    return nums[0];
+
+    return nums[lo];
 }
 
 int main(int argc, char **argv)