剑指offer java NO17

NO17
输入两个递增排序的链表，合并这两个链表
并使新链表中结点仍然是按照递增排序的。
例如输入1->3->5->7和2->4->6->8，
则合并之后的升序链表应该是1->2->3->4->5->6->7->8 。

先写一个单向链表类

/**
 * @author 
 * 单向链表
 */
public class Node {

    String data;
    Node next;

    public Node(){

    }
    public Node(String data) {
        super();
        this.data = data;
    }

    public Node(String data, Node next) {
        super();
        this.data = data;
        this.next = next;
    }

    public void setData(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }

    public void setNext(Node next) {
        this.next = next;
    }

    public Node getNext() {
        return next;
    }
}

解题代码：

import com.company.base.Node;
/**
 * 输入两个递增排序的链表，合并这两个链表
 * 并使新链表中结点仍然是按照递增排序的。
 * 例如输入1->3->5->7和2->4->6->8，
 * 则合并之后的升序链表应该是1->2->3->4->5->6->7->8 。
 */
public class NO17 {
    public static void main(String[] args) {
        Node node1 = new Node("1");
        Node node2 = new Node("2");
        Node node3 = new Node("3");
        Node node4 = new Node("4");
        Node node5 = new Node("5");
        Node node6 = new Node("6");
        Node node7 = new Node("7");
        Node node8 = new Node("8");
        node1.setNext(node3);
        node2.setNext(node4);
        node3.setNext(node5);
        node4.setNext(node6);
        node5.setNext(node7);
        node6.setNext(node8);
        NO17A no17A = new NO17A();
        System.out.println("list1: ");
        no17A.printOrderList(node1);
        System.out.println();
        System.out.println("list2: ");
        no17A.printOrderList(node2);
        System.out.println();
        System.out.println("oderlist: ");
        no17A.orderListMethod(node1, node2);
    }
}

class NO17A{
    //封装的方法
    public void orderListMethod(Node head1, Node head2){
        printOrderList(orderList(head1, head2));
    }
    //对两个链表进行排序
    private Node orderList(Node head1, Node head2){
        Node temp = new Node();
        Node temp1 = new Node();
        temp1 = head1;
        //如果有任意一个链表为空，则抛出异常
        if (head1 == null || head2 == null)
        {
            throw new RuntimeException("any of the two lists shouldn't be empty!");
        }
        /*如果链表1的头结点大于链表2头结点，则将head1 与 head2 互换，确保链表1的头结点小于等于链表2头结点*/
        if (Integer.parseInt(head1.getData()) > Integer.parseInt(head2.getData()))
        {
            temp = head1;
            head1 = head2;
            head2 = temp;
        }
        //排序过程
        for (; head1.getNext() != null; head1 = head1.getNext())
        {
        	/*如果head1 的下一个节点的值大于head2，则将和head2 的节点插入其中*/
            while (Integer.parseInt(head1.getNext().getData()) >= Integer.parseInt(head2.getData()) )
            {
                temp = head2.getNext();
                head2.setNext(head1.getNext());
                head1.setNext(head2);
                //如果head2 有下一个节点，则将head2右移一个
                if (temp.getData() != null)
                {
                    head2 = temp;
                }
                /*如果没有，说明链表2已经完全排序结束，可以直接输出链表头部节点*/
                else
                {
                    return temp1;
                }
            }
        }
        /*如果链表1已经循环结束之后链表2还有剩余的值，则需要将剩余的值的头结点接在链表1结尾进行输出*/
        if (head2.getData() != null){
            head1.setNext(head2);
        }
        return temp1;
    }
    //打印链表
    public void printOrderList(Node head){
        for (; head != null; head = head.getNext()){
            System.out.println(head.getData());
        }
    }
}

运行结果：

list1: 
1357

list2: 
2468

oderlist: 
12345678

Process finished with exit code 0

吃晚饭去了