写算法第三天-两个有序链表合并排序

public class ListNode {
    //数据
    String data;
    int vir;
    //下一个节点
    ListNode next;

    public String getData() {
        return data;
    }

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

    public ListNode getNext() {
        return next;
    }

    public int getVir() {
        return vir;
    }

    public void setVir(int vir) {
        this.vir = vir;
    }

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

/* 两个有序链表合并排序 */

 /* 两个有序链表合并排序 */
    public static ListNode merge(ListNode list1, ListNode list2) {
        /**
         思路，已经排好序了，从表头开始比较
         两个表头相互比较，谁小谁进入合并链表
         然后让小链表的下一个链表指向当前链表
         直到有一个链表为空，那么直接将不为空的链表追加合并链表里
         */
        //合并链表
        ListNode vir = new ListNode();
        //中间变量
        ListNode pointer = vir;
        while(true){
            //如果链表为空那么直接将另外一个链表追加到最后
            if (list1==null){
                pointer.setNext(list2);
                break;
            }
            //如果链表为空那么直接将另外一个链表追加到最后
            if (list2==null){
                pointer.setNext(list1);
                break;
            }
            //两个表头比较，小的被添加进去
            if(list1.getVir()>=list2.getVir()){
              //小的被添加进去
                pointer.setNext(list2);
                //让下一个成为表头
                list2=list2.getNext();
            }else {
                //小的被添加进去
                pointer.setNext(list1);
                //让下一个成为表头
                list1=list1.getNext();
            }
            //防止出现链表的下一个存储的是自己，这样会出现死循环
            if(pointer!=pointer.getNext()) {
                //让下一个成为当前链表
                pointer = pointer.getNext();
            }else {
                System.out.println("出现一个异常链节点");
            }
        }
        //返回合并排序完的链表
        return vir.getNext();
    }

测试结果：

/**
 * @ClassName Testt
 * @description: TODO
 * @Author: hdt
 * @createDate: 2023/5/6
 * @version: 1.0
 */
public class Testt {
    public static void main(String[] args) {
        ListNode head1=new ListNode();
        head1.setVir(2);
        ListNode head2=new ListNode();
        head2.setVir(1);
        //尾插法，添加节点head1
        for(int i=3;i<20;i++){
            if(i%2==0) {
                ListNode next = new ListNode();
                next.setData("" + i);
                next.setVir(i);
                //尾插法，找到最后一个添加
                ListNode mid = head1;
                while (mid.getNext() != null) {
                    mid = mid.getNext();
                }
                mid.setNext(next);
            }
        }
        //尾插法，添加节点head2
        for(int i=3;i<28;i++){
            if(i%2!=0) {
                ListNode next = new ListNode();
                next.setData("" + i);
                next.setVir(i);
                //尾插法，找到最后一个添加
                ListNode mid = head2;
                while (mid.getNext() != null) {
                    mid = mid.getNext();
                }
                mid.setNext(next);
            }
        }
        //排序好的head1链表遍历
        System.out.println("排序好的head1链表遍历");
        ListNode mid1=head1.getNext();
        System.out.print(head1.getVir());
        while (mid1!=null){
            System.out.print("<--"+mid1.getVir());
            mid1=mid1.getNext();
        }
        System.out.println("");
        //排序好的head2链表遍历
        System.out.println("排序好的head2链表遍历");
        mid1=head2.getNext();
        System.out.print(head2.getVir());
        while (mid1!=null){
            System.out.print("<--"+mid1.getVir());
            mid1=mid1.getNext();
        }
        System.out.println("");
        //排序好的链表合并
        ListNode merge = TestListNode.merge(head1,head2);
        //排序好的链表合并
        System.out.println("排序好的链表合并");
         mid1=merge.getNext();
        System.out.print(merge.getVir());
        while (mid1!=null){
            System.out.print("<--"+mid1.getVir());
            mid1=mid1.getNext();
        }
        System.out.println("");

    }
}