链表相关面试题

已于 2022-03-25 10:33:10 修改
阅读量577 收藏
点赞数
分类专栏： LeetCode 剑指Offer 文章标签： 链表
于 2021-04-23 23:44:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45661125/article/details/116075955
版权

链表相关面试题

链表中的节点每k个一组翻转

https://www.nowcoder.com/practice/b49c3dc907814e9bbfa8437c251b028e?tpId=117&&tqId=37746&&companyId=139&rp=1&ru=/company/home/code/139&qru=/ta/job-code-high/question-ranking

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    public ListNode reverseKGroup (ListNode head, int k) {
        // write code here
        if(head == null || head.next == null || k < 2) {
            return head;
        }
        ListNode newHead = new ListNode(-1);
        newHead.next = head;
        ListNode prev = newHead;
        ListNode cur = head;
        ListNode tmp = null;
        int len = 0;
        while(cur != null) {
            len++;
            cur = cur.next;
        }
        cur = head;
        //头插法反转链表
        for(int i = 0; i < len / k; i++) {
            for(int j = 1; j < k; j++) {
                tmp = cur.next;
                cur.next = tmp.next;
                tmp.next = prev.next;
                prev.next = tmp;
            }
            prev = cur;
            cur = prev.next;
        }
        return newHead.next;
    }
}

两数相加

https://leetcode-cn.com/problems/add-two-numbers/

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l1;
        }
        if(l2 == null) {
            return l1;
        }
        ListNode head = null, tail = null;
        int carry = 0;
        while(l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            if(head == null) {
                head = tail = new ListNode(sum % 10);
            }else {
                tail.next = new ListNode(sum % 10);
                tail = tail.next;
            }
            carry = sum / 10;
            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        if(carry > 0) {
            tail.next = new ListNode(carry);
        }
        return head;
    }
}

链表求和（两个链表生成相加链表）正序排列

题目连接：https://leetcode-cn.com/problems/sum-lists-lcci/

利用逆序的方法来解决

import java.util.*;
public class Solution {
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        if(head1 == null) {
            return head2;
        }
        if(head2 == null) {
            return head1;
        }
        ListNode l1 = reverse(head1);
        ListNode l2 = reverse(head2);
        int carry = 0;
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        while(l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            carry = sum / 10;
            ListNode node = new ListNode(sum % 10);
            tmp.next = node;
            tmp = tmp.next;
            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        if(carry > 0) {
            tmp.next = new ListNode(1);
        }
        ListNode ret = reverse(newHead.next);
        return ret;
    }
    public ListNode reverse(ListNode head){
        if(head == null) {
            return null;
        }
        ListNode prev = null;
        ListNode cur = head;
        ListNode curNext = null;
        while(cur != null) {
            curNext = cur.next;
            cur.next = prev;
            prev = cur;
            cur = curNext;
        }
        return prev;
    }
}

利用栈来解决

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 * }
 */

public class Solution {
    /**
     * 
     * @param head1 ListNode类 
     * @param head2 ListNode类 
     * @return ListNode类
     */
    public ListNode addInList (ListNode head1, ListNode head2) {
        // write code here
        Stack<Integer> stack1 = buildStack(head1);
        Stack<Integer> stack2 = buildStack(head2);
        ListNode newHead = new ListNode(-1);
        int carry = 0;
        while(!stack1.isEmpty() || !stack2.isEmpty() || carry != 0) {
            int n1 = stack1.isEmpty() ? 0 : stack1.pop();
            int n2 = stack2.isEmpty() ? 0 : stack2.pop();
            //头插法
            int sum = n1 + n2 + carry;
            carry = sum / 10;
            ListNode node = new ListNode(sum % 10);
            node.next = newHead.next;
            newHead.next = node;
        }
        return newHead.next;
    }
        
        public Stack<Integer> buildStack(ListNode head){
        	Stack<Integer> stack = new Stack<Integer>();
            if(head == null) {
                return stack;
            }
            while(head != null){
                stack.push(head.val);
                head = head.next;
            }
            return stack;
    }
}

