leetcode21

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

Subscribe to see which companies asked this question

简单题

没有什么技术含量。

简单循环,codetime上面可能慢一点。

递归的代码量小很多,也很简洁。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode headNode = new ListNode(0);
        ListNode result = new ListNode(0);
        headNode.next = result;
        ListNode nextNode = new ListNode(0);
        while(l1 != null || l2 != null)
        {
            nextNode = new ListNode(0);
            if(l1 == null){
                nextNode.val = l2.val;
                l2 = l2.next;
            }else if(l2 == null){
                nextNode.val = l1.val;
                l1 = l1.next;
            }else if(l1.val>l2.val){
                nextNode.val = l2.val;
                l2 = l2.next;
            }else{
                nextNode.val = l1.val;
                l1 = l1.next;
            }

            result.next = nextNode;
            result = result.next;
        }
        return headNode.next.next;
    }
}
public ListNode mergeTwoLists(ListNode l1, ListNode l2){
        if(l1 == null) return l2;
        if(l2 == null) return l1;
        if(l1.val < l2.val){
            l1.next = mergeTwoLists(l1.next, l2);
            return l1;
        } else{
            l2.next = mergeTwoLists(l1, l2.next);
            return l2;
        }
}
时间: 2024-11-08 21:21:49

leetcode21的相关文章

LeetCode21.MergeTwoSortedLists

Python3__方法(一本正经瞎忽悠系列) python将文本内容转为字典 hashCode().equals()以及compareTo()方法的理解 C\C++编译器的未来.我们还需要C++么? 撬惺载逗永悦糜巢美烈http://p.baidu.com/pai/center?uid=fa59616263336638306364bb99&type=myQuestions 乱研恃宋谪蚀牧毒谎加http://weibo.com/p/1005056396318337 在逊蜒蹈滞先嚷男盏肝http:/

LeetCode21—合并两个有序链表

方法一:这是我一开始的想法,将链表L2的各个元素与链表L1的元素进行逐一比较,将L2中的数据元素插入L1中的合适位置. 时间复杂度:O(m+n):空间复杂度:O(1) 1)首先,可能要对第一个元素进行插入操作,所以为了统一插入操作,需要创建哨兵: 2)循环终止条件是L2遍历完即nullptr == pWorkNodeL2,但是在循环过程中,L1可能先遍历完,所以要对L1分情况讨论: 3)跳出循环后,要对检测L1是否遍历完. 这是自然而然的想法,但是经验告诉我们类似这种直觉的想法往往可能不是最好的

leetcode21 Merge Two Sorted Lists

1 """ 2 Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. 3 Example: 4 Input: 1->2->4, 1->3->4 5 Output: 1->1->2->3->4->4

LeetCode-21 Merge Two Sorted Lists Solution (with Java)

1. Description: 2. Examples: 3.Solutions: 1 /** 2 * Created by sheepcore on 2019-05-07 3 * Definition for singly-linked list. 4 * public class ListNode { 5 * int val; 6 * ListNode next; 7 * ListNode(int x) { val = x; } 8 * } 9 */ 10 class Solution {

Leetcode23---&gt;Merge K sorted Lists(合并k个排序的单链表)

题目: 合并k个排序将k个已排序的链表合并为一个排好序的链表,并分析其时间复杂度 . 解题思路: 类似于归并排序的思想,lists中存放的是多个单链表,将lists的头和尾两个链表合并,放在头,头向后移动,尾向前移动,继续合并,直到头和尾相等,此时已经归并了一半, 然后以同样的方法又重新开始归并剩下的一半.时间复杂度是O(logn),合并两个链表的时间复杂度是O(n),则总的时间复杂度大概是O(nlogn):合并两个单链表算法可以参考Leetcode21中的解法:http://www.cnblo

LeetCode 23: Merge K Sorted Lists

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity. 本题在上一题(LeetCode 21: Merge Two Sorted Lists)基础上再加深了一步,链表个数从两个改为K个. 此题有如下几种解法: 1.最简单的方法莫过于每次都从K个链表头中找到最小的那个元素,加入结果链表中.基于此,有人通过最小堆来简化最小元素的比较. struct Compa

LeetCode链表解题模板

一.通用方法以及题目分类 0.遍历链表 方法代码如下,head可以为空: ListNode* p = head; while(p!=NULL) p = p->next; 可以在这个代码上进行修改,比如要计算链表的长度: ListNode* p = head; int num = 0; while(p!=NULL){ num++; p = p->next; } 如果要找到最后的节点,可以更改while循环中的条件,只不过需要加上head为NULL时的判断 if(!head) return hea

链表常见操作

1.迭代. 链表最常见的操作就是迭代. while (head.next != null) { head = head.next; } 2.链表转化为数组 涉及到下标的问题,都可以将链表转化为数组解决,数组的每一个元素都是一个节点.. 示例题目,返回链表的中间节点 public ListNode middleNode(ListNode head) { ListNode[] A = new ListNode[100]; int t = 0; while (head.next != null) {

LeetCode 21. 合并两个有序链表(Merge Two Sorted Lists)

21. 合并两个有序链表 21. Merge Two Sorted Lists 题目描述 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. LeetCode21. Merge Two Sorted Lists 示例: 输入: 1->2->4, 1->3->4 输出: 1->1->2->3->4->4 Java 实现 ListNode 类 class ListNode { int val; ListNode n