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

新增一个链表,然后分别采用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 Merge {

    public static ListNode Merge(ListNode list1,ListNode list2) {

        if(list1 == null && list2 == null)
            return null;
        if(list1 == null)
            return list2;
        if(list2 == null)
            return list1;

        ListNode newNode = new ListNode(0);
        ListNode tmp = new ListNode(0);
        tmp = newNode;
        if(list1.val < list2.val){
            newNode.val = list1.val;
            list1 = list1.next;
        }
        else{
            newNode.val = list2.val;
            list2 = list2.next;
        }
        //newNode.next = null;
        while(list1!=null && list2!=null){
            if(list1.val < list2.val){
                newNode.next = list1;
                newNode = newNode.next;
                newNode.val = list1.val;
                list1 = list1.next;
            }else{
                newNode.next = list2;
                newNode = newNode.next;
                newNode.val = list2.val;
                list2 = list2.next;
            }
        }
        if(list1!=null){
            newNode.next = list1;
            newNode = newNode.next;
            //list1 = list1.next;
        }
        if(list2!=null){
            newNode.next = list2;
            newNode = newNode.next;
            //list2 = list2.next;
        }

        return tmp;
    }

    public static void main(String[] args) {

        ListNode list1 = new ListNode(1);
        ListNode list2 = new ListNode(2);
        list1.next = null;
        list2.next = null;
        ListNode head1 = list1;
        ListNode head2 = list2;

        for(int i = 2 ; i <=8 ; i ++){
            if(i%2!=0)
            {
                ListNode temp = new ListNode(i);
                temp.next = list1.next;
                list1.next = temp;
                list1 = temp;
            }
        }
        for(int i = 4 ; i <=8 ; i ++){
            if(i%2==0)
            {
                ListNode temp = new ListNode(i);
                temp.next = list2.next;
                list2.next = temp;
                list2 = temp;
            }
        }

        ListNode newNode = Merge(head1,head2);
        for(int i = 1 ; i <= 8 ; i++){
            System.err.println(newNode.val);
            newNode = newNode.next;
        }
    }
}
时间: 2024-08-09 16:31:27

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

简单输入输出交互。 用户输入两个数字,计算并输出两个数字之和:(尝试只用一行代码实现这个功能) 输入半径,计算圆的面积。简单输入输出交互。 用户输入两个数字,计算并输出两个数字之和:(尝试只用一行代码实现这个功能) 输入半径,计算圆的面积。

# 输入姓名 name=input('请输入姓名:') #输入年龄 age=input('请输入年龄:') # 输出姓名和年龄 print('hi,%s,you are %s years ole'%(name,age)) # 输入文字 n=input('请输入第一个数:') m=input('请输入第二个数:') # 计算 sum=float(n)+float(m) # 输出结果 print('两数之和为:%.2f'%sum) # 输入数值 r=input('输入圆的半径:') π=3.14 #

二分求最长单调递增子序列并输出最长的序列(模板)

1 #include<iostream> 2 #include<cstring> 3 #include<cstdio> 4 #include<algorithm> 5 #define N 100005 6 using namespace std; 7 int num[N]; 8 int a[N]; 9 int pre[N]; 10 int pos[N]; 11 12 void print(int x){ 13 if(x==0) return; 14 prin

单调递增子序列

单调子序列包含有单调递增子序列和递减子序列,不失一般性,这里只讨论单调递增子序列.首先,从定义上明确我们的问题.给定序列a1, a2, …, an,如果存在满足下列条件的子序列 ai1<=ai2<=…<=aim, (其中i1<i2<…<im) 即称为一个原序列的长度为m的单调递增子序列,那么,现在的问题是我们要找出一个序列的最长的单调递增子序列. 直观上来说,一个序列Sn,它有2n个子序列,枚举所有的子序列,找出其中单调递增的序列,然后返回其中最长的,这样我们的问题就解

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

Python练习题8(替换相同的字符串并输出):输入两个字母串,将两个字母串都包含的字母用&#39;_&#39;替换后,输出两个字母串的剩余部分 (不能为空串,区别大小写,只能包含字母)

方法一:检查输入是否为空串,循环字母串,相同的则替换,然后再用replace()方法去除,输出想要的结果 1 def str_replace(messages1,messages2): 2 if messages1.strip() == '' or messages2.strip() == '' : #检验输入不能为空串 3 tips = "输入字母串有空串,不合法" 4 return tips 5 6 if not messages1.encode('UTF-8').strip().

nyoj 题目17 单调递增最长子序列

单调递增最长子序列 时间限制:3000 ms  |  内存限制:65535 KB 难度:4 描述 求一个字符串的最长递增子序列的长度如:dabdbf最长递增子序列就是abdf,长度为4 输入 第一行一个整数0<n<20,表示有n个字符串要处理随后的n行,每行有一个字符串,该字符串的长度不会超过10000 输出 输出字符串的最长递增子序列的长度 样例输入 3 aaa ababc abklmncdefg 样例输出 1 3 7 复习了利用二分搜索和额外空间解决最长递增子序列问题,最重要的是二分搜索的

最长单调递增子序列 POJ 3903 Stock Exchange .

题目传送门 : -------->点这里点这里<---------- 题目大意: 给出一串正整数,个数为N个.1<=N<=100000.求最长单调递增子序列长度. 样例输入: 6 5 2 1 4 5 3 3 1 1 1 4 4 3 2 1 样例输出: 3 1 1 =================================================================== 最长单调递增子序列问题的DP朴素算法复杂度为 O(n^2); 然而题目中的 N 最大有

nyist oj 214 单调递增子序列(二) (动态规划经典)

单调递增子序列(二) 时间限制:1000 ms  |  内存限制:65535 KB 难度:4 描述 给定一整型数列{a1,a2...,an}(0<n<=100000),找出单调递增最长子序列,并求出其长度. 如:1 9 10 5 11 2 13的最长单调递增子序列是1 9 10 11 13,长度为5. 输入 有多组测试数据(<=7) 每组测试数据的第一行是一个整数n表示序列中共有n个整数,随后的下一行里有n个整数,表示数列中的所有元素.每个整形数中间用空格间隔开(0<n<=1

南阳17(单调递增最长子序列)

单调递增最长子序列 时间限制:3000 ms  |  内存限制:65535 KB 难度:4 描述 求一个字符串的最长递增子序列的长度如:dabdbf最长递增子序列就是abdf,长度为4 输入 第一行一个整数0<n<20,表示有n个字符串要处理随后的n行,每行有一个字符串,该字符串的长度不会超过10000 输出 输出字符串的最长递增子序列的长度 样例输入 3 aaa ababc abklmncdefg 样例输出 1 3 7 1 #include<stdio.h> 2 #include

单调递增最长子序列(南阳oj17)(经典dp)

单调递增最长子序列 时间限制:3000 ms  |  内存限制:65535 KB 难度:4 描述 求一个字符串的最长递增子序列的长度 如:dabdbf最长递增子序列就是abdf,长度为4 输入 第一行一个整数0<n<20,表示有n个字符串要处理 随后的n行,每行有一个字符串,该字符串的长度不会超过10000 输出 输出字符串的最长递增子序列的长度 样例输入 3 aaa ababc abklmncdefg 样例输出 1 3 7 来源 经典题目 上传者 iphxer #include<std