链表求和(逆序排列)

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l2;
        }
        if(l2 == null) {
            return l1;
        }
        int carry = 0;
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        while(l1 != null || l2 != null) {
            int n1 = l1 != null ? l1.val : 0;
            int n2 = l2 != null ? l2.val : 0;
            int sum = n1 + n2 + carry;
            carry = sum / 10;
            ListNode node = new ListNode(sum % 10);
            tmp.next = node;
            tmp = tmp.next;
            if(l1 != null) {
                l1 = l1.next;
            }
            if(l2 != null) {
                l2 = l2.next;
            }
        }
        if(carry > 0) {
            tmp.next = new ListNode(1);
        }
        return newHead.next;
    }
}

相交链表

题目链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/

 //暴力解法
    class Solution {
        public int getL(ListNode cur)
        {
            if(cur==null) return 0;
            int len=0;
            while(cur!=null)
            {
                cur=cur.next;
                len++;
            }
            return len;
        }
        public ListNode findFirstCommonNode(ListNode headA, ListNode headB) {
            if(headA==null||headB==null) return null;
            int lenA=getL(headA);
            int lenB=getL(headB);
            if(lenA>lenB)
            {
                while(lenA-lenB>0)
                {
                    headA=headA.next;
                    lenA--;
                }
            }else if(lenA<lenB){
                while(lenB-lenA>0)
                {
                    headB=headB.next;
                    lenB--;
                }
            }
         while(headA!=headB)
         {
             headA=headA.next;
             headB=headB.next;
         }
         return headA;
        }
    }
    
    //双指针
    public class Solution {
        public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
            ListNode p=headA;
            ListNode q=headB;
            while(p!=q)
            {
                if(p!=null)
                {
                    p=p.next;
                }else{
                    p=headB;
                }
                if(q!=null)
                {
                    q=q.next;
                }else{
                    q=headA;
                }
            }
            return p;
        }
    }

反转链表

题目连接：https://leetcode-cn.com/problems/fan-zhuan-lian-biao-lcof/

  • 反转链表1

  • 题目描述：反转一个单链表。

  • 分析：利用一个节点的前驱，后继与本节点相互转换;简单来说就是前边后，后变前。大家都懂得

    class Solution {
    public ListNode reverseList(ListNode head) {
    if(head==null) return null;
    ListNode prev=null,cur=head,curNext=null;
    while(cur!=null)
    {
      curNext=cur.next;
      cur.next=prev;
      prev=cur;
      cur=curNext;
    }
    return prev;
    }
}

反转链表2（指定区间内的反转）

https://leetcode-cn.com/problems/reverse-linked-list-ii/

题目描述：给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

class Solution {
    public ListNode reverseBetween(ListNode head, int l, int r) {
        if(head == null) {
            return null;
        }
        ListNode newHead = new ListNode(-1);
        newHead.next = head;
        ListNode tmp = newHead;
        for(int i = 0; i < l - 1; i++){
            tmp = tmp.next;
        }
        ListNode prev = tmp.next;
        ListNode cur = prev.next;
        ListNode curNext = null;
        for(int i = 0; i < r - l; i++) {
            curNext = cur.next;
            cur.next = prev;
            prev = cur;
            cur = curNext;
        }
        tmp.next.next = cur;
        tmp.next = prev;
        return newHead.next;
    }
}

链表中环的入口节点

题目连接：https://www.nowcoder.com/practice/253d2c59ec3e4bc68da16833f79a38e4?tpId=13&tqId=23449&ru=/practice/6ab1d9a29e88450685099d45c9e31e46&qru=/ta/coding-interviews/question-ranking

public class Solution {

    public ListNode EntryNodeOfLoop(ListNode head) {
        if(head == null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if(slow == fast) {
                break;
            }
        }
        if(fast == null || fast.next == null) {
            return null;
        }
        while(slow != head) {
            slow = slow.next;
            head = head.next;
        }
        return head;
    }
}

合并两个有序链表

