精华内容
下载资源
问答
  • leetcode21

    2017-01-13 18:40:50
    1、Merge Two Sorted Lists

    1、Merge Two Sorted Lists
    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.

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
            ListNode dummy(INT_MIN);
            ListNode* temp=&dummy;
            while(l1&&l2){
                if(l1->val<l2->val){
                    temp->next=l1;
                    l1=l1->next;
                }
                else{
                    temp->next=l2;
                    l2=l2->next;
                }
                temp=temp->next;
            }
            temp->next = l1 ? l1 : l2;
            return dummy.next;
        }
    };

    既然是sorted list,则不用担心每个list的顺序了,只需要不停的比较两个list对应的val的大小。最初设一个无穷小的节点,选择与第一个元素较小的list相连,分别指向他们的next,temp指向的节点继续担任最小节点的角色,选择下一对中较小的节点,直到有一方为空,则选择剩余一个节点作为temp的next.

    展开全文
  • Leetcode 21

    2018-01-30 22:29:49
    题目要求: 查找needle在haystack中第一次出现的位置。 例1: Input : haystack = "Hello", needle = "ll" Output: 2 ...Input: haystack = "aaaaa", needle = "bba" ...首先指定haystack 和needle的指针k,j(k 的取值...

    题目要求:

    查找needle在haystack中第一次出现的位置。

    例1:

    Input : haystack = "Hello", needle = "ll"

    Output: 2

    例2:

    Input: haystack = "aaaaa", needle = "bba"

    Output: -1

    主要思想:

    首先指定haystack 和needle的指针k,j(k 的取值要小于len(haystack)-len(needle),若i大于这个值,k之后的长度就会小于len(needle)就没有比较的必要了 ),(j的取值小于len(needle))。

    另外由于题目要求返回第一次匹配needle的位置的首个索引值,所以另外定义一个i来存储这个索引值,k用于循环。

    1. i = 0

    2. k = i, j = 0

    3.如果j 小于needle的长度,并且haystack[k] == needle[j],表示当前值匹配成功,进入4,否则进入5

    4.j++, i++

    5.若 j = len(needle)表示匹配成功,返回i, 否则i++,并且返回2

    主要代码如下:

    class Solution(object):
        def strStr(self, haystack, needle):
            len1 = len(haystack)
            len2 = len(needle)
            if len(haystack) == 0 or len(needle) == 0:
                return 0
            if len1 < len2:
                return -1
            i = 0
            while i < (len1 - len2 + 1):
                j = 0
                k = i
                while j < len2 and haystack[k] == needle[j]:
                    j += 1
                    k += 1
                if j == len2:
                    return i
                i += 1
            else:
                return -1



    展开全文
  • LeetCode 21

    千次阅读 2016-04-22 09:14:29
    已经已连续做了好几道题了,感觉停不下来了,突然来了兴趣了,这个题让我觉得思路很清晰,合并两个排序的链表。我的思路如下:分别从两个链表里面摘取节点放到新的链表中,最后摘到一个也不留就行了。...

    已经已连续做了好几道题了,感觉停不下来了,突然来了兴趣了,这个题让我觉得思路很清晰,合并两个排序的链表。我的思路如下:分别从两个链表里面摘取节点放到新的链表中,最后摘到一个也不留就行了。不过需要注意的是一些小细节,主要的注意事项如下:

    1.两空(两个空的链表)

    2.一空(一个链表为空一个部位空)

    3.一个摘完了,另外的可能还有节点(这个需要好好注意一下,很容易出错的)

    好了,见代码吧:

    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) 
        {
            //类似于从两个链表上取下节点,放到newHead中去
            if(l1 == NULL && l2 == NULL)
            {
                return NULL;
            }
            if(l1 == NULL)
            {
                return l2;
            }
            if(l2 == NULL)
            {
                return l1;
            }
            
            ListNode * newHead=NULL;
            if(l1->val <= l2->val)
            {
                newHead=l1;
                l1=l1->next;
            }
            else
            {
                 newHead=l2;
                 l2=l2->next;
            }
            newHead->next = NULL;
            ListNode *cur = newHead;
            while(l1 && l2)
            {
                if(l1->val <= l2->val)
                {
                    cur->next = l1;
                    l1=l1->next;
                }
                else
                {
                    cur->next = l2;
                    l2 = l2->next;
                }
                cur=cur->next;
                cur->next=NULL;
            }
            
            if(l1)
            {//说明 l2 完了,只剩 l1 了
                cur->next = l1;    
            }
            if(l2)
            {//说明 l1 完了,只剩 l2 了
                cur->next=l2;
            }
            
            return newHead;
        }
    };
    结果如下:



    展开全文
  • leetcode21用C语言和C++两种解法

    千次阅读 2018-10-11 13:19:06
    /** * Definition for singly-linked list. * struct ListNode { * int val; * struct ListNode *next; * };...struct ListNode* ...https://leetcode-cn.com/problems/merge-two-sorted-lists/description/
    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     struct ListNode *next;
     * };
     */
    struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
         struct ListNode* temp;
         struct ListNode* l3;
        if(l1==NULL&&l2==NULL)
            return NULL;
        if(l1==NULL&&l2!=NULL) return  l2;
        if(l1!=NULL&&l2==NULL) return l1;
       l3=l1->val<=l2->val? l1:l2;
           temp=l3;
        if(l1->val<=l2->val) l1=l1->next;
        else l2=l2->next;
        while(l1&&l2)
        {
            if(l1->val<=l2->val)
            {l3->next=l1;l3=l1;l1=l1->next;}
            else {l3->next=l2;l3=l2;l2=l2->next;}
           
        }
        
         l3->next=l1?l1:l2;
        
        return temp;
        
    }
    /**
     * Definition for singly-linked list.
     * struct ListNode {
     *     int val;
     *     ListNode *next;
     *     ListNode(int x) : val(x), next(NULL) {}
     * };
     */
    class Solution {
    public:
        ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    
              // ListNode l3(0);  //设置临时头节点temp_head
            ListNode *ptr =  new ListNode (0); //使用pre指针指向temp_head
            ListNode* temp=ptr;
            while(l1&&l2){
                if(l1->val<=l2->val)  
                {
                    ptr->next=l1;ptr=l1;l1=l1->next;
                }
                else {ptr->next=l2;ptr=l2;l2=l2->next;}
            }
            ptr->next=l1? l1:l2;
            return  temp->next;
            
            
            
            
        }
    };

    题目链接https://leetcode-cn.com/problems/merge-two-sorted-lists/description/

    展开全文
  • LeetCode21-源码

    2021-02-11 14:32:25
    LeetCode21
  • 目录LeetCode 21:合并两个有序链表题目描述解题迭代递归 LeetCode 21:合并两个有序链表 题目描述 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 【示例】 输入...
  • class Solution: def mergeTwoLists(self, l1, l2): """ :type l1: ListNode :type l2: ListNode :rtype: ListNode """ if l1==None: return l2 ...
  • 剑指Offer面试题17 & Leetcode21 Merge Two Sorted Lists  合并两个排序的链表
  • 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。  示例: 输入:1-&gt;2-&gt;4, 1-&gt;3-&gt;4 输出:1-&... * struct ListNod...
  • leetcode 21天动态规划入门——从0到0.5【Day01】 写在前面 对于动态规划这一个板块,其实博主一直都是在学习,刷题的阶段,一旦度过刷题过后的半个月后再重新拾起时,总会发现动态规划的题是比较难理解与记住的...
  • Leetcode 21. 合并两个有序链表

    千次阅读 2020-05-31 20:17:16
    Leetcode 21. 合并两个有序链表1、问题分析2、问题解决3、总结 1、问题分析 题目链接:https://leetcode-cn.com/problems/merge-two-sorted-lists/   本质上就是一个链表操作问题。代码我已经进行了详细的注释,...
  • 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1-&gt;2-&gt;4, 1-&... public ListNode mergeTwoLists(ListNode l1, Lis...
  • Leetcode 21 Python

    2018-02-09 21:52:59
    思路:分治法,然后使用之前实现的合并两条有序链表的方法。 # Definition for singly-linked list. # class ListNode(object): # def __init__(self, x): # self.val = x # self.next = None ...
  • 题目 将两个有序链表合并为一个新的有序链表并返回。...题目来源力扣(LeetCode) 思路 建一新链表;比较两源链表值的大小,将较小者链至新链表中;若两源链表长度不一,则在某一源链表插入结束后,将另一源链表剩余...
  • leetcode 21天动态规划入门——从0到0.5【Day04】小兔子的跳跃游戏 写在前面 到了动态规划的第四天啦~今天可是不寻常的一天,因为今天的题的动态转化方程虽然很简单就能推导出来,但是今天的两个动态转化方程都可以...
  • 题目:将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成...来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/merge-two-sorted-lists 著作权归领扣网络所
  • 今天把最近发布的21-40篇LeetCode文章整理一下,平时文章都放在比较末尾,阅读量都不高,相信很多人都没看过,如果对于算法感兴趣的,建议可以每篇认真阅读一下!LeetCode1-2...
  • 21. 合并两个有序链表...
  • LeetCode 21:Merge Two Sorted Lists

    千次阅读 2015-05-27 23:08:48
    LeetCode 21: Merge Two Sorted Lists   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. 题目分析:对两...
  • 链表 合并两个有序链表 1. 题目描述 ...来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/merge-two-sorted-lists 2. 思路分析 遍历两个链表,每次取到两个结点的值进行比较 创建新
  • 将两个升序链表合并为一个新的升序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。...来源:力扣(LeetCode) 链接:https://leetcode-cn.com/problems/merge-two-sorted-lists 著作权归领扣网...
  • LeetCode 21. 合并两个有序链表(Golang)

    千次阅读 2018-10-11 22:57:09
    将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 示例: 输入:1-&amp;gt;2-&amp;gt;4, 1-&amp;gt;3-&amp;... * type ListNode
  • LeetCode 21 Merge Two Sorted Lists Problem Description: 合并两个有序链表 具体的题目信息: https://leetcode.com/problems/merge-two-sorted-lists/description/ Solution: 解题思路 我们把l1作为结果...
  • leetcode 21. 合并两个有序链表 (python)

    千次阅读 2018-05-31 00:10:52
    将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 例:输入:1-&gt;2-&gt;4, 1-&gt;3-&gt;...本题同样可以很单线条解决,代码如下将两个有序链表合并...
  • LeetCode21—— 相同的树 前言: 题目内容: 给你两棵二叉树的根节点 p 和 q ,编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同,并且节点具有相同的值,则认为它们是相同的。 示例 1: 输入:p = ...
  • Leetcode 21(Java)

    千次阅读 2017-06-07 11:07:04
    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.题目很简单有很简短,实际上对于链表的题目很容易想到递归的...
  • 腾讯精选练习(50 题)Day12 leetcode 21:合并两个有序链表(python)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 48,801
精华内容 19,520
关键字:

leetcode21