Update SinglyLinkedListTest.java

pom.xml

@@ -27,8 +27,8 @@
                     <artifactId>maven-compiler-plugin</artifactId>
                     <version>3.8.1</version>
                     <configuration>
-                        <source>1.8</source>
-                        <target>1.8</target>
+                        <source>17</source>
+                        <target>17</target>
                     </configuration>
                 </plugin>
             </plugins>

src/main/java/com/nbee/solution/practice/BinarySearch.java

@@ -1,26 +1,141 @@
 package com.nbee.solution.practice;
 
+import java.util.Arrays;
+
 class BinarySearch {
-    public static int binarySearchBasic(int[] nums, int target){
-        int i = 0 ,j = nums.length - 1;//设置指针和初始值
-        while (i <= j){//此处的条件是i<=j，而不是i<j，
+    public static int binarySearchBasic(int[] nums, int target) {
+        int i = 0, j = nums.length - 1;//设置指针和初始值
+        while (i <= j) {//此处的条件是i<=j，而不是i<j，
 //            int m = ((i + j) / 2);
             int m = (i + j) >>> 1; //按位右移补零操作符。相当于除2，解决溢出问题
-            if (target < nums[m]){//如果中间值大于目标值，则将右指针向左移动
-               j = m - 1;
-            }
-            else if (nums[m] < target){//如果中间值小于目标值，则将左指针向右移动
+            if (target < nums[m]) {//如果中间值大于目标值，则将右指针向左移动
+                j = m - 1;
+            } else if (nums[m] < target) {//如果中间值小于目标值，则将左指针向右移动
                 i = m + 1;
+            } else {
+                return m;
             }
-            else {
+        }
+        return -1;
+        /**
+         * 为什么必须是i<=j?
+         * 在二分搜索中，使用条件 i <= j 作为循环的继续条件是为了确保在数组只剩下一个元素时，仍然能够检查这个元素。这是因为在二分搜索中
+         * 你每次都在缩小搜索范围，直到没有元素剩余。如果用 i < j 作为条件，当 i 和 j 相等时，这个位置的元素将不会被检查，可能导致漏掉目标元素。
+         */
+    }
+
+
+    public static int binarySearchAlternative(int[] nums, int target) {
+        int i = 0, j = nums.length;
+        while (i < j) {
+            int m = (i + j) >>> 1;
+            if (target < nums[m]) {
+                j = m;
+            } else if (nums[m] < target) {
+                i = m + 1;
+            } else {
                 return m;
             }
         }
         return -1;
     }
+
+    public static int binarySearch01(int[] nums, int target) {
+        int i = 0, j = nums.length;
+        while (1 < j - i) {
+            int m = (i + j) >>> 1;
+            if (target < nums[m]) {
+                j = m;
+            } else {
+                i = m;
+            }
+        }
+        if (nums[i] == target) {
+            return i;
+        } else {
+            return -1;
+        }
+    }
+
+    public static int binarySearchLeftMost(int[] nums, int target) {
+        int i = 0, j = nums.length - 1;
+        int candidate = -1;
+        while (i <= j) {
+            int m = (i + j) >>> 1;
+            if (target < nums[m]) {
+                j = m - 1;
+            } else if (nums[m] < target) {
+                i = m + 1;
+            } else {
+                candidate = m;
+                j = m - 1;
+            }
+        }
+        return candidate;
+    }
+
+    public static int binarySearchRightMost(int[] nums, int target) {
+        int i = 0, j = nums.length - 1;
+        int candidate = -1;
+        while (i <= j) {
+            int m = (i + j) >>> 1;
+            if (target < nums[m]) {
+                j = m - 1;
+            } else if (nums[m] < target) {
+                i = m + 1;
+            } else {
+                candidate = m;
+                i = m + 1;
+            }
+        }
+        return candidate;
+    }
+
+    //改进二分查找
+    public static int binarySearchLeftMost0(int[] nums, int target) {
+        int i = 0, j = nums.length - 1;
+        while (i <= j) {
+            int m = (i + j) >>> 1;
+            if (target < nums[m]) {
+                j = m - 1;
+            } else {
+                i = m + 1;
+            }
+        }
+        return i;
+    }
+
+    public static int binarySearchRightMost0(int[] nums, int target) {
+        int i = 0, j = nums.length - 1;
+        while (i <= j) {
+            int m = (i + j) >>> 1;
+            if (target < nums[m]) {
+                j = m - 1;
+            } else {
+                i = m + 1;
+            }
+        }
+        return i - 1;
+    }
+
     /**
-     * 为什么必须是i<=j?
-     * 在二分搜索中，使用条件 i <= j 作为循环的继续条件是为了确保在数组只剩下一个元素时，仍然能够检查这个元素。这是因为在二分搜索中
-     * 你每次都在缩小搜索范围，直到没有元素剩余。如果用 i < j 作为条件，当 i 和 j 相等时，这个位置的元素将不会被检查，可能导致漏掉目标元素。
+     * 给你一个按照非递减顺序排列的整数数组 nums，和一个目标值 target。请你找出给定目标值在数组中的开始位置和结束位置。
+     * 如果数组中不存在目标值 target，返回 [-1, -1]。
+     * 你必须设计并实现时间复杂度为 O(log n) 的算法解决此问题。
+     *
+     * @param nums
+     * @param target
+     * @return
      */
+    public static int[] searchRange(int[] nums, int target) {
+        if (nums.length == 0){
+            return new int[]{-1,-1};
+        }
+        if (nums.length == 1){
+            return new int[]{0,0};
+        }
+        int left = binarySearchLeftMost(nums, target);
+        int right = binarySearchRightMost(nums,target);
+        return new int[]{left,right};
+    }
 }

src/main/java/com/nbee/solution/practice/DynamicArray.java

@@ -0,0 +1,91 @@
+package com.nbee.solution.practice;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.function.Consumer;
+import java.util.stream.IntStream;
+
+public class DynamicArray implements Iterable<Integer> {
+    private int size = 0;
+    private int capacity = 8;
+    private int[] array = {};
+
+    public void addList(int element) {
+        add(size, element);
+    }
+
+    public void add(int index, int element) {
+        checkAndGrow();
+        if (index < 0 || index > size) {
+            throw new IndexOutOfBoundsException();
+        }
+        if (index >= 0 && index < size) {
+            System.arraycopy(array, index, array, index + 1, size - index);
+        }
+        array[index] = element;
+        size++;
+    }
+
+    private void checkAndGrow() {
+        if (size == 0) {
+            array = new int[capacity];
+        } else if (size == capacity) {
+            capacity = capacity + (capacity >>> 1);
+            int[] newArray = new int[capacity];
+            System.arraycopy(array, 0, newArray, 0, size);
+            array = newArray;
+        }
+    }
+
+    public int getSize() {
+        return size;
+    }
+
+    public int get(int index) {
+        if (index < 0 || index >= size) {
+            throw new IndexOutOfBoundsException();
+        }
+        return array[index];
+    }
+
+    public void forEach0(Consumer<Integer> consumer) {
+        for (int i = 0; i < size; i++) {
+            consumer.accept(array[i]);
+        }
+    }
+
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return new Iterator<Integer>() {
+            int i = 0;
+
+            @Override
+            public boolean hasNext() {
+                return i < size;
+            }
+
+            @Override
+            public Integer next() {
+                return array[i++];
+            }
+        };
+    }
+
+    public IntStream stream() {
+        return IntStream.of(Arrays.copyOfRange(array, 0, size));
+    }
+
+    public int remove(int index) {
+        int removed = array[index];
+        if (index < size - 1) {
+            System.arraycopy(array, index + 1, array, index, size - index - 1);
+            size--;
+        }
+        return removed;
+    }
+    public String toString() {
+        return Arrays.toString(Arrays.copyOfRange(array, 0, size));
+    }
+}
+

src/main/java/com/nbee/solution/practice/SinglyLinkedList.java

@@ -0,0 +1,81 @@
+package com.nbee.solution.practice;
+
+import java.util.Iterator;
+import java.util.function.Consumer;
+
+/**
+ * 链表类
+ */
+public class SinglyLinkedList implements Iterable<Integer> {
+    private Node head;
+
+    @Override
+    public Iterator<Integer> iterator() {
+        return new Iterator<Integer>() {
+            Node p = head;
+
+            @Override
+            public boolean hasNext() {
+                return p != null;
+            }
+
+            @Override
+            public Integer next() {
+                int value = p.value;
+                p = p.next;
+                return value;
+            }
+        };
+    }
+
+    private Node findLast() {
+        if (head == null) {
+            return null;
+        }
+        Node p;
+        for (p = head; p != null; p = p.next) {
+        }
+        return p;
+    }
+
+    public void addLast(int value) {
+        Node last = findLast();
+        if (last == null){
+            addFirst(value);
+            return;
+        }
+        last.next = new Node(value, null);
+    }
+
+    private static class Node {
+        int value;
+        Node next;
+
+        Node(int value, Node next) {
+            this.value = value;
+            this.next = next;
+        }
+    }
+
+    public void addFirst(int value) {
+        //链表为空
+//        head = new Node(value,null);
+        //链表非空，包含了链表为空的情况
+        head = new Node(value, head);
+    }
+
+    public void loop(Consumer<Integer> consumer) {
+        Node p = head;
+        while (p != null) {
+            consumer.accept(p.value);
+            p = p.next;
+        }
+    }
+
+    public void loop0(Consumer<Integer> consumer) {
+        for (Node p = head; p != null; p = p.next) {
+            consumer.accept(p.value);
+        }
+    }
+}
+

src/test/java/com/nbee/solution/practice/BinarySearchTest.java

@@ -2,12 +2,18 @@ package com.nbee.solution.practice;
 
 import org.junit.Assert;
 import org.junit.Test;
+import org.junit.jupiter.api.DisplayName;
+
+import java.util.Arrays;
+
+import static org.junit.jupiter.api.Assertions.*;
 
 public class BinarySearchTest {
+    private int[] nums = {1, 3, 5, 7, 9};
 
     @Test
     public void testBinarySearchBasic_Found() {
-        int[] nums = {1, 3, 5, 7, 9};
+        int[] nums = {1, 3, 5, 7, 9, 11, 13};
         int target = 5;
         int result = BinarySearch.binarySearchBasic(nums, target);
         Assert.assertEquals("Element should be found at index 2", 2, result);
@@ -48,4 +54,86 @@ public class BinarySearchTest {
         int result = BinarySearch.binarySearchBasic(nums, target);
         Assert.assertEquals("Binary search should work on decreasing arrays", 2, result);
     }
+
+    @Test
+    public void testBinarySearchAlternativeFound() {
+        // Test that the method correctly returns the index of an existing element
+        int target = 7;
+        int result = BinarySearch.binarySearchAlternative(nums, target);
+        assertEquals(3, result, "The target should be found at index 3");
+    }
+
+    @Test
+    public void testBinarySearchAlternativeNotFound() {
+        // Test that the method correctly returns -1 when the element is not present
+        int target = 4;
+        int result = BinarySearch.binarySearchAlternative(nums, target);
+        assertEquals(-1, result, "The target should not be found");
+    }
+
+    @Test
+    public void testBinarySearchAlternativeWithEmptyArray() {
+        // Test with an empty array
+        int[] emptyNums = new int[]{};
+        int target = 1;
+        int result = BinarySearch.binarySearchAlternative(emptyNums, target);
+        assertEquals(-1, result, "The target should not be found in an empty array");
+    }
+
+    @Test
+    public void testBinarySearchAlternativeWithSingleElement() {
+        // Test with a single element array
+        int[] singleNums = new int[]{5};
+        int target = 5;
+        int result = BinarySearch.binarySearchAlternative(singleNums, target);
+        assertEquals(0, result, "The target should be found at index 0 in a single-element array");
+    }
+
+    @Test
+    @DisplayName("Test Binary Search Java")
+    public void testBinarySearchJava() {
+        int[] nums = {1, 3, 5, 7, 9};
+        int target = 4;
+        int result = Arrays.binarySearch(nums, target);
+        if (result < 0) {
+            int insertIndex = Math.abs(result + 1);
+            System.out.println("nums: " + Arrays.toString(nums));
+            System.out.println("insertIndex: " + insertIndex);
+            int[] newNums = new int[nums.length + 1];
+            //第一次拷贝
+            System.arraycopy(nums, 0, newNums, 0, nums.length);
+            System.out.println("newNums: " + Arrays.toString(newNums));
+            newNums[insertIndex] = target;
+            // 第二次拷贝
+            System.arraycopy(nums, insertIndex, newNums, insertIndex + 1, nums.length - insertIndex);
+            System.out.println("newNums: " + Arrays.toString(newNums));
+        }
+        System.out.println("result: " + result);
+        assertEquals(-3, result, "The target should not be found");
+    }
+
+    @Test
+    public void testBinarySearchLeftMost() {
+        int[] nums = new int[]{1, 3, 3, 5, 7};
+        assertEquals(0, BinarySearch.binarySearchLeftMost(nums, 1));
+        assertEquals(1, BinarySearch.binarySearchLeftMost(nums, 3));
+    }
+
+    @Test
+    public void testBinarySearchRightMost() {
+        int[] nums = new int[]{1, 3, 3, 5, 5, 5, 5, 5, 7};
+        assertEquals(0, BinarySearch.binarySearchRightMost(nums, 1));
+        assertEquals(2, BinarySearch.binarySearchRightMost(nums, 3));
+        assertEquals(7, BinarySearch.binarySearchRightMost(nums, 5));
+    }
+
+    @Test
+    public void testSearchRange() {
+        int[] nums = {5, 7, 7, 8, 8, 10};
+        int[] nums1 = {1};
+        assertArrayEquals(new int[]{1,2}, BinarySearch.searchRange(nums, 7), "The result should be [1, 2]" );
+        assertArrayEquals(new int[]{3,4}, BinarySearch.searchRange(nums, 8), "The result should be [3, 4]" );
+        assertArrayEquals(new int[]{-1, -1}, BinarySearch.searchRange(nums, 6), "The result should be [-1, -1]");
+        assertArrayEquals(new int[]{0, 0}, BinarySearch.searchRange(nums1, 1), "The result should be [0, 0]");
+    }
 }

src/test/java/com/nbee/solution/practice/DynamicArrayTest.java

@@ -0,0 +1,79 @@
+package com.nbee.solution.practice;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import java.util.List;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertIterableEquals;
+
+class DynamicArrayTest {
+
+    private DynamicArray dynamicArray;
+
+    @BeforeEach
+    public void setUp() {
+        dynamicArray = new DynamicArray();
+    }
+
+    @Test
+    public void testAddListInitial() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        for (int i = 0; i < 4; i++) {
+            System.out.println(dynamicArray.get(i));
+        }
+    }
+
+    @Test
+    public void test01() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        dynamicArray.forEach(element -> {
+            System.out.println(element);
+        });
+    }
+    @Test
+    public void test02() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        for (Integer element : dynamicArray) {
+            System.out.println(element);
+        }
+    }
+    @Test
+    public void test03() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        dynamicArray.stream().forEach(element -> {
+            System.out.println(element);
+        });
+    }
+    @Test
+    public void test04() {
+        dynamicArray.addList(1);
+        dynamicArray.addList(3);
+        dynamicArray.addList(5);
+        dynamicArray.add(1, 7);
+        int removed =dynamicArray.remove(1);
+        System.out.println("removed: " + removed);
+        for (Integer element : dynamicArray) {
+            System.out.println(element);
+        }
+    }
+    @Test
+    public void test05() {
+        for (int i = 0; i < 9; i++) {
+            dynamicArray.addList(i);
+        }
+        System.out.println(dynamicArray.toString());
+        assertIterableEquals(List.of(0, 1, 2, 3, 4, 5, 6, 7, 8), dynamicArray, "List should be equal");
+    }
+}

src/test/java/com/nbee/solution/practice/SinglyLinkedListTest.java

@@ -0,0 +1,25 @@
+package com.nbee.solution.practice;
+
+import org.junit.Test;
+
+public class SinglyLinkedListTest {
+    private SinglyLinkedList list = new SinglyLinkedList();
+    @Test
+    public void singlyLinkedListAddFirstTest(){
+        list.addFirst(1);
+        list.addFirst(3);
+        list.addFirst(5);
+        list.addFirst(6);
+        list.loop0(i -> System.out.println(i + " "));
+    }
+    @Test
+    public void singlyLinkedListIteratorTest(){
+        list.addFirst(1);
+        list.addFirst(3);
+        list.addFirst(5);
+        list.addFirst(6);
+        for (Integer value: list) {
+            System.out.println(value);
+        }
+    }
+}