算法 | 第2章 链表相关《程序员面试金典》

第2章 链表相关《程序员面试金典》

  • 前言
  • 0. *经验总结
    • 0.1 程序员面试金典 P79
    • 0.2 需要询问面试官的点
    • 0.3 快慢指针
    • 0.4 递归
  • 1. 移除重复节点 [easy]
    • 1.1 考虑点
    • 1.2 解法
      • 1.2.1 集合法
      • 1.2.2 两循环法
  • 2. 返回倒数第 k 个节点 [easy]
    • 2.1 考虑点
    • 2.2 解法
      • 2.2.1 双指针同步运动法(快慢指针)(优)
      • 2.2.2 使用栈法
      • 2.2.3 递归
  • 3. 删除中间节点 [easy]
    • 3.1 考虑点
    • 3.2 解法
      • 3.2.1 复制自己法
  • 4. 分割链表 [medium]
    • 4.1 考虑点
    • 4.2 解法
      • 4.2.1 双指针逐个处理法
      • 4.2.2 排序法
      • 4.2.3 头插法
      • 4.2.4 原地删除
  • 5. 链表求和 [medium]
    • 5.1 考虑点
    • 5.2 解法
      • 5.2.1 反向存放法
      • 5.2.2 递归法
  • 6. 回文链表 [easy]
    • 6.1 考虑点
    • 6.2 解法
      • 6.2.1 改变方向双向遍历法(优)
      • 6.2.2 将值复制到数组中后用双指针法
      • 6.2.3 递归
  • 7. 链表相交 [easy]
    • 7.1 考虑点
    • 7.2 解法
      • 7.2.1 长度对齐双指针法
      • 7.2.2 双指针(优)
  • 8. 环路检测 [medium]
    • 8.1 考虑点
    • 8.2 解法
      • 8.2.1 快慢指针法(优)
      • 8.2.2 哈希表
  • 最后


前言

本系列笔记主要记录笔者刷《程序员面试金典》算法的一些想法与经验总结,按专题分类,主要由两部分构成:经验值点和经典题目。其中重点放在经典题目上;


0. *经验总结

0.1 程序员面试金典 P79

  • 链表的特点:无法在常数时间复杂度内访问链表的特定元素;可以在参数事件复杂度内加入和删除元素;
  • 如果链表被多个对象引用,当链表头结点变了,可能会有一些对象仍然指向原头结点;解决方法:可以用LinkedList封装Node类,该类只包含一个成员变量:头结点;
  • 链表问题可以关注“快慢指针”和递归;

0.2 需要询问面试官的点

  • 是否可以修改原链表;
  • 是否可以开辟额外空间;
  • 时间优先还是空间优先;
  • 在面试中要弄清单向链表和双向链表;

0.3 快慢指针

  • 快慢指针又称双指针,是一个广泛的概念,只要涉及两个指针遍历链表,并且一前一后,都可以称为快慢指针;
  • 快慢指针在不同题目有不同的作用,常见类型有:
    • 找到中点:慢指针每走n步时,快指针走2n步,当快指针达到尾部时;
    • 找到三分之一点:慢指针走n步,快指针走3n步;
    • 找到倒数第x个节点:快指针先走x步后,慢指针从头出发,与快指针速度一样,当快指针达到尾部时,慢指针到倒数第k个节点;【详情见 2. 返回倒数第 k 个节点】
    • 测试环形链表:慢指针每走n步时,快指针走2n步,能相遇说明环形;
    • 测试链表是否成环并找到第一个成环节点:【详情见 8. 环路检测】
    • ……

0.4 递归

  • 实际上所有递归算法都可以转换成迭代法,只是后者可能要复杂得多;
  • 一般来说,递归解法更简洁,但效率低下;


1. 移除重复节点 [easy]

算法 | 第2章 链表相关《程序员面试金典》_第1张图片

1.1 考虑点

  • 需要问清楚面试官是否可以开辟额外空间;
  • 需要询问面试官时间优先还是空间优先

1.2 解法

1.2.1 集合法

