leetcode-hot-100-20230922

2. 两数相加（Java实现）

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode p1 = l1;
        ListNode p2 = l2;
        ListNode newHead = new ListNode(0);
        ListNode resultHead = newHead;

        //保存当前位的数字
        int curr = 0;
        //保存进位的数字
        int jin = 0;

        //当两个节点均不等于空的时候进入循环
        while(p1 != null && p2 != null){
            //得到当前位置的数字
            curr = (p1.val + p2.val + jin) % 10;
            //将当前位置添加到结果链表中
            ListNode tmp = new ListNode(curr);
            newHead.next = tmp;
            newHead = newHead.next;

            //得到进位的数字
            jin = (p1.val + p2.val + jin) / 10;

            //到下一个结点
            p1 = p1.next;
            p2 = p2.next;
        }

        //如果l1还有剩余
        while(p1 != null){
            curr = (p1.val + jin) % 10;
            jin = (p1.val + jin) / 10;
            ListNode tmp = new ListNode(curr);
            newHead.next = tmp;
            newHead = newHead.next;

            p1 = p1.next;
        }

        //如果l2还有剩余
        while(p2 != null){
            curr = (p2.val + jin) % 10;
            jin = (p2.val + jin) / 10;

            ListNode tmp = new ListNode(curr);
            newHead.next = tmp;
            newHead = newHead.next;

            p2 = p2.next;
        }

        if(jin != 0){
            ListNode tmp = new ListNode(jin);
            newHead.next = tmp;
            newHead = newHead.next;
        }

        return resultHead.next;
    }
}

19. 删除链表的倒数第 N 个结点（Java实现）

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;

        ListNode slow = dummy;
        ListNode fast = dummy;

        for(int i = 0;i <= n;i++){
            fast = fast.next;
        }

        while(fast != null){
            slow = slow.next;
            fast = fast.next;
        }

        slow.next = slow.next.next;

        return dummy.next;
    }
}

24. 两两交换链表中的节点（Java实现）

/**
 * 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; }
 * }
 */
class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode resultNode = new ListNode(0);
        resultNode.next = head;
        ListNode curr = resultNode;

        while(curr.next != null && curr.next.next != null){
            //记录slow结点
            ListNode slowTmp = curr.next;
            //记录fastNode.next结点
            ListNode fastTmp = curr.next.next.next;

            //交换头结点指向头节点的下一个结点
            curr.next = curr.next.next;
            //更新curr.next.next为slowTmp
            curr.next.next = slowTmp;
            //更新curr为fastTmp
            curr.next.next.next = fastTmp;

            //更新curr
            curr = curr.next.next;

        }

        return resultNode.next;
    }
}