binary search tree

Author: genkimaru

README.md

@@ -0,0 +1,3 @@
+## practice in leetcode
+https://leetcode.cn/studyplan/top-100-liked/
+

src/main/java/com/leetcode/Practice10.java

@@ -0,0 +1,87 @@
+package com.leetcode;
+
+import com.leetcode.util.ListNode;
+import com.leetcode.util.Utils;
+import java.util.ArrayList;
+
+
+/**
+ *  merge two list
+ */
+public class Practice10 {
+
+/*    public ListNode mergeTwoLists(ListNode head1, ListNode head2) {
+        ListNode newHead, currentNode;
+        ListNode currentHead1 = head1, currentHead2 = head2;
+        if (head1.val < head2.val) {
+            newHead = head1;
+            currentNode = newHead;
+            currentHead1 = head1.next;
+
+        } else if (head1.val > head2.val) {
+            newHead = head2;
+            currentNode = newHead;
+            currentHead2 = head2.next;
+        } else {
+            currentHead1 = head1.next;
+            currentHead2 = head2.next;
+            newHead = head1;
+            newHead.next = head2;
+            currentNode = newHead.next;
+
+        }
+        while (currentHead1 != null && currentHead2 != null) {
+            if (currentHead1.val < currentHead2.val || currentHead2 == null) {
+                currentNode.next = currentHead1;
+                currentHead1 = currentHead1.next;
+
+            } else if (currentHead1.val > currentHead2.val || currentHead1 == null) {
+                currentNode.next = currentHead2;
+                currentHead2 = currentHead2.next;
+            } else {
+                currentHead1 = currentHead1.next;
+                currentHead2 = currentHead2.next;
+                currentNode.next = currentHead1;
+                currentNode.next.next = currentHead2;
+
+            }
+        }
+
+        return newHead;
+    }*/
+
+    public ListNode mergeTwoLists(ListNode head1, ListNode head2) {
+        ArrayList<Integer>  list = new ArrayList<Integer>();
+        while(head1 != null && head2 != null){
+            if(head2 == null || head1.val < head2.val){
+                list.add(head1.val);
+                head1 = head1.next;
+            }else if( head1 == null || head1.val > head2.val){
+                list.add(head2.val);
+                head2 = head2.next;
+            }else{
+                list.add(head1.val);
+                list.add(head2.val);
+                head1 = head1.next;
+                head2 = head2.next;
+            }
+        }
+
+
+        ListNode head = Utils.buildList(list.stream().mapToInt(Integer::intValue).toArray());
+        return head;
+    }
+
+
+    public static void main(String[] args) {
+        int[] arr1 = {1, 2, 4}, arr2 = {1, 3, 4};
+        ListNode head1 = Utils.buildList(arr1);
+        ListNode head2 = Utils.buildList(arr2);
+        ListNode newHead = new Practice10().mergeTwoLists(head1, head2);
+        while (newHead != null) {
+            System.out.println(newHead.val);
+            newHead = newHead.next;
+
+        }
+    }
+}

src/main/java/com/leetcode/Practice10_MergeSortedLists.java

@@ -0,0 +1,47 @@
+package com.leetcode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Practice10_MergeSortedLists {
+    public static List<Integer> mergeSortedLists(List<Integer> list1, List<Integer> list2) {
+        List<Integer> mergedList = new ArrayList<>();
+
+        // Indices for iterating through both lists
+        int i = 0;
+        int j = 0;
+
+        // Iterate through both lists and compare elements
+        while (i < list1.size() && j < list2.size()) {
+            if (list1.get(i) <= list2.get(j)) {
+                mergedList.add(list1.get(i));
+                i++;
+            } else {
+                mergedList.add(list2.get(j));
+                j++;
+            }
+        }
+
+        // Add remaining elements from list1, if any
+        while (i < list1.size()) {
+            mergedList.add(list1.get(i));
+            i++;
+        }
+
+        // Add remaining elements from list2, if any
+        while (j < list2.size()) {
+            mergedList.add(list2.get(j));
+            j++;
+        }
+
+        return mergedList;
+    }
+
+    public static void main(String[] args) {
+        List<Integer> list1 = List.of(1, 3, 5, 7, 9);
+        List<Integer> list2 = List.of(2, 4, 6, 8, 10);
+
+        List<Integer> mergedList = mergeSortedLists(list1, list2);
+        System.out.println("Merged List: " + mergedList);
+    }
+}

src/main/java/com/leetcode/Practice11.java

@@ -0,0 +1,4 @@
+package com.leetcode;
+
+public class Practice11 {
+}

src/main/java/com/leetcode/Practice9.java