public ListNode removeDuplicateNodes(ListNode head) {
    if(head == null || head.next == null){
        return head;
    }
    ListNode cur = head;
    ListNode index = head;
    Set<Integer> set = new HashSet<>();
    set.add(head.val);
    while( cur.next != null){
		cur = cur.next;
        if( !set.contains(cur.val) ){
			index.next = cur;
            index = cur;
            set.add(cur.val);
        } else {
            index.next = null;
        }
    } 
    return head;
}
  • 执行时间:66.09%;内存消耗:51.20%;
  • 也可以用哈希表;
  • 时间复杂度:O(N),其中 N 是给定链表中节点的数目;
  • 空间复杂度:O(N)。在最坏情况下,给定链表中每个节点都不相同,哈希表中需要存储所有的 N个值;

1.2.2 两循环法

public ListNode removeDuplicateNodes(ListNode head) {
    ListNode ob = head;
    while (ob != null) {
        ListNode oc = ob;
        while (oc.next != null) {
            if (oc.next.val == ob.val) {
                oc.next = oc.next.next;
            } else {
                oc = oc.next;
            }
        }
        ob = ob.next;
    }
    return head;
}
  • 执行时间:93.52%;内存消耗:93.52%;
  • 时间复杂度:O(N2),其中 N 是给定链表中节点的数目;
  • 空间复杂度:O(1);

2. 返回倒数第 k 个节点 [easy]

算法 | 第2章 链表相关《程序员面试金典》_第2张图片

2.1 考虑点

  • 需要问清楚面试官是否可以开辟额外空间;

2.2 解法

2.2.1 双指针同步运动法(快慢指针)(优)

public int kthToLast(ListNode head, int k) {
    if(head == null || head.next == null){
        return head.val;
    }
    ListNode cur = head;
    ListNode index = head;
    //cur先走k-1个步长
    for(int i = 0; i < k - 1; i++ ){
        cur = cur.next;
    }
    //index上链表,跟cur同步运动,当cur到达链表尾时,cur为倒数第k个
    while(cur.next != null){
        cur = cur.next;
        index = index.next;
    }
    return index.val;
}
  • 执行时间:100.00%;内存消耗:30.78%;
  • 第一个指针先移动k步,然后第二个指针再从头开始,这个时候这两个指针同时移动,当第一个指针到链表的末尾的时候,返回第二个指针即可;

2.2.2 使用栈法

public int kthToLast(ListNode head, int k) {
    Stack<ListNode> stack = new Stack<>();
    //链表节点压栈
    while (head != null) {
        stack.push(head);
        head = head.next;
    }
    //在出栈串成新的链表
    ListNode firstNode = stack.pop();
    while (--k > 0) {
        ListNode temp = stack.pop();
        temp.next = firstNode;
        firstNode = temp;
    }
    return firstNode.val;
}
  • 执行时间:9.00%;内存消耗:58.84%;
  • 把原链表的结点全部压栈,然后再把栈中最上面的k个节点出栈,出栈的结点重新串成一个新的链表即可;

2.2.3 递归

int size;
public int kthToLast(ListNode head, int k) {
    if (head == null){
    	return 0;
    }
    int value = kthToLast(head.next, k);
    if (++size == k){
        return head.val;
    }
    return value;
}
  • 执行时间:100.00%;内存消耗:24.44%;
  • 递归访问整个链表,到达尾部时,回传一个设置为0的size计数器,后续调用每次都会将计数器加1,当计数器为k是,即为倒数第k个。value为暂存的结果值;

3. 删除中间节点 [easy]

算法 | 第2章 链表相关《程序员面试金典》_第3张图片

3.1 考虑点

  • 题目有点“脑筋急转弯”的意思,注意给出的是当前要删除的节点;
  • 面试官期待的是:当待删除的节点为链表尾节点时的情况:
    • 因为不能访问前一个节点,要从其他方面考虑解决方法;
    • 可以考虑将该节点标记为假节点,即物理上存在,逻辑上不在;

3.2 解法

3.2.1 复制自己法

