面试---必刷题

题目一删除链表中所有值为value的元素

题解一

public class RemoveAllNodes {
    public ListNode deleteDuplicates(ListNode head) {
        // 1.base case
        if(head == null || head.next == null) {
            return head;
        }
        ListNode dummyHead = new ListNode(-101);
        dummyHead.next = head;
        // prev一定要指向不重复的节点
        ListNode prev = dummyHead,cur = prev.next;
        while (cur != null) {
            ListNode sec = cur.next;
            // 最终遍历的过程中，有可能sec已经走到末尾
            if (sec == null) {
                break;
            }
            if (cur.val != sec.val) {
                // 只有当cur和sec不相等，才能移动prev引用
                prev = prev.next;
            }else {
                // 说明此时cur和sec相等，让sec一直向后移动，直到碰到和cur不相等的节点停止
                while (sec != null && cur.val == sec.val) {
                    sec = sec.next;
                }
                // 此时sec指向第一个和cur不相等的节点，[cur..sec) 全都是待删除的节点
                prev.next = sec;
            }
            cur = sec;
        }
        return dummyHead.next;
    }

题解二

public class RemoveAllNodes {
 public ListNode deleteDuplicates(ListNode head) {
        // 1.base case
        if (head == null || head.next == null) {
            return head;
        }
        // 2.就要判断当前头节点和第二个节点是否相等的问题
        if (head.val != head.next.val) {
            // 此时头节点不是要删除的节点
            // 处理子链表的删除
            head.next = deleteDuplicates(head.next);
            return head;
        }else {
            // 此时头节点就是待删除的节点，就需要先把头节点处理完毕
            ListNode newHead = head.next;
            while (newHead != null && newHead.val == head.val) {
                newHead = newHead.next;
            }
            // 此时newHead节点指向第一个不重复的节点
            // 头节点已经处理完毕，接着处理子链表的情况
            return deleteDuplicates(newHead);
        }
    }
   }

题目二

消失的数字
1.排序法

   public int missingNumber(int[] nums) {
       // 1.先将整个数组nums排序
      Arrays.sort(nums);
      // 2.遍历这个排序后的数组，当下标 i == nums[i]，该元素存在
      // 只需要找反例即可
      for (int i = 0; i < nums.length; i++) {
          if (i != nums[i]) {
              // 反例，应该出现的元素i并未出现，直接返回下标i即可
               return i;
            }
       }
       // 走完整个循环还没找到反例，此时消失的是最大值
       return nums.length;
  }

2.数学求和，差值即为消失的数字

   public int missingNumber(int[] nums) {
       int respectVal = (nums.length * (nums.length + 1)) / 2;
      int actualVal = 0;
       for (int i : nums) {
          actualVal += i;
       }
       return respectVal - actualVal;
          }

// 3.映射

    public int missingNumber(int[] nums) {
        // 1.创建一个大小为n + 1的布尔数组(nums中应该出现的元素个数为n + 1)
        boolean[] hash = new boolean[nums.length + 1];
        // 2.遍历原数组，将出现元素对应的hash数组置为true
        for (int i = 0; i < nums.length; i++) {
            hash[nums[i]] = true;
        }
        // 3.遍历hash数组，找到那个缺失的元素
        for (int i = 0; i < hash.length; i++) {
            if (!hash[i]) {
                // i这个下标就是消失的数字
                return i;
            }
        }
        return -1;
    }
}