Java合并两个单链表(破坏)

compareTo 封装的就是普通的> 、 <
show 打印链表
node 类似构造体

非递归

• 思路
  1.如果有一个null，返回另一个
  2.完成头结点的赋值
  3.剩余部分循环，直到其中一个遍历完
  4.将另一个接到后面
  5.返回头结点

    static <T> Node<T> mergeBigFirst(Node<T> f1,Node<T> f2){
            if(f1 == null){
                return f2;
            }
            if(f2 == null) {
                return f1;
            }
            Node<T> first;
            if(f1.compareTo(f2)>0){
                first = f1;
                f1 = f1.next;
            }else {
                first = f2;
                f2 = f2.next;
            }
            Node<T> newNode = first;
            while (f1!=null&&f2!=null){
                if(f1.compareTo(f2) >= 0){
                    newNode.next = f1;
                    f1 = f1.next;
                }else {
                    newNode.next = f2;
                    f2 = f2.next;

                }
                newNode = newNode.next;
            }
            if(f1 == null){
                newNode.next = f2;
            }else {
                newNode.next = f1;
            }
        return first;
    }

递归

和非递归思路差不多，从链接的角度考虑返回值和重复步骤，控制好出口。

   static <T> Node<T>  recursiveMergeBigFirst(Node<T> f1,Node<T>f2){
        if(f1==null&&f2==null) {
            return null;
        }else if(f1 == null) {
            return f2;
        }else if(f2==null) {
            return f1;
        }else{
            if(f1.compareTo(f2) > 0){
                f1.next = recursiveMergeBigFirst(f1.next,f2);
                return f1;
            }else {
                f2.next = recursiveMergeBigFirst(f1,f2.next);
                return f2;
            }
        }

    }

测试

    public static void main(String[] args) throws InterruptedException {
        ReverserList<Integer> list1 = new ReverserList<>();
        ReverserList<Integer> list2 = new ReverserList<>();
        ReverserList<Integer> list3 = new ReverserList<>();
        ReverserList<Integer> list4 = new ReverserList<>();

        list1.add(-2);
        list1.add(-1);
        list1.add(-1);
        list1.add(10);
        list2.add(1);
        list2.add(2);
        list2.add(2);
        list2.add(8);

        list3.add(-2);
        list3.add(-1);
        list3.add(-1);
        list3.add(10);
        list4.add(1);
        list4.add(2);
        list4.add(2);
        list4.add(8);
        
        System.out.println("非递归:");
        ListUtils.show(ListUtils.mergeBigFirst(list1.first,list2.first));
        System.out.println();
        System.out.println("递归:");
        ListUtils.show(ListUtils.recursiveMergeBigFirst(list3.first,list4.first));


    }
}