public void deleteNode(ListNode node) {
    if(node == null || node.next == null){
        return;
    }
    ListNode nextNode = node.next;
    node.val = nextNode.val;
    node.next = nextNode.next;
}
  • 执行时间:100.00%;内存消耗:72.05%;
  • 如果只能访问当前节点,那么该题的解题思路就是,将自己变成其他节点;
    • 举个例子:A->B->C->D;
    • 如果要删掉 B 节点,那么只需要将 B 变为 C,再把 B 的指针指向 D,即可完成;

4. 分割链表 [medium]

算法 | 第2章 链表相关《程序员面试金典》_第4张图片

4.1 考虑点

  • 注意题目意思,可以排序,但不一定是排序;
  • 如果本题描述的是数组,对于如何移动元素要谨慎,数组元素的移动通常开销很大。但链表相对比较简单;

4.2 解法

4.2.1 双指针逐个处理法

public ListNode partition(ListNode head, int x) {
    if(head == null || head.next == null ){
        return head;
    }
    //找到比x小的节点,该节点离x节点最近
    ListNode index = head;
    while(index.val < x && index.next != null){
        index = index.next;
    }
    //用2个指针完成移位操作
    //index为首个大于等于x的节点
    //cur为index2的next
    ListNode cur = index.next;
    while(index.next != null){
        if(cur.val >= x){
            //继续
            index = index.next;
            cur = cur.next;
        } else {
            //移位
            index.next = cur.next;
            if( head.val < x){
				cur.next = head.next;
                head.next = cur;
            } else {
                cur.next = head;
                head = cur;
            }
            cur = index.next;
        }
    }
    return head;
}
  • 执行时间:100.00%;内存消耗:64.81%;

4.2.2 排序法

public ListNode partition(ListNode head, int x) {
    return sortList(head, null);
}

private ListNode sortList(ListNode head, ListNode tail) {
    //无法继续拆分的情况
    if (head == null) {
        return null;
    }
    //无法继续拆分的情况
    if (head.next == tail) {
        head.next = null;
        return head;
    }
    //快慢指针找到中间节点
    ListNode slow = head, fast = head;
    while (fast != tail && fast.next != tail) {
        slow = slow.next;
        fast = fast.next.next;
    }
    ListNode mid = slow;
    //左边继续拆分
    ListNode left = sortList(head, mid);
    //右边继续拆分
    ListNode right = sortList(mid, tail);
    //有序链表合并
    return merge(left, right);
}

private ListNode merge(ListNode left, ListNode right) {
    ListNode mergeNode = new ListNode();
    ListNode help = mergeNode;
    //比较两个链表当前的值,值小的链表就把引用赋给mergeNode,并向后移动一位重新赋值给自己,同时help指向值小的那个节点
    while (left != null && right != null) {
        if (left.val < right.val) {
            help.next = left;
            left = left.next;
        } else {
            help.next = right;
            right = right.next;
        }
        help = help.next;
    }
    //最后如果有剩余的节点,就一次性链上去 
    help.next = left == null ? right : left;
    return mergeNode.next;
}
  • 执行时间:100.00%;内存消耗:83.65%;
  • 最无脑的做法是排序,这题不管x给什么,只需要对链表进行一次排序,既能满足题目要求,之前的题目中有练习过插入排序、归并排序,随便哪一种都可以,当然归并的效率更高一点;

4.2.3 头插法

public ListNode partition(ListNode head, int x) {
    ListNode dummy = new ListNode();
    dummy.next = head;
    while (head != null && head.next != null) {
        int nextVal = head.next.val;
        if (nextVal < x) {
            ListNode next = head.next;
            head.next = head.next.next;
            next.next = dummy.next;
            dummy.next = next;
        } else {
            head = head.next;
        }
    }
    return dummy.next;
}
  • 执行时间:100.00%;内存消耗:20.44%;
  • 逐个遍历,遇到小于x值的节点,就插到头部;
  • PS:Java中HashMap,jdk1.8之前,扩容时链表采用的就是头插法(存在死循环的问题,1.8改了);

4.2.4 原地删除