@@ -0,0 +1,63 @@
+package com.leetcode;
+
+import com.leetcode.util.ListNode;
+import com.leetcode.util.Utils;
+
+/**
+ *  intersect list
+ */
+public class Practice9 {
+
+
+    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
+        ListNode currentNodeA = null;
+        ListNode currentNodeB = null;
+        for (int i = 1; i <= this.skipA; i++) {
+            if(i == 1){
+                currentNodeA = headA.next;
+            }else{
+                currentNodeA = currentNodeA.next;
+            }
+
+        }
+        for (int i = 1; i <= this.skipB; i++) {
+            if(i == 1){
+                currentNodeB = headB.next;
+            }else{
+                currentNodeB = currentNodeB.next;
+            }
+        }
+        if (currentNodeA != null && currentNodeB != null && currentNodeA.val == currentNodeB.val) {
+            return currentNodeA;
+        } else {
+            return null;
+        }
+
+
+    }
+
+    public static void main(String[] args) {
+
+        int[] listA = {4, 1, 8, 4, 5};
+        int[] listB = {5, 6, 1, 8, 4, 5};
+
+        //  expect : int intersectVal = 8;
+        Practice9 practice9 = new Practice9();
+        practice9.listAHead = Utils.buildList(listA);
+        practice9.listBHead = Utils.buildList(listB );
+        ListNode intersectionNode = practice9.getIntersectionNode(practice9.listAHead, practice9.listBHead);
+        if (intersectionNode != null) {
+            System.out.println(intersectionNode.val);
+        } else {
+            System.out.println("null");
+        }
+    }
+
+    private ListNode listAHead;
+    private ListNode listBHead;
+
+    private int skipA = 2;
+    private int skipB = 3;
+
+
+}

src/main/java/com/leetcode/tree/Practice1.java

@@ -0,0 +1,27 @@
+package com.leetcode.tree;
+
+
+import com.leetcode.util.TreeNode;
+import java.util.List;
+/*
+ * binary tree , inorder-traversal
+ */
+
+
+public class Practice1 {
+
+//    public List<Integer> inorderTraversal(TreeNode root) {
+//
+//    }
+
+
+    public static void main(String[] args) {
+
+
+//        new Practice1().inorderTraversal();
+
+
+    }
+
+
+}

src/main/java/com/leetcode/util/BinarySearchTree.java

@@ -0,0 +1,60 @@
+package com.leetcode.util;
+
+
+/**
+ * Binary search tree
+ *
+ * `recursion` algorithm
+ */
+
+public class BinarySearchTree {
+
+
+    public static TreeNode buildBST(int[] arr) {
+        TreeNode root = new TreeNode(arr[0]);
+        for (int ele : arr) {
+            compareAndAdd(root, new TreeNode(ele));
+        }
+        return root;
+    }
+
+    private static void compareAndAdd(TreeNode root, TreeNode node) {
+        if (node.val > root.val) {
+            if (root.right == null) {
+                root.right = node;
+            } else {
+                compareAndAdd(root.right, node);
+            }
+        } else if (node.val < root.val) {
+            if (root.left == null) {
+                root.left = node;
+            } else {
+                compareAndAdd(root.left, node);
+            }
+        } else {
+            System.out.println("have the same one , drop " + node.val);
+        }
+    }
+
+
+    public static void main(String[] args) {
+        int[] arr = new int[]{4, 2, 3, 1, 5, 7, 6,9,8};
+        TreeNode root = buildBST(arr);
+        inorderTraversal(root);
+
+    }
+
+    private static void inorderTraversal(TreeNode root) {
+        if (root.left != null) {
+            inorderTraversal(root.left);
+        }
+        System.out.println(root.val);
+        if (root.right != null) {
+            inorderTraversal(root.right);
+        }
+
+
+    }
+
+
+}

src/main/java/com/leetcode/util/ListNode.java

@@ -0,0 +1,12 @@
+package com.leetcode.util;
+
+
+public class ListNode {
+    public int val;
+    public ListNode next;
+
+    public ListNode(int x) {
+        val = x;
+        next = null;
+    }
+}

src/main/java/com/leetcode/util/TreeNode.java

@@ -0,0 +1,24 @@
+package com.leetcode.util;
+
+/**
+ * Definition for a binary tree node.
+ */
+
+public class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+
+    public TreeNode() {
+    }
+
+    public TreeNode(int val) {
+        this.val = val;
+    }
+
+   public TreeNode(int val, TreeNode left, TreeNode right) {
+        this.val = val;
+        this.left = left;
+        this.right = right;
+    }
+}

src/main/java/com/leetcode/util/Utils.java

@@ -0,0 +1,28 @@
+package com.leetcode.util;
+
+import com.leetcode.Practice9;
+
+public class Utils {
+
+    /**
+     *
+     * @param arr
+     * @return linked list's head node
+     */
+    public static ListNode buildList(int[] arr  ) {
+        ListNode next = null;
+        ListNode head = null;
+        for(int i =0; i< arr.length-1; i++){
+            if(i == 0) {
+                head = new ListNode(arr[i]);
+                next = new ListNode(arr[i+1]);
+                head.next = next;
+            }else{
+                ListNode current = next;
+                current.next = new ListNode(arr[i+1]);
+                next = current.next;
+            }
+        }
+        return head;
+    }
+}