update

Author: fibers

src/main/java/com/fibers/algorithm/datastructure/Heap.java

@@ -0,0 +1,66 @@
+package com.fibers.algorithm.datastructure;
+
+import com.fibers.utils.Utils;
+
+public abstract class Heap {
+
+    protected int[] h;
+    protected int N;
+
+
+    public Heap(int length) {
+        h = new int[length + 1];
+        N = 0;
+    }
+
+    abstract public void shift_up(int i);
+
+    abstract public void shift_down(int i);
+
+    abstract public void force_push(int v);
+
+    public void push(int v) {
+        if (N < h.length - 1) {
+            N++;
+            h[N] = v;
+            this.shift_up(N);
+        }
+    }
+
+    public int top() {
+        if (N > 0) {
+            return h[1];
+        } else {
+            return -1;
+        }
+    }
+
+    public int bottom(){
+        if (N > 0) {
+            return h[N];
+        } else {
+            return -1;
+        }
+    }
+
+    public int pop() {
+        int v = -1;
+        if (N > 0) {
+            v = h[1];
+            Utils.swap(h, 1, N);
+            N--;
+            this.shift_down(1);
+        }
+        return v;
+    }
+
+    public int[] heap_sort() {
+        int[] a = new int[N];
+        int i = 0;
+        while (N > 0) {
+            a[i] = this.pop();
+            i++;
+        }
+        return a;
+    }
+}

src/main/java/com/fibers/algorithm/datastructure/MinHeap.java

@@ -0,0 +1,58 @@
+package com.fibers.algorithm.datastructure;
+
+import com.fibers.utils.Utils;
+
+public class MinHeap extends Heap {
+
+    public MinHeap(int length) {
+        super(length);
+    }
+
+
+    public static void main(String[] args) {
+
+        MinHeap mh = new MinHeap(10);
+
+        int[] nums = new int[]{3, 1, 4, 6, 7, 10, 2, 5, 9, 8};
+        for (int i : nums) {
+            mh.push(i);
+        }
+
+        Utils.printArray(mh.heap_sort());
+    }
+
+    @Override
+    public void shift_up(int i) {
+        while (i > 1 && h[i] < h[i / 2]) {
+            Utils.swap(h, i, i / 2);
+            i = i / 2;
+        }
+    }
+
+    @Override
+    public void shift_down(int i) {
+        while (2 * i <= N) {
+            int j = 2 * i;
+            if (j < N && h[j] > h[j + 1]) {
+                j += 1;
+            }
+            if (h[i] < h[j]) {
+                break;
+            }
+            Utils.swap(h, i, j);
+            i = j;
+        }
+    }
+
+    @Override
+    public void force_push(int v) {
+        if (N < h.length - 1) {
+            this.push(v);
+        } else {
+            if (v > h[1]) {
+                h[1] = v;
+                this.shift_down(1);
+            }
+        }
+    }
+}

src/main/java/com/fibers/algorithm/leetcode/_023/Solution.java

@@ -0,0 +1,70 @@
+package com.fibers.algorithm.leetcode._023;
+
+import com.fibers.algorithm.datastructure.ListNode;
+import com.fibers.utils.Utils;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        ListNode l11 = new ListNode(1);
+        ListNode l12 = new ListNode(4);
+        ListNode l13 = new ListNode(5);
+        l11.next = l12;
+        l12.next = l13;
+
+        ListNode l21 = new ListNode(1);
+        ListNode l22 = new ListNode(3);
+        ListNode l23 = new ListNode(4);
+        l21.next = l22;
+        l22.next = l23;
+
+        ListNode l31 = new ListNode(2);
+        ListNode l32 = new ListNode(6);
+        l31.next = l32;
+
+        ListNode[] lists = new ListNode[]{l11, l21, l31};
+
+        Solution s = new Solution();
+        ListNode result = s.mergeKLists(lists);
+
+        Utils.printListNode(result);
+
+    }
+
+    public ListNode mergeKLists(ListNode[] lists) {
+        ListNode head = new ListNode(0);
+        ListNode p = head;
+
+        if (lists == null || lists.length == 0) {
+            return head.next;
+        }
+
+        while (true) {
+            int index = compare(lists);
+            if (index == -1) {
+                return head.next;
+            }
+            ListNode node = lists[index];
+
+            p.next = node;
+            lists[index] = node.next;
+
+            p = p.next;
+        }
+    }
+
+    private int compare(ListNode[] lists) {
+
+        int index = -1;
+        int min = Integer.MAX_VALUE;
+
+        for (int i = 0; i < lists.length; i++) {
+            if (lists[i] != null && lists[i].val < min) {
+                min = lists[i].val;
+                index = i;
+            }
+        }
+
+        return index;
+    }
+}