public ListNode partition(ListNode head, int x) {
    ListNode dummy = new ListNode();
    dummy.next = head;
    ListNode smallDummy = new ListNode();
    ListNode small = smallDummy;
    //和删除节点的套路一样,先处理头节点满足条件的情况
    while (head != null) {
        if (head.val >= x) {
            break;
        }
        small.next = new ListNode(head.val);
        small = small.next;
        head = head.next;
    }
    //删除
    ListNode cur = head;
    ListNode pre = null;
    while (cur != null) {
        if (cur.val < x) {
            pre.next = cur.next;
            small.next = new ListNode(cur.val);
            small = small.next;
        } else {
            pre = cur;
        }
        cur = cur.next;
    }
    small.next = head;
    return smallDummy.next;
}
  • 执行时间:100.00%;内存消耗:56.22%;
  • 按照删除节点的方式,遇到小于x值的节点,就从原链表中删除,并添加到新的链表中,这样一次遍历结束后,只要把新的链表连上原链表即可;

5. 链表求和 [medium]

算法 | 第2章 链表相关《程序员面试金典》_第5张图片

5.1 考虑点

  • 需要考虑链表长度不一导致的空指针异常问题;
  • 进阶的思考:
    • 链表长度不一时的对位问题,如(1 -> 2 -> 3 -> 4)和(5 -> 6 -> 7),这里5对2而不是1;
    • 上述问题可以遍历链表,用0占位解决;

5.2 解法

5.2.1 反向存放法

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    if( l1 == null && l2 == null){
        return null;
    }
    ListNode cur1 = l1;
    ListNode cur2 = l2;
    int cache = 0;
    boolean isFirst = true;
    ListNode head = null;
    ListNode index = null;
    while( cur1 != null || cur2 != null){
        //加法
        int value = 0;
        if( cur1 == null){
            value = cur2.val + cache;
            cur2 = cur2.next;
        } else if ( cur2 == null){
            value = cur1.val + cache;
            cur1 = cur1.next;
        } else {
            value = cur1.val + cur2.val + cache;
            cur1 = cur1.next;
            cur2 = cur2.next;
        }
        //进位在cache储存
        cache = value / 10;
        //构造新节点,新节点指向新节点
        ListNode node = new ListNode(value%10);
        if(isFirst){
            head = node;
            index = node;
            isFirst = false;
        } else {
            index.next = node;
            index = node;
        }
    }
    //判断cache
    if(cache != 0){
        ListNode node = new ListNode(cache);
        index.next = node;
    }
    return head;
}
  • 执行时间:97.51%;内存消耗:33.72%;
  • 通常做法:逐个遍历,进位,构建新节点;

5.2.2 递归法

public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
    ListNode head = new ListNode(0);
    helper(head, l1, l2, 0);
    return head.next;
}
private void helper(ListNode result, ListNode l1, ListNode l2, int carry) {
    if (l1 == null && l2 == null && carry == 0){
        return;
    }
    int sum = (l1 != null ? l1.val : 0) + (l2 != null ? l2.val : 0) + carry;
    result.next = new ListNode(0);
    result.next.val = sum % 10;
    carry = sum / 10;
    helper(result.next, l1 != null ? l1.next : null, l2 != null ? l2.next : null, carry);
}
  • 执行时间:100.00%;内存消耗:26.25%;

6. 回文链表 [easy]

算法 | 第2章 链表相关《程序员面试金典》_第6张图片

6.1 考虑点

  • 对于链表,可以思考的角度有:改变链表方向、拼接、成环等;
  • 需要问清楚面试官是否可以开辟额外空间;
  • 需要问清楚面试官是否可以修改链表;

6.2 解法

6.2.1 改变方向双向遍历法(优)

