完整代码实例: Java实现合并两个有序的单链表

代码如下:

package DataStrcture.ArrayDemo.singlelistdemo;

public class MergerOrderedSingleList {
    //结点内部类
    static class Node{
        Node next;
        int id;
        String name;

        ///构造器和toString()
        public Node(int id, String name){
            this.id = id;
            this.name = name;
        }
        public String toString(){
            return "id: "+id+"-"+this.name;
        }
    }

    头结点
    Node head = new Node(0,"");

    //顺序添加结点到链表
    public void addNodeByOrder(Node node){
        ///临时变量
        Node temp = head;
        ///查找插入位置
        /*
        链表按顺序插入的情况:
        1. node.id = temp.id; flag=false
        2. node.id > temp.id; flag=flase;
        3. node.id < temp.id; flag=true;
         */
        boolean flag = false;
        while(true) {
            //0. 这个节点正好是最后一个位置
            if (temp.next == null) {
                flag = true;
                break;
            }
            //1. id相同
            if(temp.next.id == node.id)
                break;

            //2. temp.id > node.id
            if(temp.next.id > node.id){
                flag = true;
                break;
            }
            //3.temp.id < node.id
            temp = temp.next;
        }

        if(flag){
            node.next = temp.next;
            temp.next = node;
        }else{
            System.out.println("无法插入这个结点: "+node);
        }
    }
    /// 两个单链表的合并
    // ( 链表1- list_1 ,头结点 head_1,   链表2-- list_2, 头结点 head_2)
    /*   合并链表的头为链表1或链表2中较小的那个!
        1. 两个链表都为空,直接返回
        2.其中一个为空,把另一个结点直接返回
        3. 两个链表分别遍历并相互比较,小的那个插入到合并链表中
        4, 有一个链表已经遍历到末尾了, 把另外一个剩的链表连接到合并链表后即可;
     */

    public static Node mergeList(Node head_1, Node head_2){

        //两个链表都为空,或者其中一个为空情况的处置;
        if(head_1 ==null || head_2 == null)
            return null;
        if(head_1.next == null)
            return head_2;
        if(head_2.next == null)
            return head_1;
        /// 对链表1, 链表2分别设置临时变量, 目的是为了分别遍历
        Node temp_1 = head_1.next;
        Node temp_2 = head_2.next;
        // 合并链表的首元结点为 链表1 和 链表2中较小的那个节点
        Node head_3 =head_2;
        Node temp_3 = head_3; ///合并链表的临时变量
        ///遍历两个链表并比较
        while(true){
            // 链表1号节点小, 把合并链表的临时指针指向链表1的这个节点(尾插法)
            if( temp_1.id < temp_2.id){
                temp_3.next = temp_1;
                temp_3 = temp_1;
                temp_1 = temp_1.next;
            //链表2号节点小,
            }else if(temp_1.id > temp_2.id){
                temp_3.next = temp_2;
                temp_3 = temp_2;
                temp_2 = temp_2.next;
            // 链表1和2的结点的值相同, 我们就把两个链表分别都往后移动
            }else{
                temp_1 = temp_1.next;
                temp_2 = temp_2.next;
            }
            /// 这里千万要注意! 如果设置了temp_1.next 或temp_2.next判空的话,会把链表的最后一个结点给落掉!
            if(temp_1 == null || temp_2 == null){
                break;
            }

        }

        if(temp_1 != null)
            temp_3.next= temp_1;
        if(temp_2 != null)
            temp_3.next = temp_2;

        return head_3;
    }




    ///输出链表
    public void  list(){
        Node temp = head;

        while(true){
            if(temp.next == null)
                break;
            temp = temp.next;
            System.out.println(temp);
        }
    }
    // 获取头结点
    public Node getHead(){
        return head;
    }
    ///测试
    public static void main(String[] args) {
        Node node_1 = new Node(0,"小王");
        Node node_2 = new Node(8,"小🐖");
        Node node_3 = new Node(4,"小狗");
        Node node_4 = new Node(6,"小牛");
        Node node_5 = new Node(2,"小粑粑");
        Node node_6 = new Node(3,"小鸡");
        Node node_7 = new Node(2,"小沙比");

        Node node_8 = new Node(1,"小王");
        Node node_9 = new Node(10,"小🐖");
        Node node_10 = new Node(5,"小狗");
        Node node_11 = new Node(9,"小牛");
        Node node_12 = new Node(7,"小粑粑");


        MergerOrderedSingleList sl = new MergerOrderedSingleList();
        MergerOrderedSingleList sl_1 = new MergerOrderedSingleList();
        MergerOrderedSingleList s3 = new MergerOrderedSingleList();

        sl.addNodeByOrder(node_1);
        sl.addNodeByOrder(node_2);
        sl.addNodeByOrder(node_3);
        sl.addNodeByOrder(node_4);
        sl.addNodeByOrder(node_5);
        sl.addNodeByOrder(node_6);
        sl.addNodeByOrder(node_7);


        sl_1.addNodeByOrder(node_8);
        sl_1.addNodeByOrder(node_9);
        sl_1.addNodeByOrder(node_10);
        sl_1.addNodeByOrder(node_11);
        sl_1.addNodeByOrder(node_12);


        sl.list();
        System.out.println("==========================");
        System.out.println("单链表2号:");
        sl_1.list();
        System.out.println("=========================");
        System.out.println("两条单链表合并后的链表为: ");
        Node head = mergeList(sl.getHead(), sl_1.getHead());
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
            System.out.println(temp);
        }

    }
}