【算法专场】链表篇（上）-优快云博客

链表常用技巧

链表相关的题目，学过数据结构的可以都做过一些，接下来，我们再通过一些算法题目来加深一下对链表的操作。

2. 两数相加 - 力扣（LeetCode）

算法代码

class Solution {
        public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
      ListNode newHead=new ListNode(-1);
      ListNode cur=newHead;
      ListNode cur1=l1;
      ListNode cur2=l2;
      int val=0;
      while(cur1!=null||cur2!=null||val!=0){
          if(cur1!=null){
              val+=cur1.val;
              cur1=cur1.next;
          }
          if(cur2!=null){
              val+=cur2.val;
              cur2=cur2.next;
          }
          ListNode node=new ListNode(val%10);
          val/=10;
          cur.next=node;
          cur=cur.next;
      }
      return newHead.next;
    }
}

24. 两两交换链表中的节点 - 力扣（LeetCode）

算法代码

  /**
     * 交换链表中的相邻节点
     * 该方法通过迭代的方式，两两交换链表中的节点
     * @param head 链表的头节点
     * @return 交换后的链表的头节点
     */
    public ListNode swapPairs1(ListNode head) {
        // 如果链表为空或只有一个节点，则直接返回原链表
        if(head==null||head.next==null) return head;
        //进行模拟
        ListNode dummy=new ListNode(-1);
        ListNode prev=dummy;
        dummy.next=head;
        // 每次处理两个节点，直到链表末尾
        while(prev.next!=null&&prev.next.next!=null){
            //记录节点
            ListNode node1=prev.next;//第一个节点
            ListNode node2=prev.next.next.next;//第三个节点
            // 交换两个节点
            prev.next=node1.next;
            prev.next.next=node1;
            node1.next=node2;
            // 更新prev指针，为下一次交换做准备
            prev=node1;
    
        }
        // 返回交换后的链表头节点
        return dummy.next;
    }

143. 重排链表 - 力扣（LeetCode）

算法代码

  /**
     * 重新排序单链表，使得链表的节点以交错的顺序排列
     * 实现方法是将链表分为两部分，然后反转第二部分，并将两部分交错合并
     *
     * @param head 链表的头节点
     */
    public void reorderList(ListNode head) {
        if (head == null || head.next == null) {
            return;
        }

        // 使用快慢指针找到链表的中间节点
        ListNode slow = head;
        ListNode fast = head;
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
        }

        // 反转链表的后半部分
        ListNode head2=reverse(slow);

        // 交错合并链表的前半部分和反转后的后半部分
        while(head2.next!=null){
            ListNode temp=head.next;
            ListNode temp2=head2.next;
            head.next=head2;
            head2.next=temp;
            head=temp;
            head2=temp2;
        }
    }

    /**
     * 反转链表
     *
     * @param head 链表的头节点
     * @return 反转后的链表的头节点
     */
    public ListNode reverse(ListNode head){
        ListNode pre=null;
        ListNode cur=head;
        while(cur!=null){
            ListNode temp=cur.next;
            cur.next=pre;
            pre=cur;
            cur=temp;
        }
        return pre;
    }

19. 删除链表的倒数第 N 个结点

算法代码

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy=new ListNode(-1);
        dummy.next=head;
        ListNode slow=dummy;
        ListNode fast=dummy;
        n++;
        while(n--!=0&&fast!=null){
            fast=fast.next;
        }
        while(fast!=null){
            fast=fast.next;
            slow=slow.next;
        }
        slow.next=slow.next.next;
        return dummy.next;
    }
}