public boolean isPalindrome(ListNode head) {
    if(head == null){
        return true;
    }
    //统计链表长度
    ListNode cur = head;
    int count = 0;
    while( cur != null ){
        count++;
        cur = cur.next;
    }
    if( count < 2){
        return true;
    }
    //改变前 count/2-1 个节点指向,分奇偶讨论
    ListNode right = head;
        //定位right指针
    if( count % 2 == 1 ){
        //奇数情况
        for( int i = 0; i < count/2+1; i++){
            right = right.next;
        }
    } else {
        //偶数情况
        for( int i = 0; i < count/2; i++){
            right = right.next;
        }
    }
    //改变前count/2-1个节点方向
    ListNode left = head;
    cur = head.next;
    ListNode mid = cur.next;
    //判断对只有2~3个节点单独判断
    if(count < 4){
        return left.val == right.val;
    }
    for( int i = 0; i < count/2-1; i++){
        cur.next = left;
        left = cur;
        cur = mid;
        mid = mid.next;
    }
    //遍历比较left和right
    while(right != null){
        if(left.val != right.val){
            return false;
        }
        right = right.next;
        left = left.next;
    }
    return true;
}
  • 执行时间:96.85%;内存消耗:80.19%;
  • 不使用额外空间;
  • 需要注意,是否可以改变原链表;

6.2.2 将值复制到数组中后用双指针法

public boolean isPalindrome(ListNode head) {
    List<Integer> vals = new ArrayList<Integer>();
    // 将链表的值复制到数组中
    ListNode currentNode = head;
    while (currentNode != null) {
        vals.add(currentNode.val);
        currentNode = currentNode.next;
    }
    // 使用双指针判断是否回文
    int front = 0;
    int back = vals.size() - 1;
    while (front < back) {
        if (!vals.get(front).equals(vals.get(back))) {
            return false;
        }
        front++;
        back--;
    }
    return true;
}
  • 执行时间:32.69%;内存消耗:24.77%;
  • 时间复杂度:O(n),其中 n 指的是链表的元素个数;
    • 第一步: 遍历链表并将值复制到数组中,O(n)。
    • 第二步:双指针判断是否为回文,执行了 O(n/2) 次的判断,即 O(n)。
    • 总的时间复杂度:O(2n) = O(n)。
  • 空间复杂度:O(n),其中 n 指的是链表的元素个数,我们使用了一个数组列表存放链表的元素值;
  • 需要开辟额外空间;

6.2.3 递归

private ListNode frontPointer;
private boolean recursivelyCheck(ListNode currentNode) {
    if (currentNode != null) {
        if (!recursivelyCheck(currentNode.next)) {
            return false;
        }
        if (currentNode.val != frontPointer.val) {
            return false;
        }
        frontPointer = frontPointer.next;
    }
    return true;
}
public boolean isPalindrome(ListNode head) {
    frontPointer = head;
    return recursivelyCheck(head);
}
  • 执行时间:56.10%;内存消耗:5.05%;
  • 时间复杂度:O(n),其中 n 指的是链表的大小;
  • 空间复杂度:O(n),其中 n 指的是链表的大小。 这种方法不仅使用了 O(n)的空间,且比第一种方法更差,因为在许多语言中,堆栈帧的开销很大(如 Python),并且最大的运行时堆栈深度为 1000(可以增加,但是有可能导致 底层解释程序内存出错)。为每个节点创建堆栈帧极大的限制了算法能够处理的最大链表大小;

7. 链表相交 [easy]

算法 | 第2章 链表相关《程序员面试金典》_第7张图片

7.1 考虑点

  • 这里不能使用链表反转,题目要求不能破坏原有结构;
  • 对于两条长度不同的链表而言,可以先遍历求出各自的长度再做计算,也可以使用;两个指针走完两条链表,最后必然能重合,因为指针的速度(步长)的一样的;
  • 需要问清楚面试官是否可以开辟额外空间;

7.2 解法

7.2.1 长度对齐双指针法

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
    if( headA == null || headB == null ){
        return null;
    }
    ListNode cur = headA;
    int countA = 0;
    while( cur != null ){
        countA++;
        cur = cur.next;
    }
    cur = headB;
    int countB = 0;
    while( cur != null){
        countB++;
        cur = cur.next;
    }
    //保证headA长于headB
    if( countA < countB){
        return getIntersectionNode(headB,headA);
    }
    ListNode curA = headA;
    ListNode curB = headB;
    for( int i = 0; i < countA-countB; i++){
        curA = curA.next;
    }
    while( curA != null ){
        if( curA.equals(curB) ){
            return curA;
        }
        curA = curA.next;
        curB = curB.next;
    }
    return null;
}
  • 执行时间:100.00%;内存消耗:57.18%;
  • 时间复杂度:O(A+B),A和B是两个链表的长度;
  • 空间复杂度:O(1);