题目连接：https://leetcode-cn.com/problems/he-bing-liang-ge-pai-xu-de-lian-biao-lcof/

 /**
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1 == null) {
            return l2;
        }
        if(l2 == null) {
            return l1;
        }
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        while(l1 != null && l2 != null) {
            if(l1.val <= l2.val) {
                tmp.next = l1;
                l1 = l1.next;
            }else {
                tmp.next = l2;
                l2 = l2.next;
            }
            tmp = tmp.next;
        }
        if(l1 != null) {
            tmp.next = l1;
        }
        if(l2 != null) {
            tmp.next = l2;
        }
        return newHead.next;
    }
}

两个链表的第一个公共节点

public class Solution {
    public ListNode FindFirstCommonNode(ListNode h1, ListNode h2) {
         if(h1 == null || h2 == null) {
             return null;
         }
        ListNode p = h1, q = h2;
        while(p != q) {
            if(p != null) {
                p = p.next;
            }else {
                p = h2;
            }
            if(q != null) {
                q = q.next;
            }else {
                q = h1;
            }
        }
        return p;
    }
}

从有序链表中删除重复节点

https://www.nowcoder.com/practice/71cef9f8b5564579bf7ed93fbe0b2024?tpId=117&&tqId=37729&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

  • 从有序链表中删除重复节点Ⅰ

  • 题目描述：给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

public class Solution {
    /**
     * 
     * @param head ListNode类 
     * @return ListNode类
     */
    public ListNode deleteDuplicates (ListNode head) {
        // write code here
         if(head == null) return null;
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        ListNode cur = head;
        while(cur != null)
        {
            if(cur.next != null && cur.val == cur.next.val)
            {
                while(cur.next != null && cur.val == cur.next.val)
                {
                    cur = cur.next;
                }
                cur = cur.next;
            }else{
                tmp.next=cur;
                tmp = tmp.next;
                cur = cur.next;
            }
        }
        tmp.next = null;
        return newHead.next;
    }
}

  • 从有序链表中删除重复节点Ⅱ

    • 题目描述：给定一个排序链表，删除所有含有重复数字的节点，只保留原始链表中 没有重复出现 的数字。

    • 分析：分情况：重复节点与不重复节点；找到不重复节点连接在新链表的尾部

public class Solution {
    public ListNode deleteDuplicates (ListNode head) {
        // write code here
         if(head == null) return null;
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        ListNode cur = head;
        while(cur != null)
        {
            if(cur.next != null && cur.val == cur.next.val)
            {
                while(cur.next != null && cur.val == cur.next.val)
                {
                    cur = cur.next;
                }
            }else{
                tmp.next=cur;
                tmp = tmp.next;
                cur = cur.next;
            }
        }
        tmp.next = null;
        return newHead.next;
    }
}

删除链表的节点

题目链接：https://leetcode-cn.com/problems/shan-chu-lian-biao-de-jie-dian-lcof/

  • 分析：双指针

    class Solution {
    public ListNode deleteNode(ListNode head, int val) {
      if(head==null) return null;
      if(head.val==val) return head.next;
      ListNode prev=head;
      ListNode cur=head.next;
      while(cur!=null){
          if(cur.val==val){
              prev.next=cur.next;
              prev=cur;
              
          }else{
              prev=cur;
          }
          cur=cur.next;
      }
      return head;
    }
}


//单指针
    public ListNode deleteNode (ListNode head, int val) {
        // write code here
        if(head == null) {
            return null;
        }
        if(head.val == val) {
            return head.next;
        }
        ListNode cur = head;
        while(cur != null) {
            if(cur.next.val == val) {
                cur.next = cur.next.next;
                break;
            }
            cur = cur.next;
        }
        return head;
    }
}

链表中倒数第n个节点

https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        if(head == null) {
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        for(int i = 0; i < k; i++) {
            if(fast == null) {
                return null;
            }else {
                fast = fast.next;
            }
        }
        while(fast != null) {
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}

删除链表的倒数第n个节点

https://www.nowcoder.com/practice/f95dcdafbde44b22a6d741baf71653f6?tpId=117&&tqId=37750&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
public class Solution {
    class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if(head == null){
            return null;
        }
        ListNode fast = head;
        ListNode slow = head;
        for(int i = 0; i < n; i++) {
            if(fast == null) {
                return null;
            }else {
                fast = fast.next;
            }
        }
        if(fast == null) {
            return head.next;
        }
        ListNode prev = null;
        while(fast != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next;
        }
        prev.next = slow.next;
        return head;
    }
}

交换链表中的相邻节点

题目连接：https://leetcode-cn.com/problems/swap-nodes-in-pairs/

   class Solution {
        public ListNode swapPairs(ListNode head) {
            ListNode newList = new ListNode(-1);
            newList.next = head;
            ListNode prev = newList;
    
            while(prev.next != null && prev.next.next != null){
                ListNode l1 = prev.next;
                ListNode l2 = prev.next.next;
    
                l1.next = l2.next;
                l2.next = l1;
                prev.next = l2;
    
                prev = l1;
            }
    
            return newList.next;
        }
    }

