精华内容
下载资源
问答
  • 我刷LeetCode的顺序先刷简单题,再刷中等题,并且按类型刷。有同学说按类型刷,相当于...21.合并两个有序链表将两个有序链表合并为一个新的有序链表并返回。新链表通过拼接给定的两个链表的所有节点组成的。 ...

    我刷LeetCode的顺序是先刷简单题,再刷中等题,并且按类型刷。有同学说按类型刷,相当于提示答案了,这就要看是以学习的方式刷题还是以测试的方式刷题。我把刷题的过程记录下来,以便二刷三刷的时候参考,同时分享给大家。

    这一节介绍leetcode的简单题中的链表,共8题,这些题都是高频题。

    21.合并两个有序链表

    将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

    示例:

    输入:1->2->4, 1->3->4
    输出:1->1->2->3->4->4

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def mergeTwoLists(self, l1, l2):
            """
            :type l1: ListNode
            :type l2: ListNode
            :rtype: ListNode
            """
            cur = head =ListNode(0)
            while l1 and l2:
                if l1.val <= l2.val:
                    cur.next = l1
                    l1 = l1.next
                else:
                    cur.next = l2
                    l2 = l2.next
                cur = cur.next
            cur.next = l1 or l2
            return head.next

    83.删除排序链表中的重复元素

    给定一个排序链表,删除所有重复的元素,使得每个元素只出现一次。

    示例 1:

    输入: 1->1->2
    输出: 1->2
    

    示例 2:

    输入: 1->1->2->3->3
    输出: 1->2->3

    分析

    两个循环:

    外循环cur移动,外循环移动到尾节点停止;

    内循环runner移动,runner移动到和当前cur不相等的前一个停止,直接将cur.next=runner,相当于删除中间元素的操作。

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def deleteDuplicates(self, head):
            """
            :type head: ListNode
            :rtype: ListNode
            """
            cur = head
            while cur:
                runner = cur.next
                while runner and cur.val == runner.val:
                    runner = runner.next
                cur.next = runner
                cur = cur.next
            return head

    141.环形链表

    给定一个链表,判断链表中是否有环。

    为了表示给定链表中的环,我们使用整数 pos 来表示链表尾连接到链表中的位置(索引从 0 开始)。 如果 pos-1,则在该链表中没有环。

    示例 1:

    输入:head = [3,2,0,-4], pos = 1
    输出:true
    解释:链表中有一个环,其尾部连接到第二个节点。
    

    1258952e289467659674d7e1047abc50.png

    分析

    题目有点误导,输入只有head,没有pos,如果给了pos,那就不用判断了。

    设置两个指针,快指针和慢指针,快指针每次走两步,慢指针每次走一步,如果快慢指针相等了(或者是快指针套了圈追上慢指针),说明有环。

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def hasCycle(self, head):
            """
            :type head: ListNode
            :rtype: bool
            """
            fast,slow = head,head
            while fast and fast.next:
                fast,slow = fast.next.next,slow.next
                if fast==slow:
                    return True
            return False    

    160.相交链表

    编写一个程序,找到两个单链表相交的起始节点。

    如下面的两个链表

    8ea028f5cda3c00a56a538193501f62f.png

    在节点 c1 开始相交。

    注意:

    • 如果两个链表没有交点,返回 null.
    • 在返回结果后,两个链表仍须保持原有的结构。
    • 可假定整个链表结构中没有循环。
    • 程序尽量满足 O(n) 时间复杂度,且仅用 O(1) 内存。

    分析

    设置两个指针,一个从headA开始遍历,遍历完headA再遍历headB,另一个从headB开始遍历,遍历完headB再遍历headA,如果有交点,两个指针会同时遍历到交点处。

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def getIntersectionNode(self, headA, headB):
            """
            :type head1, head1: ListNode
            :rtype: ListNode
            """
            p1 = headA
            p2 = headB
            while p1 != p2:
                if p1 == None:
                    p1 = headB
                else:
                    p1 = p1.next
                if p2 == None:
                    p2 = headA
                else:
                    p2 = p2.next
            return p2  

    203.移除链表元素

    删除链表中等于给定值 val 的所有节点。

    示例:

    输入: 1->2->6->3->4->5->6, val = 6
    输出: 1->2->3->4->5

    分析

    设置一个虚拟的头结点,让它指向头结点,否则会丢失头结点元素和val值的比较。

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def removeElements(self, head, val):
            """
            :type head: ListNode
            :type val: int
            :rtype: ListNode
            """
            dummy = ListNode(-1)
            dummy.next = head
            pre ,cur = dummy, dummy.next
            while cur:
                if cur.val == val:
                    pre.next = cur.next
                else:
                    pre = pre.next
                cur = cur.next
            return dummy.next

    206.反转链表

    反转一个单链表。

    示例:

    输入: 1->2->3->4->5->NULL
    输出: 5->4->3->2->1->NULL

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def reverseList(self, head):
            """
            :type head: ListNode
            :rtype: ListNode
            """
            if not head:
                return None
            p = head
            q = head.next
            while q:
                head.next = q.next
                q.next = p
                p = q
                q = head.next
            return p

    234.回文链表

    请判断一个链表是否为回文链表。

    示例 :

    输入: 1->2->2->1
    输出: true
    

    进阶:
    你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题?

    分析

    借助两个指针,一个快指针,一个慢指针,快指针每次走两步,慢指针每次走一步,快指针走到终点的时候,慢指针走到一半,把这一半推进栈中,然后拿后面的一半和栈中的元素挨个对比。

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def isPalindrome(self, head):
            """
            :type head: ListNode
            :rtype: bool
            """
            fast = slow =ListNode(0)
            fast = slow = head
            stack = []
            
            while fast and fast.next:
                stack.append(slow.val)
                slow = slow.next
                fast = fast.next.next
                
            if fast:
                slow = slow.next
            
            while slow:
                top = stack.pop()
                
                if top != slow.val:
                    return False
                slow = slow.next
            return True

    237.删除链表中的节点

    请编写一个函数,使其可以删除某个链表中给定的(非末尾)节点,你将只被给定要求被删除的节点。

    现有一个链表 -- head = [4,5,1,9],它可以表示为:

    a3816df33502620c2ee41517ee3fd9e8.png

    示例 :

    输入: head = [4,5,1,9], node = 5
    输出: [4,1,9]
    解释: 给定你链表中值为 5 的第二个节点,那么在调用了你的函数之后,该链表应变为 4 -> 1 -> 9.

    说明:

    • 链表至少包含两个节点。
    • 链表中所有节点的值都是唯一的。
    • 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
    • 不要从你的函数中返回任何结果。

    分析

    这个题的意思是没有给定链表,只给一个节点,调用这个函数,可以删除指定的节点。

    代码

    # Definition for singly-linked list.
    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution(object):
        def deleteNode(self, node):
            """
            :type node: ListNode
            :rtype: void Do not return anything, modify node in-place instead.
            """
           
            node.val = node.next.val
            node.next = node.next.next
    展开全文
  • ————— 第二天 —————————————————人们如何进行扑克牌的排序呢?...最自然也最简单的方式,在已经有序的四张牌中找到红桃8应该插入的位置,也就是7和9之间,把红桃8插入进去:给定无...
    748f976ef72ad97caa7ba01ed0342310.gif0c0629582857cb1e4415acfc77cca5ce.pngba085ec7980d093737aa09aa48f817f5.png

    ————— 第二天 —————

    67efe1cd967f276e20d063a41daca6b4.pngad1cd4bcae4a91dc581919ec64f067c4.png57480559e30fd125c7a2bf79380a5130.png995a6876bfe314371d4c879333465bc9.png3a15230bc87e25445f2a6233b4aefb7b.png36c033158e90639917be86cdc5e844c2.pngea5de58e9fa25c4efd1bd71150d52c53.png

    ————————————

    a6c7ee9c9e9f420c9814547df585af41.png35c815b4d07d0daa60ee05e328ea0258.pngebf7e633237347bad0804ce07ba15477.png8af339274432426774b1baccbedf8051.pngc8b22b019d0866c89f0c16121b9e9b3e.png26c3b4479f83def262a241f5b804705d.png

    人们如何进行扑克牌的排序呢?

    举个例子,比如我手中有红桃6,7,9,10这四张牌,已经处于升序排列:

    513878ab5584457d134042d2758231b6.png

    这时候,我又抓到了一张红桃8,如何让手中的五张牌重新变成升序呢?用冒泡排序,选择排序,亦或是快速排序?

    ce11a823a1eb9a14127e92b1503953df.png

    恐怕正常人打牌的时候都不会那么做。最自然也最简单的方式,是在已经有序的四张牌中找到红桃8应该插入的位置,也就是7和9之间,把红桃8插入进去:

    499cd76ae39f35c277411de06b02b7f8.pnga74a2337631e17d68b96628bb728e72e.png023933ef0a756bef6bf283d877be3004.png11a3cee3e6f31e5bf230c52377a160c2.png

    给定无序数组如下:

    162d67d813208950f6fb27fa32a34ce6.png

    把数组的首元素5作为有序区,此时有序区只有这一个元素:

    8f609868dbeb391241f6bdcf19c410a0.png

    第一轮

    让元素8和有序区的元素依次比较。

    8>5,所以元素8和元素5无需交换。

    此时有序区的元素增加到两个:

    4bbf06cf342041a31c4439b11767f126.png

    第二轮

    让元素6和有序区的元素依次比较。

    6<8,所以把元素6和元素8进行交换:

    6d76ae5e33afd83634f35116114d961b.png

    6>5,所以把元素6和元素5无需交换。

    此时有序区的元素增加到三个:

    c529a4677be6e90ccc3d73b8fd990b67.png

    第三轮

    让元素3和有序区的元素依次比较。

    3<8,所以把元素3和元素8进行交换:

    6400b220b2d0f52a0142be92c3327efc.png

    3<6,所以把元素3和元素6进行交换:

    bcebf5ba2fe3a474d2e5c1a5968de046.png

    3<5,所以把元素3和元素5进行交换:

    5db763c688aea36dc0d4aea8d5d8ed1c.png

    此时有序区的元素增加到四个:

    608c98cdfe973a7308ca5a6f05b785eb.png

    以此类推,插入排序一共会进行(数组长度-1)轮,每一轮的结果如下:

    c0a5aa44a1a504d44c740d8dec1c9f94.pnge7effed2fba4f946d74f5e8e93a2b31c.png6ec4d93c36e122e183c189e7d75071df.png742d058153ecbb39ce667983eb93bc0b.pngf45bd07a046b259b4deaeadcfce2567c.png

    什么意思呢?让我们以第三轮举例:

    在第三轮操作中,我们需要让元素3逐个与有序区的元素进行比较和交换,与8交换、与6交换、与5交换,最终交换到有序区的第一个位置。

    但是我们并不需要真的进行完整交换,只需把元素3暂存起来,再把有序区的元素从左向右逐一复制。

    第一步,暂存元素3:

    031ad3dc488e20807a0791af257bb69f.png

    第二步,和前一个元素比较,由于3<8,复制元素8到它下一个位置:

    ed7521b8342d0a482ef371d412383971.png

    第三步,和前一个元素比较,由于3<6,复制元素6到它下一个位置:

    a30cd83128cb4899647c632885dfff23.png

    第四步,和前一个元素比较,由于3<5,复制元素5到它下一个位置:

    3846d5496331b6f1a95a92612158a0cb.png

    第五步,也是最后一步,把暂存的元素3赋值到数组的首位:

    9de046b7f159009b7855752cd7dffb52.png

    显然,这样的优化方法减少了许多无谓的交换。

    67f5f126aee66e5285f405aca0cf687c.png455a40d486ffb4fb66ae77887515d129.png

    public static void sort(int[] array){

    for(int i=1;i

    int insertValue =array[i];

    int j=i-1;

    //从右向左比较元素的同时,进行元素复制

    for(; j>=0&&insertValue

    array[j+1]=array[j];

    }

    //insertValue的值插入适当位置

    array[j+1]=insertValue;

    }

    }

    public static void main(String[] args) {

    int array={12,1,3,46,5,0,-3,12,35,16};

    sort(array);

    System.out.println(Arrays.toString(array));

    }

    0a3a44b6a4a62e052208f9de92a04df5.png0f4ecd69c38d4bcccfa2904b4529a1cc.png65580c2091ed767a28e91be13e49da35.png1fb0a2154d58a21b6f5dbaf5349981a9.png

    —————END—————

    关注文章的同时请关注一下小灰的作品《漫画算法》哦

    5755df66a762ad1cf4239b7e785c052d.png

    扫码查看详情

    小灰把两年多以来积累的漫画作品进行了筛选和优化,并加上了一些更为基础和系统的入门章节,最终完成了本书的六大篇章:

    第一章 算法概述

    介绍了算法和数据结构的相关概念,告诉大家算法是什么,数据结构又是什么,它们有哪些用途,如何分析时间复杂度,如何分析空间复杂度。

    第二章 数据结构基础

    介绍了最基本的数据结构,包括数组、链表、栈、队列、哈希表的概念和读写操作。

    第三章 树

    介绍了树和二叉树的概念、二叉树的各种遍历方式、二叉堆和优先队列的应用。

    第四章 排序算法介绍了几种典型的排序算法,包括冒泡排序、快速排序、堆排序、计数排序、桶排序。

    第五章 面试中的算法

    介绍了10余道职场上流行的算法面试题及详细的解题思路。例如怎样判断链表有环、怎样计算大整数相加等。

    第六章 算法的实际应用

    介绍了算法在职场上的一些应用,例如使用LRU算法来淘汰冷数据,使用Bitmap算法来统计用户特征等。

    本书是全彩印制,书中的每一章、每一节、每一句话、每一幅图、每一行代码,都经过了小灰和编辑们的精心打磨,力求用最为直白的方式把知识讲明白、讲透彻。

    4e96f0f653b92ca73fcc92543c942044.pngb3a86b3feafebe9c5b0ac4a477981327.png

    早期的漫画中存在一些叙述错误和表达不清晰的地方,小灰在本书中做了修正和补充;同时书中增加了许多全新的篇章,使得本书的内容更加系统和全面。

    对于渴望学习算法的小伙伴,无论你是正在学习计算机专业的学生,还是已经进入职场的新人,亦或是拥有多年工作经验却不擅长算法的老手,这本《漫画算法》都能帮助你告别对算法的恐惧,认识算法、掌握算法。

    扫码购买

    f68ad960be47dbc464c66e112272a78e.gif

    欢迎大家加入我们的码书群,在这里你可以和技术人一起聊人生,一起聊技术,一起畅谈职场生活,因为群已满100人,只能添加微信号加入了哦

    展开全文
  • 文章目录方法一:迭代**ListNode(0)这个是什么意思?****涨姿势的写法:currentNode.next = l1 or l2**方法一:迭代(简化)方法二:递归 题目: 将两个有序链表合并为一个新的有序链表并返回。 题目位置 代码位置 ...

    合并两个有序链表

    题目:
    将两个有序链表合并为一个新的有序链表并返回。

    题目位置
    代码位置

    示例:
    输入:1->2->4, 1->3->4
    输出:1->1->2->3->4->4
    

    方法一:迭代

    class Solution(object):
        def mergeTwoLists(self, l1, l2):
            """
            :type l1: ListNode
            :type l2: ListNode
            :rtype: ListNode
            """
            currentNode = tempNode = ListNode(0)
            if not l1 and not l2:
                return None
            while l1 and l2:
                if l1.val <= l2.val:
                    currentNode.next = l1
                    l1 = l1.next
                else:
                    currentNode.next = l2
                    l2 = l2.next
                currentNode = currentNode.next
                
            if l1 or l2:
                currentNode.next = l1 or l2
                
            return tempNode.next
    

    ListNode(0)这个是什么意思?

    刚开始我也懵,仔细看了下。发现这是个实例化的东西。LeetCode题目前面有个ListNode的类的定义,初始化时需要传进去一个值。

    # class ListNode(object):
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    

    我们做题目时,其实没有用到这个实例化的值,也就是说ListNode括号里面的0,也可以是100,20,3这些,我们实际不会用到,我们最后返回的是(return tempNode.next)这个节点以后的那些节点。

    方法一是没有动原来的l1和l2链表,重新搞了一个新链表放这个排序,而链表嘛,首先要有个头不是嘛,ListNode(0)就是新建了一个头,后面自己加节点,自己玩儿去~ 反正最后这个头不跟你们走~

    涨姿势的写法:currentNode.next = l1 or l2

            if l1 or l2:
                currentNode.next = l1 or l2
    

    这种写法没见过。自己先测试一下:

    >>> a = [1,2,3]
    >>> b = []
    >>> if a or b:
    ...     print(a or b)
    ...
    [1, 2, 3]
    

    发现这个是真的,记下来哦,不要再傻傻的用if…else了。

    方法一:迭代(简化)

    class Solution(object):
        def mergeTwoLists(self, l1, l2):
            """
            :type l1: ListNode
            :type l2: ListNode
            :rtype: ListNode
            """
            currentNode = tempNode = ListNode(0)
            while l1 and l2:
                if l1.val < l2.val:
                    currentNode.next = l1
                    l1 = l1.next
                else:
                    currentNode.next = l2
                    l2 = l2.next
                currentNode = currentNode.next
            currentNode.next = l1 or l2
            return tempNode.next
    

    无意中看到一个更简洁的版本,本着少写一行是一行的原则(因为懒),可以将方法一的代码简化一下。
    如果l1l2都不存在,直接return tempNode.next,而tempNode.next就是为空的。下面的代码就会出现重复,去掉吧。

         if not l1 and not l2:
                return None
    

    还有,将下面的代码

      if l1 or l2:
              currentNode.next = l1 or l2
    

    替换为:

    currentNode.next = l1 or l2
    

    是不是很简单,少写了三行代码哦~

    方法二:递归

    class Solution(object):
        def mergeTwoLists(self, l1, l2):
            """
            :type l1: ListNode
            :type l2: ListNode
            :rtype: ListNode
            """
            if not l1 or not l2:
                return l1 or l2
            while l1 and l2:
                if l1.val < l2.val:
                    l1.next = self.mergeTwoLists(l1.next,l2)
                    return l1
                else:
                    l2.next = self.mergeTwoLists(l1,l2.next)
                    return l2
    
    展开全文
  • 我一个朋友问我的问题,我觉得还有点意思 假设有 tb_user(id int(6) autoincrement not null,name varchar(20) not null) 插入数据顺序如下: 1 a, 2 b, 3 c tb_pwd(id int(6) not null, pwd varchar...
    这是我一个朋友问我的问题,我觉得还有点意思
    假设有表
    tb_user(id int(6) autoincrement not null,name varchar(20) not null)
    插入数据顺序如下:
    1 a,
    2 b,
    3 c
    tb_pwd(id int(6) not null, pwd varchar(20) not null)
    有数据:
    3 9,
    2 8,
    1 7
    分别查询两个表,结果跟插入的顺序一致
    SELECT a.*,b.pwd FROM tb_user a,tb_pwd b where a.id=b.id
    结果是:
    1 a 7,
    2 b 8,
    3 c 9,
    SELECT a.*,b.pwd FROM tb_user a,tb_pwd b where a.id=b.id
    结果是:
    3 c 9,
    2 b 8,
    1 a 7
    数据库MySQL,展现工具MySQL-font,
    初步估计:
    1、在MySQL中数据是按照表中记录的插入次序进行排序的
    2、如果是联合查询则按第一个表排序。
    验证一下,我把tb_user中的2 b记录删除,再在后面添加同样一条记录,只查询tb_user表,排序结果仍然不变,说明前面推测不对。
    再次估计:
    1、在MySQL中数据是按照表中的主键字段次序进行排序的
    再次验证,我按以下顺序在表tb_user中添加了记录6 f,5 e,之后仅查询表表tb_user,发现结果是:
    1 a,
    2 b,
    3 c,
    6 f,
    5 e
    第三次估计,
    1、在MySQL中数据是按照表中记录的插入次序进行排序的
    2、如果是联合查询则按第一个表排序。
    3、如果删除了某条记录,再将该记录添加到原来的表里,数据库用某种机制实现恢复原来记录包括查询顺序。

    写本文的目的仅仅在于研究一下MySQL数据库的记录排序问题,并强烈反对利用数据库本身的排序功能实现功能。
    如果要保证出来的结果按照一定的次序,则在设计数据库的时候就应该设计好一个字段作为排序依据
    展开全文
  • 单链表L中的结点是按值非递减有序排列的,这句话是什么意思?结点应该是有序的,但是按值非递减是什么意思
  • 'T_EPZ_INOUT_ENTRY_DETAIL'。扫描计数 1,逻辑读 4825 次,物理读 6 次,预读 19672 次。SQL SERVER 数据库引擎当遇到一个查询语句时,SQL SERVER数据库引擎会分别生成执行计划(占用CPU和内存资源),同时存储...
  • 有序的组合

    2011-11-19 18:40:00
    接到一个需求:需要支持... asa、esa,有两个可表达出这个意思,为什么?因为“阿”多音字“e”和“a”。(举的示例可能不是很恰当,只是想表达出一个意思,输入asa或是esa都能匹配出“阿是啊”)。 比如现在输入...
  • 合并K个链表且有序知识点解题思路小... lists:这代表的是什么意思? 解题思路 解法一:暴力法-对待这样的问题应该是最首先想到的:先遍历所以元素放在数组中,然后排序,进而创建新链表 class Solution { public: ...
  • 这种含有出现关键字,而且还有有序的时候,一般不会用哈希,一般无序统计出现次数才会用哈希。 直接用HashMap取搞就没有意思了,那么有序就根本没有用用到了。 中间的数要么和左边相等,要么和右边相等。看...
  • 首先从题目描述来看,不读个3、4遍可能不知道它是什么意思,同时又考察了链表和二叉树这两种结构。嗯不知道牛客难度标记是不是越小越不好做,很魔性。 正题: 先来看一棵简单的二叉搜索树 由他变成一个有序的双向...
  • 因为恰好我们可以复习下排序算法的时间复杂度),题中要求时间复杂度为O(nlogn),显然从下可以看出来归并排序和堆排可以实现的,这里我采用归并排序的方法说一下思路。 思路:我们先利用快慢指针的方法,找出...
  • 是什么意思? 顺序上的基本操作实现 时 限: 1000 ms 内存限制: 10000 K 总时限: 3000 ms 描述: 在顺序存储结构实现基本操作:初始化、创建、插入、删除、查找、遍历、逆置、合并运算。 输入: 请输入...
  • 2019-03-13 11:52:20
    矩阵表示系统信息的表格,也就是数排成一个矩形的数的形式,什么矩阵的秩呢?秩在中文中的引申义次序有序的意思。 首先要明确,秩一个数,并且一个...什么意思呢?就是对一个矩阵,存在某个r阶行列...
  • 21. Merge Two Sorted Lists

    2017-09-28 22:01:02
    Merge two sorted linked lists and return it as a new list. The new list should be made by splicing ...题目的第二句话不知道什么意思不能创建新链表?没懂。 合并有序链表比较简单,一种方法创建一个新
  • 归并排序

    2015-07-26 13:59:55
    归并(Merge)排序法将两个(或两个以上)有序表合并成一个新的有序表,即把待排序序列分为若干个子序列,每个子序列有序的。 然后再把有序子序列合并为整体有序序列。 这段话什么意思呢?我们举个例
  • 头条基础面试题1-9

    2021-01-09 01:05:16
    一面(43min) 自我介绍 代码题:k个有序链表合并 代码题:求数组前k小 + 快速选择和最大堆两种方案的平均、最坏复杂度比较 ...不懂回表什么意思。换句话说只有主键索引聚簇索引吗?举例?比如说联合索引可...
  • java集合二分查找算分

    2017-09-14 06:23:10
    只有采用随机访问,二分查找才有意义,如果提供的一个链表,binarySearch()就 自动的变成线性查找。没太理解这句话的意思。链表是有序集合,为什么二分查找用在链表上就变成线性查找? 多谢各位老师指教。
  • java源码--set无序吗?

    2019-07-16 16:28:00
    有序的概念就是你添加是什么顺序,他保存就是什么顺序,那么无序也就知道是什么意思了,其次,jdk1.8及以上版本,set集合的底层实现采取的是hashmap,hashmap有一个很明显的特点就是数据量大了之后,会由链表转为...
  • 什么意思呢?就是说你这个算法只能用于从大到小、或者从小到大排列好的有序序列。如果你存放数据的数组无序的,那你首先还得给它排序一下。 二、二分查找算法的具体思路 首先如果我们有一个数组: {1,8,10,89,10
  • 插入顺序是有序的 (底层链表致使有序) 负载因子和初始容量对LinkedHashMap影响很大 问题: access-ordered和insertion-ordered具体的使用和意思什么说初始容量对遍历没有影响? 2. 属性 /** * 在原有的HashMap...
  • 这样就带来一个问题:python中什么是对象? 答案:一切都对象。 python中所有的数据值都对象,尽管从表面来看,“Don't panic!”一个字符串,42一个数字,但是对python程序员来说 “Don't panic!”...
  • Web前端第三课

    2019-12-23 15:21:51
    列表 列表有三种:ul、ol、dl ...但是li一个容器级标签,li里面什么都可以放。 有序列表: ordered list 有序列表:ol 。 ol这个东西用的不多,如果想要表达顺序,大家一般也用ul 。 定义列表...
  • JDK8之Stream流

    2020-05-25 23:24:52
    (先不必纠结这段代码究竟什么意思,看完之后就能理解了。) 1.什么流? 到底什么流?简短的定义就是:从支持数据处理操作的源生成的元素序列 剖析上面的定义: 元素序列— 就像集合一样,流也提供一个接口,...
  • java基础-集合-List

    2019-10-21 17:30:07
    什么是List 初识 list字面翻译列表、清单的意思。List一种有序的容器,通过线性方式管理数据,它的内部结构双向链表; 在jdk中属于集合类工具,继承了collection接口。 简单看一下List接口的方法 相知 ...
  • 换了递归做居然也这个结果,感觉写博客也没什么意思,所以我就又随机选了一道。 题目 给定一个字符串 (s) 和一个字符模式 § ,实现一个支持 ‘?’ 和 ‘*’ 的通配符匹配。 ‘?’ 可以匹配任何单个字符。 ‘*’ ...
  • 0.简介 本次我来简单做一个平衡二叉树的推导,意在了解平衡二叉树...来看一下不平衡的情况是什么。下面采用手绘图来表达。 不平衡情况 上图中我们不难看出,这种情况是不平衡情况,相对的还可以是右子树深左子树浅
  • 隐马尔可夫链模型

    2020-08-08 21:50:08
    什么是熵(Entropy) 简单来说,熵表示物质系统状态的一种度量,用它老表征系统的无序程度。熵越大,系统越无序,意味着系统结构和运动的不确定和无规则;反之,,熵越小,系统越有序,意味着具有确定和有规则的...
  • Comparable故名思意比较,意思就是做比较的,然后进行排序。 1.什么是comparable接口 此接口强行对实现它的每个类的对象进行整体排序。此排序被称为该类的自然排序 ,类...实现此接口的对象可以用作有序映射中...

空空如也

空空如也

1 2 3
收藏数 46
精华内容 18
关键字:

有序表是什么意思