7.2.2 双指针(优)

public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
     ListNode h1 = headA;
     ListNode h2 = headB;
     while(h1 != h2){
         h1 = (h1 == null ? headB : h1.next); 
         h2 = (h2 == null ? headA : h2.next); 
     }
     return h1;
}
  • 执行时间:100.00%;内存消耗:57.18%;
  • 对于h1来说,走到末尾(或相交点)时,走了两段链表(两段链表不同部分)的路径;
  • 对于h2来说,走到末尾(或相交点)时,走了两段链表(两段链表不同部分)的路径;
  • h1和h2走过的路径相同,因此第二轮就能匹配到;

8. 环路检测 [medium]

算法 | 第2章 链表相关《程序员面试金典》_第8张图片

8.1 考虑点

  • 处理环形链表可以试试快慢指针;

8.2 解法

8.2.1 快慢指针法(优)

public ListNode detectCycle(ListNode head) {
    if( head == null ){
        return null;
    }
    if(head.next == null){
        return null;
    }
    if(head.next.next == null){
        return null;
    }
    //使用快慢指针找到有count个环成圈;
    ListNode fast = head.next.next;
    ListNode slow = head.next;
    int count = 1; //count变量不是必要的
    while( fast != slow ){
        if(fast == null || slow == null){
            return null;
        }
        slow = slow.next;
        if(fast.next != null){
            fast = fast.next.next;
        } else {
            return null;
        }
        count++;
    }
    // cur 和 slow 一起走,走n步到环路开头节点
    ListNode cur = head;
    while( cur != slow ){
        cur = cur.next;
        slow = slow.next;
    }
    return cur;
}
  • 执行时间:100.00%;内存消耗:53.71%;
  • 时间复杂度:O(n),n为不成环的节点和成环节点的较大值;
  • 空间复杂度:O(1),不开辟额外空间,算法中的count不是必要的;
  • 算法解释:算法主要分为两个部分,如下:
    • 使用快慢指针找到有count个环成圈:走x步到达下标为x的节点。可以通过快慢指针获得count(或count的质因数)个节点成圈,同时慢指针走了count步(此时快慢指针所指节点下标为count)。假设环路开头节点的下标为 n(n<=count),从链表头走要走n步到环路开头节点;
    • 走n步到环路开头节点:从链表头到快慢指针处走count步,从链表头到环路开头节点要n步。如果要从环路开头节点走到快慢指针处要走count-n步;如果要从环路开头节点再一次回到开头节点必须走完一个圈(或n圈),即走count步。那么从快慢指针处走到开头节点至少就要count-(count-n)=n步,而我们从链表头走到环路开头节点也是要走n步;

8.2.2 哈希表

public ListNode detectCycle(ListNode head) {
    ListNode pos = head;
    Set<ListNode> visited = new HashSet<ListNode>();
    while (pos != null) {
        if (visited.contains(pos)) {
            return pos;
        } else {
            visited.add(pos);
        }
        pos = pos.next;
    }
    return null;
}
  • 执行时间:30.58%;内存消耗:24.80%;
  • 时间复杂度:O(N),其中 N 为链表中节点的数目。我们恰好需要访问链表中的每一个节点;
  • 空间复杂度:O(N),其中 N 为链表中节点的数目。我们需要将链表中的每个节点都保存在哈希表当中;


最后

新人制作,如有错误,欢迎指出,感激不尽!
欢迎关注公众号,会分享一些更日常的东西!
如需转载,请标注出处!

你可能感兴趣的:(学习笔记,#,数据结构与算法学习笔记,链表,算法,面试,递归法,单链表)