回文链表

题目连接：https://leetcode-cn.com/problems/palindrome-linked-list/

 class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head == null) {
            return true;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode prev = null;
        ListNode slowNext = null;
        while(slow != null) {
            slowNext = slow.next;
            slow.next = prev;
            prev = slow;
            slow = slowNext;
        }
        while(prev != null) {
            if(prev.val != head.val) {
                return false;
            }
            prev = prev.next;
            head = head.next;
        }
        return true;
    }
}

分隔链表

题目连接：https://leetcode-cn.com/problems/split-linked-list-in-parts/

class Solution {
        public ListNode[] splitListToParts(ListNode root, int k) {  
            ListNode[] res = new ListNode[k];
            if(null == root) return res;
            //链表长度
            int count= 0;
            ListNode cur = root;
            while(null != cur){
                count++;
                cur = cur.next;
            }
    
            cur = root;
    
            //链表长度小于等于分组，也就是每组一个节点还有的组没有节点
            if(k >= count){
                for(int i =0;i < count;i++){
                    res[i] = cur;
                    ListNode temp = cur.next;
                    cur.next = null;
                    cur = temp;
                }
                
            }else{
                int preCount = count/k;
                int remain = count%k;
    
                int[] numArr = new int[k];
                for(int i = 0;i < k;i++){
                    numArr[i] = remain-- >0?preCount+1:preCount;
                }
    
                for(int i=0;i < k;i++){
                    int num = numArr[i];
    
    
                    res[i] = cur;
                    while(--num > 0){
                        cur = cur.next;
                    }
    
                    ListNode temp = cur.next;
                    cur.next = null;
                    cur = temp;
                }
            }
    
            return res;
        }
    }

链表元素按奇偶聚集

题目连接：https://leetcode-cn.com/problems/odd-even-linked-list/

  class Solution {
        public ListNode oddEvenList(ListNode head) {
           if(null == head){
               return null;
           }
    
           ListNode odd = head;
           ListNode oddTail = odd;
           ListNode even = head.next;
           ListNode evenTail = even;
    
           while(evenTail != null && evenTail.next != null){
               oddTail.next = oddTail.next.next;
               evenTail.next = evenTail.next.next;
    
               oddTail = oddTail.next;
               evenTail = evenTail.next;
           }
    
           oddTail.next = even;
           return head;
        }
    }

复杂链表的复刻

题目连接：https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/

  //HashMap
  class Solution {
      public ListNode copyRandomList(ListNode head) {
          if(head==null) return null;
          HashMap<ListNode,ListNode> map=new HashMap<>();
          ListNode cur=head;
          while(cur!=null)
          {
              ListNode node=new ListNode(cur.val);
              map.put(cur,node);
              cur=cur.next;
              
          }
          cur=head;
          while(cur!=null)
          {
            map.get(cur).next=map.get(cur.next);
            map.get(cur).random=map.get(cur.random);
            cur=cur.next;
          }
          return map.get(head);
      }
  }
  //复制连接法
  class Solution {
      public ListNode copyRandomList(ListNode head) {
          if(head==null) return null;
          ListNode cur=head;
          while(cur!=null)
          {
              ListNode node=new ListNode(cur.val);
              node.next=cur.next;
              cur.next=node;
              cur=node.next;
          }
          cur=head;
          while(cur!=null)
          {
             if(cur.random!=null)
             {
                 cur.next.random=cur.random.next;
             }
             cur=cur.next.next;
          }
          cur=head;
          ListNode newHead=new ListNode(-1);
          ListNode tmp=newHead;
          while(cur!=null)
          {
              tmp.next=cur.next;
              tmp=tmp.next;
              cur.next=tmp.next;
              cur=cur.next;
          }
          return newHead.next;
      }
  }

