java合并lsit JAVA合并链表后排序

链表排序是链表有序合并的前提，所以就放在一起写了

链表的冒泡排序，

/**
     *  链表的冒泡排序
     *  排序思路：
     *  逐个节点进行排序
     *  把当前节点和下个节点的值进行比较，根据结果处理
     *  主要是更换了节点的值
     *  没有更换节点对象本身
     *
     * @param head
     * @return
     */
    static LinearList bubbleSort(LinearList head) {
        //判断链表是否需要排序
        if (head == null || head.nextNode == null) {
            return null;
        }
        //保存入参头节点的引用
        LinearList temp = head;

        /**
         * 尾部节点，是循环截止节点
         */
        LinearList tail = null;
        int in = 0;

        /**
         * 外部遍历是遍历每个节点
         */
        while(head.nextNode != tail) {
            /**
             * 内部遍历是把当前冒泡的节点进行逐个比较
             */
            while (head.nextNode != tail) {
                //互换节点的值
                if (head.i > head.nextNode.i) {
                    in = head.i;
                    head.i = head.nextNode.i;
                    head.nextNode.i = in;
                }
                //指针下移一位
                head = head.nextNode;
            }
            /**
             * tail作为遍历截止节点
             * 内部循环结束一次则成功把一个数放到它合适的位置，下次遍历不需要再遍历到已经排好位置的这个数
             * tail既是作为已经最后一个排好序的节点的引用
             */
            tail = head;
            //指针重新回到链表头部
            head = temp;
        }

        return head;
    }

 

循环方式完成两条链表有序合并

/**
     * 循环方式
     * 把两条两边合并为一条单调递增链表
     *
     * @param head
     * @param head1
     * @return
     */
    static LinearList merge(LinearList head,LinearList head1){

        /**
         * 声明两个链表节点实例
         * 分别保存两条链表排序后的头节点
         */
        LinearList temp = null,temp1 = null;

        /**
         * 对两条链表进行排序
         */
        temp = bubbleSort(head);
        temp1 = bubbleSort(head1);

        LinearList megre = null;

        /**
         *
         * 声明合并后的链表的头节点
         * 作为作为返回值
        */
        LinearList megre1 = null;

        /**
         * 比较两条链表的头节点
         * 确定谁的头节点作为合并后链表的头节点
         */
        if(temp.i>temp1.i){
            megre = temp1;
            temp1 = temp1.nextNode;
            megre1 = megre;
        }else{
            megre = temp;
            temp = temp.nextNode;
            megre1 = megre;
        }

        /**
         * 循环中一次对比两条链表指针所对应的节点的值
         * 值小的插入新链表中
         */
        while(temp != null || temp1 != null){
            System.out.println("----------");
            if(temp.i>temp1.i){
                megre.nextNode = temp1;
                temp1 = temp1.nextNode;
                megre = megre.nextNode;
                /**
                 * 如果再此次插入新链表的操作指针下移后
                 * temp1 节点所对应的链表已经没有下一个节点了
                 * 则把排序好的另一条链表的剩余部分直接插入新链表的下个节点
                 * 下面同理
                 */
                if(temp1 == null){
                    megre.nextNode = temp;
                    // 组合完毕 跳出循环
                    break;
                }
            }else{
                megre.nextNode = temp;
                temp = temp.nextNode;
                megre = megre.nextNode;
                if(temp == null){
                    megre.nextNode = temp1;
                    break;
                }
            }

        }
        //返回合并后新链表的头节点
        return megre1;
    }

递归方式完成链表的有序合并

因为排序不需要写进递归排序方法内，所以在调用递归合并方法前对两条链表进行排序

LinearList temp = Utils.bubbleSort(linearList);
	LinearList temp1 = Utils.bubbleSort(linearList1);
	linearList2 = Utils.merge1(temp,temp1);

接下来是递归合并方法

/**
     * 递归方式
     * 把链条两边合并成一条单调递增的链表
     * ps：因为排序不需要递归，所以再调用本方法前就进行排序
     * @param head1
     * @param head2
     * @return
     */
    static LinearList merge1(LinearList head1,LinearList head2){

        /**
         * 递归结束的标志
         * 其中一条链表没了就把另一条链表剩余部分接到新链表后面去
         */
        if(head1 == null) {
            return head2;
        }
        if (head2 == null){
            return head1;
        }
        /**
         * 声明两个链表节点实例
         * 分别保存两条链表排序后的头节点
         */
        LinearList temp1 = null,temp2 = null;

        /**
         * 对两条链表进行排序
         */
        temp1 = head1;
        temp2 = head2;

        //声明一个新链表头节点
        LinearList merge = new LinearList();

        /**
         * 比较链表1和链表2的值的大小
         * 值小的则插入新链表
         * 递归调用本方法，参数中节点插入新链表的链表指针下移一位
         * 返回值赋值给新链表新插入节点的下一节点
         */
        if(temp1.i>temp2.i){
            merge = temp2;
            merge.nextNode = merge1(temp1,temp2.nextNode);
        }else{
            merge = temp1;
            merge.nextNode = merge1(temp1.nextNode,temp2);
        }
        return merge;
    }

实现结果

链表1

链表2

 

新链表