Merge Two Sorted Lists & Remove Nth Node From End of List

1.合并两个排好序的list

Merge Two Sorted Lists

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

2.删除list倒数第n个元素

Remove Nth Node From End of List

Given a linked list, remove the nth node from the end of list and return its head.

For example,

   Given linked list: 1->2->3->4->5, and n = 2.

   After removing the second node from the end, the linked list becomes 1->2->3->5.

Note:
Given n will always be valid.
Try to do this in one pass.

两个问题合在一个工程里面测试

 package com.rust.datastruct;

 public class MergeTwoSortedLists {
     public static ListNode mergeTwoSortedLists(ListNode l1, ListNode l2) {
         ListNode r1 = new ListNode(0);
         ListNode res = r1;
         ListNode t1 = l1;//java 中这样的赋值操作，对了l1操作等同于对t1操作
         ListNode t2 = l2;
         while (t1 != null && t2 != null){
             if (t1.val <= t2.val) {
                 r1.next = t1;
                 t1 = t1.next;
             } else {
                 r1.next = t2;
                 t2 = t2.next;
             }
             r1 = r1.next;
         }
         if (t1 != null) {
             r1.next = t1;
         }
         if (t2 != null) {
             r1.next = t2;
         }
         res = res.next;
         return res;
     }
     /**
      * @param head
      * @param n
      * @return ListNode
      */
     public static ListNode removeNthFromEnd(ListNode head, int n) {
         if (n == 0) return head;
         ListNode fakeNode = head;
         int count = 0;
         while (fakeNode != null) {
             fakeNode = fakeNode.next;
             count++;
         }
         fakeNode = head;
         if (n == count) {
             head = head.next;
             return head;
         } else {
             for (int i = 0; i < count; i++) {
                 if (i + n + 1== count) {
                     System.out.println(fakeNode.val);
                     ListNode cut = fakeNode.next.next;
                     fakeNode.next = cut;
                     count--;
                     continue;
                 }
                 fakeNode = fakeNode.next;
             }
         }
         return head;
     }

     public static void main(String args[]){
         ListNode l1 = new ListNode(0);
         ListNode l2 = new ListNode(1);
         ListNode p1 = l1;
         ListNode p2 = l2;
         /*initial the list*/
         for (int i = 2; i <= 10; i++) {
             if (i%2 == 0) {
                 p1.next = new ListNode(i);
                 p1 = p1.next;
             } else {
                 p2.next = new ListNode(i);
                 p2 = p2.next;
             }
         }
         p1 = l1;
         p2 = l2;
         System.out.println("input List l1 and l2");
         showData(l1, l2);//after show,l1 and l2 value didn't change!
         System.out.println("mergeTwoLists(l1, l2) -->");
         ListNode res = mergeTwoSortedLists(l1, l2);
         /**  test  mergeTwoSortedLists  start ************/
         while (res.next != null) {// res is destroyed
             System.out.print(res.val + "\t");
             res = res.next;
         }
         System.out.println(res.val);
         System.out.println("After merge");
         /** End ***********************************/
         /** test removeNthFromEnd  start **************/
         showData(l1, l2);
         // use l2 to test
         int n = 1;
         l2 = removeNthFromEnd(l2,n);
         showData(l1, l2);
         /** End ***********************************/
     }
     /**
      * Print the ListNode
      * @param l1 ListNode
      * @param l2 ListNode
      */
     public static void showData(ListNode l1, ListNode l2){
         System.out.println("l1 -->");
         while (l1.next != null) {
             System.out.print(l1.val + "\t");
             l1 = l1.next;
         }
         System.out.println(l1.val);
         System.out.println("l2 -->");
         while (l2.next != null) {
             System.out.print(l2.val + "\t");
             l2 = l2.next;
         }
         System.out.println(l2.val);
         System.out.println("/************************************/");
     }
 }

 //Definition for singly-linked list.
 class ListNode {
     int val;
     ListNode next;
     ListNode(int x) { val = x; }
 }

输出：

input List l1 and l2
l1 -->
0 2 4 6 8 10
l2 -->
1 3 5 7 9
/************************************/
mergeTwoLists(l1, l2) -->
0 1 2 3 4 5 6 7 8 9 10
After merge
l1 -->
0 1 2 3 4 5 6 7 8 9 10
l2 -->
1 2 3 4 5 6 7 8 9 10
/************************************/
9
l1 -->
0 1 2 3 4 5 6 7 8 9
l2 -->
1 2 3 4 5 6 7 8 9
/************************************/