排序链表(链表排序）

题目连接：https://leetcode-cn.com/problems/sort-list/

归并思想

class Solution {
    public ListNode sortList(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode fast = head;
        ListNode slow = head;
        ListNode prev = null;
        while(fast != null && fast.next != null) {
           prev = slow;
           slow = slow.next;
           fast = fast.next.next;
        }
        prev.next = null;
        ListNode l = sortList(head);
        ListNode r = sortList(slow);
        return merge(l, r);
    }
    public ListNode merge(ListNode l1, ListNode l2) {
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        while(l1 != null && l2 != null) {
            if(l1.val <= l2.val) {
                tmp.next = l1;
                l1 = l1.next;
            }else {
                tmp.next = l2;
                l2 = l2.next;
            }
            tmp = tmp.next;
        }
        if(l1 != null) {
            tmp.next = l1;
        }
        if(l2 != null) {
            tmp.next = l2;
        }
        return newHead.next;
    }
}

重排链表

https://www.nowcoder.com/practice/3d281dc0b3704347846a110bf561ef6b?tpId=117&&tqId=37712&rp=1&ru=/ta/job-code-high&qru=/ta/job-code-high/question-ranking

public class Solution {
    public void reorderList(ListNode head) {
        if(head == null) {
            return ;
        }
        ListNode fast = head;
        ListNode slow = head;
        while(fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode slowNext = slow.next;
        slow.next = null;
        ListNode newHead = reverse(slowNext);
        ListNode cur = head;
        ListNode next = null;
        int k = 0;
        while(newHead != null && cur != null) {
            if(k % 2 == 0) {
                next = cur.next;
                cur.next = newHead;
                cur = next;
            }else {
                next = newHead.next;
                newHead.next = cur;
                newHead = next;
            }
            k++;
        }
    }
    public ListNode reverse(ListNode head) {
        if(head == null) {
            return null;
        }
        ListNode prev = null;
        ListNode cur = head;
        ListNode curNext = null;
        while(cur != null) {
            curNext = cur.next;
            cur.next = prev;
            prev = cur;
            cur = curNext;
        }
        return prev;
    }
}

单链表的排序

https://www.nowcoder.com/practice/f23604257af94d939848729b1a5cda08?tpId=117&&tqId=37817&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

public class Solution {
    public ListNode sortInList (ListNode head) {
        // write code here
        if(head == null || head.next == null) {
            return head;
        }
        ListNode fast = head;
        ListNode slow = head;
        ListNode prev = null;
        while(fast != null && fast.next != null) {
           prev = slow;
           slow = slow.next;
           fast = fast.next.next;
        }
        prev.next = null;
        ListNode l = sortInList(head);
        ListNode r = sortInList(slow);
        return merge(l, r);
    }
    public ListNode merge(ListNode l1, ListNode l2) {
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        while(l1 != null && l2 != null) {
            if(l1.val <= l2.val) {
                tmp.next = l1;
                l1 = l1.next;
            }else {
                tmp.next = l2;
                l2 = l2.next;
            }
            tmp = tmp.next;
        }
        if(l1 != null) {
            tmp.next = l1;
        }
        if(l2 != null) {
            tmp.next = l2;
        }
        return newHead.next;
    }
}

合并k个已排序的链表

https://www.nowcoder.com/practice/65cfde9e5b9b4cf2b6bafa5f3ef33fa6?tpId=117&&tqId=37747&&companyId=665&rp=1&ru=/company/home/code/665&qru=/ta/job-code-high/question-ranking

import java.util.*;
public class Solution {
    public ListNode mergeKLists(ArrayList<ListNode> lists) {
        if (lists == null) {
            return null;
        }
        PriorityQueue<ListNode> queue = new PriorityQueue<>((ListNode a, ListNode b) -> (a.val - b.val));
        for (ListNode list : lists) {
            if (list != null) {
                queue.add(list);
            }
        }
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;

        while (!queue.isEmpty()) {
            ListNode node = queue.poll();
            tmp.next = node;
            if (node.next != null) {
                queue.add(node.next);
            }
            tmp = tmp.next;
        }
        return newHead.next;
    }
}


class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if(lists == null || lists.length ==0) {
            return null;
        } 
        return func(lists, 0, lists.length - 1);
    }

    private ListNode func(ListNode[] lists, int left, int right) {
        if(left == right){
            return lists[left];
        }
        int mid = left + right >> 1;
        ListNode leftList = func(lists, left, mid);
        ListNode rightList = func(lists, mid + 1, right);
        return merge(leftList, rightList);
    }

    public ListNode merge(ListNode first,ListNode second) {
        ListNode newHead = new ListNode(-1);
        ListNode tmp = newHead;
        while (first != null && second != null) {
            if(first.val <= second.val){
                tmp.next = first;
                first = first.next;
            }
            else{
                tmp.next = second;
                second = second.next;
            }
            tmp = tmp.next;
        }
        if(first != null){
            tmp.next = first;
        }
        if(second != null){
            tmp.next = second;
        }
        return newHead.next;
    }
}

