牛客：数字翻转 + 143. 重排链表（快慢指针+合并链表+部分翻转链表；翻转链表）

1、数字翻转

题目描述

对于一个整数X，定义操作rev(X)为将X按数位翻转过来，并且去除掉前导0。例如:
如果 X = 123，则rev(X) = 321;
如果 X = 100，则rev(X) = 1.
现在给出整数x和y,要求rev(rev(x) + rev(y))为多少？

输入描述:

输入为一行，x、y(1 ≤ x、y ≤ 1000)，以空格隔开。

输出描述:

输出rev(rev(x) + rev(y))的值

示例1

输入
复制

123 100

输出
复制

223

public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int x=scanner.nextInt();
        int y=scanner.nextInt();
        x=rev(x);
        y=rev(y);
        x+=y;
        x=rev(x);
        System.out.println(x);
    }

    //这个方法不如rev2巧妙
    private static int rev(int num){
        int reverseNum=0;
        StringBuilder sb=new StringBuilder();

        while (num!=0){
            int yushu=num%10;
            num/=10;
            sb.append(yushu);
        }
        reverseNum=new Integer(sb.toString());
        return reverseNum;
    }

    //方法2
    private static int rev2(int num){
        int reverseNum=0;

        while (num!=0){
            int yushu=num%10;
            num/=10;
            reverseNum=reverseNum*10+yushu;
        }
        return reverseNum;
    }

    //方法3
    private static int rev3(int num){
        StringBuilder sb=new StringBuilder(num);
        String str=sb.reverse().toString();
        return Integer.parseInt(str);
    }

2、143. 重排链表

给定一个单链表 L：L0→L1→…→Ln-1→Ln ，
将其重新排列后变为： L0→Ln→L1→Ln-1→L2→Ln-2→…

你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1:

给定链表 1->2->3->4, 重新排列为 1->4->2->3.

示例 2:

给定链表 1->2->3->4->5, 重新排列为 1->5->2->4->3.

public void reorderList(ListNode head) {
        if(head==null||head.next==null) return;

        //Find the middle of the list
        ListNode p1=head;
        ListNode p2=head;
        while(p2.next!=null&&p2.next.next!=null){
            p1=p1.next;
            p2=p2.next.next;
        }

        //Reverse the half after middle  1->2->3->4->5->6 to 1->2->3->6->5->4
        ListNode preMiddle=p1;
        ListNode preCurrent=p1.next;
        while(preCurrent.next!=null){
            ListNode current=preCurrent.next;
            preCurrent.next=current.next;
            current.next=preMiddle.next;
            preMiddle.next=current;
        }

        //Start reorder one by one  1->2->3->6->5->4 to 1->6->2->5->3->4
        p1=head;
        p2=preMiddle.next;
        while(p1!=preMiddle){
            preMiddle.next=p2.next;
            p2.next=p1.next;
            p1.next=p2;
            p1=p2.next;
            p2=preMiddle.next;
        }
    }

翻转链表：

//206. 反转链表
    /*
    * 输入: 1->2->3->4->5->NULL
    * 输出: 5->4->3->2->1->NULL
    */
    public ListNode reverseList(ListNode head) {
        ListNode newHead=null;
        while (head!=null){
            ListNode next=head.next;
            head.next=newHead;
            newHead=head;
            head=next;
        }
        return newHead;
    }