算法-链表

链表练习与总结

简单

1、求两个 升序 链表 的并集

建模，需要考虑边界情况

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        } else if (l2 == null) {
            return l1;
        } else if (l1.val < l2.val) {
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else {
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
    }
}
//其中 n 和 m 分别为两个链表的长度。因为每次调用递归都会去掉 l1 或者 l2 的头节点（直到至少有一个链表为空），函数 mergeTwoList 至多只会递归调用每个节点一次。因此，时间复杂度取决于合并后的链表长度，即 O(n+m)

迭代

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode prehead = new ListNode(-1);
​
        ListNode prev = prehead;
        while (l1 != null && l2 != null) {
            if (l1.val <= l2.val) {
                prev.next = l1;
                l1 = l1.next;
            } else {
                prev.next = l2;
                l2 = l2.next;
            }
            prev = prev.next;
        }
​
        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;
​
        return prehead.next;
    }
}

1. 删除重复元素

   while(cur.next!=null){
               if(cur.val==cur.next.val){
                   cur.next=cur.next.next;
               }else{
                   cur=cur.next;
               }
           }

2. 判断是否为环形链表

   Set<ListNode> seen = new HashSet<ListNode>();
           while (head != null) {
               if (!seen.add(head)) {
                   return true;
               }
               head = head.next;
           }
           return false;
   ​

1. 判断两个链表是否相交

   Set<ListNode> visited = new HashSet<ListNode>();
           ListNode temp = headA;
           while (temp != null) {
               visited.add(temp);
               temp = temp.next;
           }
           temp = headB;
           while (temp != null) {
               if (visited.contains(temp)) {
                   return temp;
               }
               temp = temp.next;
           }
           return null;
   //使用哈希集合存储链表节点。首先遍历链表headA，并将链表headA 中的每个节点加入哈希集合中。然后遍历链表headB，对于遍历到的每个节点，判断该节点是否在哈希集合中：
   ​

1. 删除链表中某个元素

   public ListNode removeElements(ListNode head, int val) {
           ListNode dummyHead = new ListNode(0);
           dummyHead.next = head;
           ListNode temp = dummyHead;
           while (temp.next != null) {
               if (temp.next.val == val) {
                   temp.next = temp.next.next;
               } else {
                   temp = temp.next;
               }
           }
           return dummyHead.next;
   ​
       }

1. 反转链表

   class Solution {
       public ListNode reverseList(ListNode head) {
           ListNode prev = null;
           ListNode curr = head;
           while (curr != null) {
               ListNode next = curr.next;
               curr.next = prev;
               prev = curr;
               curr = next;
           }
           return prev;
       }
   }
   //假设链表是1-2-3-null，我们要改成3-2-1-NULL；在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。