链表合成

题目描述:输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

方法一:递归

public class MergeList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ListNode list1 = new ListNode();
        ListNode list2 = new ListNode();
        ListNode second1=new ListNode();
        ListNode second2=new ListNode();
        ListNode third2=new ListNode();
        list1.nextNode=second1;
        list2.nextNode=second2;
        second2.nextNode=third2;
        list1.data=1;
        second1.data=3;
        list2.data=2;
        second2.data=2;
        third2.data=2;
        MergeList p = new MergeList();
        System.out.println(p.Merge2(list1, list2));
    }
    public ListNode Merge(ListNode list1,ListNode list2) {
           ListNode list= null;//定义一个合完之后的list,初始化为空,也可以是ListNode list=new ListNode();
           /*
            * public class ListNode {
                int val;
                ListNode next = null;

                ListNode(int val) {
                    this.val = val;
                }
}*/        if(list1==null) return list2;
           else if(list2==null) return list1;
           if(list1.data<list2.data){
               list=list1;
               list.nextNode=Merge(list1.nextNode,list2);
           }
           else{
               list=list2;
               list.nextNode=Merge(list2.nextNode,list1);
           }
           return list;
     }
}

方法二:非递归

public ListNode Merge2(ListNode list1,ListNode list2) {//非递归的方法
         ListNode list= null;//保存最后合成的链表
         ListNode current=null;//移动节点
         if(list1==null) return list2;
         else if(list2==null) return list1;
         while(list1!=null && list2!=null){//同时不为空的时候才可以比较
            if(list1.data<=list2.data){
                if(list==null)//先判断开始的时候链表是否为空,为空的时候直接赋值
                    current=list=list1;
                else{
                    current.nextNode=list1;
                    current=current.nextNode;//当前节点往后移动
                }
                list1=list1.nextNode;//比较的节点往后移动
            }
            else{
                if(list==null)
                    current=list=list2;
                else{
                    current.nextNode=list2;
                    current=current.nextNode;
                }
                list2=list2.nextNode;
            }
        }
        if(list1==null){//最后在比较完成之后判断链表是否到达结尾,将较长的链表的后面部分直接插入到list中
            current.nextNode=list2;
        }
        if(list2==null){
            current.nextNode=list1;
        }
        return list;
    }
时间: 2024-12-31 23:12:21

链表合成的相关文章

两个有序链表合成一个有序链表

RT.... 无聊帮朋友撸个 C++ 作业.. = = 1 /* 2 无聊帮朋友撸个作业...... \ = v = / 3 4 两个有序链表合成为一个有序链表. 5 要求: 6 1. 每个链表元素里的值不超过int范围. 7 2. 两个链表要求为升序(从小到大). 8 9 10 2016.1.5 author : 加德满都的猫会爬树 11 12 */ 13 14 #include <iostream> 15 using namespace std; 16 const int MAX = 10

线性时间将两个有序链表合成一个有序链表(constant additional space)

description: given two sorted singly list, merge them into one using constant additional space algorithm: we will reference the two linked list as list1 and list2 for convenience, since list1 is sorted,just find the right position for each element in

27、输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 思路:同归并算法 本题: 1 public class Solution { 2 public ListNode Merge(ListNode list1, ListNode list2) { 3 ListNode head; 4 if (list1 == null) { 5 return list2; 6 } 7 if (list2 == null) { 8 return list1; 9 } 10

将两个无序链表合成一个链表

对于链表,可以先将两个链表排序,然后再将其枚举合成一个链表. 或者是先将一个链表接到另一个链表的尾部,然后将总链表排序. 1 #include <bits/stdc++.h> 2 #include <iostream> 3 #include <cstring> 4 #include <cstdio> 5 #include <malloc.h> 6 using namespace std; 7 struct Node{ 8 int date; 9

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。

新增一个链表,然后分别采用2个指针指向这两个链表,每次比较链表的值,将较小的那一个存入新链表中.需要主要的是对空链表进行处理,主要还是考察代码的鲁棒性.总共2个链表,数组分别是1,3,5,7,和2, 4, 6,8 采用java进行实现. package com.test.algorithm; class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } public class Me

合并链表

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. class ListNode { int val; ListNode next = null; ListNode(int val) { this.val = val; } } public class Solution { public ListNode Merge(ListNode list1,ListNode list2) { ListNode MergeNode=null; ListNode no

剑指offer-合并两个排序的链表

题目描述 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. public class Test { class ListNode { int value; ListNode next; public ListNode(int value) { this.value = value; } } /** * node1: 1->3->5->7; * node2: 2->4->6->8->9->10->11; * @

面试题17 合并两个排序的链表

题目描述 输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则. 1 /* 2 struct ListNode { 3 int val; 4 struct ListNode *next; 5 ListNode(int x) : 6 val(x), next(NULL) { 7 } 8 };*/ 9 class Solution { 10 public: 11 ListNode* Merge(ListNode* pHead1, ListNode* pHead2

合并两个排序的链表

输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则 /* struct ListNode { int val; struct ListNode *next; ListNode(int x) : val(x), next(NULL) { } };*/ class Solution { public: ListNode* Merge(ListNode* pHead1, ListNode* pHead2) { if(pHead1==NULL) return pH