src/main/java/com/fibers/algorithm/leetcode/_024/Solution.java

@@ -0,0 +1,48 @@
+package com.fibers.algorithm.leetcode._024;
+
+import com.fibers.algorithm.datastructure.ListNode;
+import com.fibers.utils.Utils;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        ListNode l11 = new ListNode(1);
+        ListNode l12 = new ListNode(2);
+        ListNode l13 = new ListNode(3);
+        ListNode l14 = new ListNode(4);
+        l11.next = l12;
+        l12.next = l13;
+        l13.next = l14;
+
+        Solution s = new Solution();
+        ListNode result = s.swapPairs(l11);
+
+        Utils.printListNode(result);
+
+    }
+
+    public ListNode swapPairs(ListNode head) {
+        if (head == null || head.next == null) {
+            return head;
+        }
+
+        ListNode parent = new ListNode(-1);
+        parent.next = head;
+
+        ListNode root = parent;
+
+        ListNode prev = head;
+        ListNode next = head.next;
+
+        do {
+            parent.next = next;
+
+            prev.next = next.next;
+            next.next = prev;
+
+            parent = prev;
+        } while ((prev = prev.next) != null && (next = prev.next) != null);
+
+        return root.next;
+    }
+}

src/main/java/com/fibers/algorithm/leetcode/_025/Solution.java

@@ -0,0 +1,83 @@
+package com.fibers.algorithm.leetcode._025;
+
+import com.fibers.algorithm.datastructure.ListNode;
+import com.fibers.utils.Utils;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        ListNode l11 = new ListNode(1);
+        ListNode l12 = new ListNode(2);
+        ListNode l13 = new ListNode(3);
+        ListNode l14 = new ListNode(4);
+        ListNode l15 = new ListNode(5);
+        ListNode l16 = new ListNode(6);
+        ListNode l17 = new ListNode(7);
+
+        l11.next = l12;
+        l12.next = l13;
+        l13.next = l14;
+        l14.next = l15;
+        l15.next = l16;
+        l16.next = l17;
+
+        Solution s = new Solution();
+        ListNode result = s.reverseKGroup(l11, 3);
+
+        Utils.printListNode(result);
+
+    }
+
+
+    public ListNode reverseKGroup(ListNode head, int k) {
+        if (head == null || k == 0) {
+            return head;
+        }
+
+        ListNode prevGroupLast = new ListNode(-1);
+        prevGroupLast.next = head;
+
+        ListNode root = prevGroupLast;
+        ListNode cur = prevGroupLast.next;
+        ListNode curGroupFirst = null;
+        ListNode prev = null;
+        int i = 0;
+
+        while (cur != null) {
+            ListNode next = cur.next;
+            if (i < k) {
+                if (i == 0) {
+                    curGroupFirst = cur;
+                }
+                cur.next = prev;
+                prev = cur;
+                cur = next;
+                i++;
+            } else {
+                prevGroupLast.next = prev;
+                prevGroupLast = curGroupFirst;
+                i = 0;
+                prev = null;
+            }
+        }
+
+        if( i< k){
+            cur = prev;
+            prev = null;
+
+            while (cur != null) {
+                ListNode next = cur.next;
+                cur.next = prev;
+
+                prev = cur;
+                cur = next;
+            }
+
+            prevGroupLast.next = curGroupFirst;
+        }else{
+            prevGroupLast.next = prev;
+        }
+
+        return root.next;
+    }
+}

src/main/java/com/fibers/algorithm/leetcode/_027/Solution.java

@@ -0,0 +1,37 @@
+package com.fibers.algorithm.leetcode._027;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        int nums[] = new int[]{0, 1, 2, 2, 3, 0, 4, 2};
+
+        Solution s = new Solution();
+        int len = s.removeElement(nums, 2);
+
+        System.out.println(len);
+    }
+
+    public int removeElement(int[] nums, int val) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+
+        int first = 0;
+        int last = nums.length - 1;
+
+        while (first <= last) {
+
+            if (nums[first] == val && nums[last] != val) {
+                int temp = nums[first];
+                nums[first] = nums[last];
+                nums[last] = temp;
+            } else if (nums[first] != val) {
+                first++;
+            } else {
+                last--;
+            }
+        }
+
+        return first;
+    }
+}