持续更新中。。。。。。。

赵jc
关注
专栏目录
链表面试题
你又来看我了，一起学习吧
09-11 4444
前言： 在面试中，最经常被提及的就是链表，，但又因为需要对指针进行操作，凡是涉及到指针的，都需要我们具有良好的编程基础才能确保代码没有任何错误。 链表是一种动态的数据结构，因为在创建链表时，我们不需要知道链表的长度，当插入一个结点时，只需要为该结点分配内存，然后调整指针的指向来确保新结点被连接到链表中。所以，它不像数组，内存是一次性分配完毕的，而是每添加一个结点分配一次内存。正是因为这点，所以...
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6809
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表有关的常见面试题
weixin_30414245的博客
05-03 80
1.单链表逆序 实现1： 遍历: 1: /* 2: * 遍历链表， 将每个结点的next置为其前驱 3: * 遍历过程中需要额外的指针来记录结点的前驱和后继 4: */ 5: LinkList ReverseList(LinkList L) 6: { 7: if (!L || !L->...
反转链表（leetcode每日打卡）
m0_60264772的博客
11-15 390
目录 题目描述 思路 题解 题目描述 给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。 示例 1： 输入：head = [1,2,3,4,5] 输出：[5,4,3,2,1] 思路 假设链表为 1→2→3→∅，我们想要把它改成∅←1←2←3。 在遍历链表时，将当前节点的 \textit{next}next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。 题解 c.
C语言链表相关面试题.zip
最新发布
03-13
C语言链表相关的面试题在软件开发领域的面试中是非常常见的，这是因为链表作为一种基本的数据结构，对于理解数据结构、算法以及内存管理等方面有着重要的作用。以下是一些关于C语言链表的面试题及其详细解释。 1. ...
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
链表之十大经典面试题
weixin_64702703的博客
04-06 1640
快速学习链表面试题
关于链表的一些面试题
07-25
关于链表的面试题主要考察应聘者对链表这种基本数据结构的理解和操作能力，下面详细讲解每个面试题所涉及的知识点。 题一检测单链表是否有环的知识点： 要检测链表是否有环，可以使用快慢指针的方法。具体操作为，...
链表相关面试题（基础篇）
agate_zhang的博客
07-24 675
链表相关面试题（基础篇）     链表是一种常见的基础数据结构，是一种线性表，是一种物理存储单元上非连续、非顺序的存储结构。链表由一系列节点组成，节点可以在运行时动态生成。每个节点包括存储数据元素的数据域和存储下一个节点地址的指针域两个部分。相比于线性表顺序结构，操作复杂。数据元素的逻辑顺序也是通过链表中的指针链接次序实现的。     线性表的链式存储特点是用一组任意的存储单元存储线性
链表笔试面试题
热门推荐
fatshaw的专栏
05-28 1万+
<br />1.已知链表的头结点head,写一个函数把这个链表逆序<br />void List::reverse() { list_node * p = head; list_node * q = p->next; list_no
链表面试题总结（一）
宇哲
06-11 1万+
基于上一次写的链表，现在，我们来讨论下面这些问题。1.链表的冒泡排序 2.删除无头非尾节点 3.反转链表 4.在当前节点前插入一个数据x 5.查找链表的中间节点。 6.删除单链表的倒数第K个节点（K>1&&K<总长度）对于上面这6个问题，我们进行分析与解答。链表的代码我都已经写过博客：数据结构—单链表的实现另外，我也在我的github上有链表的代码，github链接如还有什么问题，可以发邮
C++链表反转面试题与答案详解
首先，针对链表反转问题，它是一个经典的面试题目，涉及基础的数据结构操作。在单向链表中，要实现反转，可以采用迭代或递归的方法。迭代方法通过设置两个指针，一个pre指向前一个节点，一个cur指向当前节点，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值