链表反转面试题

leetcode92指定区间反转

头插法：

代码：

 public static ListNode reverseBetween2(ListNode head, int left, int right) {
        // 设置 dummyNode 是这一类问题的一般做法
        ListNode dummyNode=new ListNode(-1);
        dummyNode.next=head;
        ListNode pre=dummyNode;
        for (int i=0;i<left-1;i++){
            pre=pre.next;
        }
        ListNode cur=pre.next;
        for (int i=0;i<right-left;i++){
            ListNode next=cur.next;
            cur.next=next.next;
            next.next=pre.next;
            pre.next=next;
        }
        return dummyNode.next;
    }

穿针引线法

找到指定片段，然后断开反转再接上

代码：

/**
     * 方法1：穿针引线法
     *
     * @param head
     * @param left
     * @param right
     * @return
     */
    public static ListNode reverseBetween(ListNode head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode dummyHead=new ListNode(-1);
        dummyHead.next=head;
        ListNode pre=dummyHead,l=head;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i=0;i<left-1;i++){
            l=l.next;
            pre=pre.next;
        }
        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点,next再走一步
        ListNode next=pre,r=pre;
        for (int i=0;i<right-left+1;i++){
            r=r.next;
            next=next.next;
        }
        next=next.next;
        // 第 3 步：切断出一个子链表（截取链表）
        pre.next=null;
        r.next=null;
        // 第 4 步：同第 206 题，反转链表的子区间
        ListNode newhead=reverseList(l);
        // 第 5 步：接回到原来的链表中
        pre.next=newhead;
        l.next=next;
        return dummyHead.next;
    }

    /**
     * 基本的反转方法
     *
     * @param head
     * @return
     */
    public static ListNode  reverseList(ListNode head) {
        ListNode pre=head;
        ListNode cur=head.next;
        while (cur!=null){
            ListNode next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        return pre;
    }

leetcode24两两交换表中节点

 public static  ListNode swapPairs(ListNode head) {
        ListNode dummyHead=new ListNode(-1);
        dummyHead.next=head;
        ListNode cur=dummyHead;
        while (cur.next!=null&&cur.next.next!=null){
            ListNode node1=cur.next,node2=cur.next.next;
            cur.next=node2;
            node1.next=node2.next;
            node2.next=node1;
            cur=node1;
        }
        return dummyHead.next;

    }

 链表加法

       leetcode369链表加一

plus是进位，addr是个位加一

 public static ListNode plusOne(ListNode head) {
        Stack<Integer> stack=new Stack<>();
        ListNode cur=head;
        while (cur!=null){
            stack.push(cur.val);
            cur=cur.next;
        }
        ListNode dummyHead=new ListNode(-1);
        int plus=0,addr=1;
        while (!stack.isEmpty()||plus>0){
            int digit=stack.empty()?0:stack.pop();
            int sum=digit+addr+plus;
            plus=sum>=10?1:0;
            sum=sum>=10?sum-10:sum;
            ListNode temp=new ListNode(sum);
            temp.next=dummyHead.next;
            dummyHead.next=temp;
            addr=0;
        }
        return dummyHead.next;
    }

leetcode445链表加法

用栈实现：

/**
     * 通过栈来实现
     *
     * @param l1
     * @param l2
     * @return
     */
    public static ListNode addInListByStack(ListNode l1, ListNode l2) {
        Stack<Integer> st1 = new Stack<>();
        Stack<Integer> st2 = new Stack<>();
        while (l1 !=null){
            st1.push(l1.val);
            l1 = l1.next;
        }
        while (l2 !=null){
            st2.push(l2.val);
            l2 = l2.next;
        }
        ListNode newHead=new ListNode(-1);
        int carry=0;
        while (!st1.isEmpty()||!st2.isEmpty()||carry!=0){
            int a,b;
            a=st1.isEmpty()?0:st1.pop();
            b=st2.isEmpty()?0:st2.pop();
            int sum=a+b+carry;
            int ans=sum%10;
            carry=sum/10;
            ListNode node=new ListNode(ans);
            node.next=newHead.next;
            newHead.next=node;
        }
        return newHead.next;

    }

 用链表反转实现

 /**
     * 方法2：通过链表反转来实现
     *
     * @param head1
     * @param head2
     * @return
     */
    public static ListNode addInListByReverse(ListNode head1, ListNode head2) {
        head1 = reverse(head1);
        head2 = reverse(head2);
        ListNode head = new ListNode(-1);
        ListNode cur = head;
        int carry = 0;
        while (head1 != null || head2 != null) {
            int val = carry;
            if (head1 != null) {
                val += head1.val;
                head1 = head1.next;
            }
            if (head2 != null) {
                val += head2.val;
                head2 = head2.next;
            }
            cur.next = new ListNode(val % 10);
            carry = val / 10;
            cur = cur.next;
        }
        if (carry > 0) {
            cur.next = new ListNode(carry);
        }
        return reverse(head.next);
    }

    private static ListNode reverse(ListNode head) {
        ListNode cur = head;
        ListNode pre = null;
        while (cur != null) {
            ListNode temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        return pre;
    }