（算法题）Day-20230315

二分查找

注意边界情况

package day.d0315;

/**
 * @author hdbing
 * 二分查找
 * @create 2023-03-15 15:52
 */
public class T01 {

   public static int search(int[] nums, int target) {
      if (target < nums[0] || target > nums[nums.length - 1]) {
         return -1;
      }

      int left = 0;
      int right = nums.length - 1;
      while (left <= right) {
         int mid = left + ((right - left) >> 1);
         if (target > nums[mid]) {
            left = mid + 1;
         } else if (target < nums[mid]) {
            right = mid - 1;
         } else {
            return mid;
         }
      }
      return -1;
   }

}

移除元素

快慢指针

package day.d0315;

/**
 * @author hdbing
 * @create 2023-03-15 16:02
 */
public class T02 {
   public int removeElement(int[] nums, int val) {
      int i = 0;
      for (int j = 0; j < nums.length; j++) {
         if (val != nums[j]) {
            nums[i] = nums[j]; 
            i++;
         }
      }
      return i;
   }

   /*
   排除掉不需要赋值的情况
   两个指针往中间找
   慢指针 从左往右找 等于目标值的
   快指针 从右往左找 不等于目标值的
   然后赋值即可
   */
   public int removeElementV2(int[] nums, int val) {
      int i = 0, j = nums.length - 1;
      while (i <= j) {
         while (i <= j && nums[i] != val) i++;
         while (i <= j && nums[j] == val) j--;
         if (i < j) nums[i++] = nums[j--];
      }
      return i;
   }
}

移除元素链表版本

注意链表中 构造虚拟头节点 和 使用指针指向前一个节点 技巧

/**
 * 添加虚节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
public ListNode removeElements(ListNode head, int val) {
    if (head == null) {
        return head;
    }
    // 因为删除可能涉及到头节点，所以设置dummy节点，统一操作
    ListNode dummy = new ListNode(-1, head);
    ListNode pre = dummy;
    ListNode cur = head;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return dummy.next;
}
/**
 * 不添加虚拟节点方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
public ListNode removeElements(ListNode head, int val) {
    while (head != null && head.val == val) {
        head = head.next;
    }
    // 已经为null，提前退出
    if (head == null) {
        return head;
    }
    // 已确定当前head.val != val
    ListNode pre = head;
    ListNode cur = head.next;
    while (cur != null) {
        if (cur.val == val) {
            pre.next = cur.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    return head;
}
/**
 * 不添加虚拟节点and pre Node方式
 * 时间复杂度 O(n)
 * 空间复杂度 O(1)
 * @param head
 * @param val
 * @return
 */
public ListNode removeElements(ListNode head, int val) {
    while(head!=null && head.val==val){
        head = head.next;
    }
    ListNode curr = head;
    while(curr!=null){
        while(curr.next!=null && curr.next.val == val){
            curr.next = curr.next.next;
        }
        curr = curr.next;
    }
    return head;
}

反转链表

// 双指针
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;
        ListNode temp = null;
        while (cur != null) {
            temp = cur.next;// 保存下一个节点
            cur.next = prev;
            prev = cur;
            cur = temp;
        }
        return prev;
    }
}