精华内容
下载资源
问答
  • 数据结构刷题app
    2020-07-26 17:07:16

    1.树

    1.1 二叉树

    1.1.1 二叉树的深度

     # Definition for a binary tree node.
     class TreeNode:
         def __init__(self, x):
             self.val = x
             self.left = None
             self.right = None
    
    class Solution:
        def maxDepth(self, root: TreeNode) -> int:
            if not root:
                return 0
            ldepth = Solution.maxDepth(self, root.left)
            rdepth = Solution.maxDepth(self, root.right)
            return max(ldepth, rdepth) + 1
    

    1.1.2 二叉搜索树的第k大节点

    # Definition for a binary tree node.
    # class TreeNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    
    class Solution:
        def kthLargest(self, root: TreeNode, k: int) -> int:
            def func(root):
                return func(root.left) +[root.val]+func(root.right) if root else []
    
            return func(root)[-k]
    
    

    1.1.3 二叉树的遍历

    先序遍历
    #递归
    def pre_order(root):
        if not root:
            return []
        return [root.val]+pre_order(root.left)+pre_order(root.right)
    #非递归
    def pre_order(root):
        if not root:
            return 
        stack=[]
        stack.append(root)
        ret=[]
        while stack:
            x=stack.pop()
            ret.append(x.val)
            if x.right:
                stack.append(x.right)
            if x.left:
                stack.append(x.left)
    
    中序遍历
    #递归
    def mid_order(root):
        if not root:
            return []
        return mid_order(root.left)+[root.val]+mid_order(root.right)
    #非递归
    def mid_order(root):
        if not root:
            return 
        stack=[]
        stack.append(root)
        ret=[]
        while stack:
            x=stack.pop()
            if x.right:
                stack.append(x.right)
            ret.append(x.val)
            if x.left:
                stack.append(x.left)
    
    后序遍历
    # 递归
    def post_order(root):
        if not root:
            return []
        return post_order(root.left)+post_order(root.right)+[root.val]
    # 非递归
    def post_order(root):
        if not root:
            return 
        stack=[]
        stack.append(root)
        ret=[]
        while stack:
            x=stack.pop()
            if x.right:
                stack.append(x.right)
            if x.left:
                stack.append(x.left)
            ret.append(x.val)
    
    层次遍历

    不保留空值

    def layer_order(root):
        if not root:
            return 
        stack=[]
        stack.append(root)
        ret=[]
        while stack:
            x=stack.pop()
            if x.right:
                stack.append(x.right)
            if x.left:
                stack.append(x.left)
            ret.append(x.val)
    

    保留空值

    def layer_order(root):
        if not root:
            return 
        stack=[]
        stack.append(root)
        ret=[]
        while any(stack):
            x=stack.pop()
            if x:
                stack.append(x.right)
                stack.append(x.left)
            ret.append(x.val)
    

    1.1.4 二叉树的构建

    按层次遍历构建

    采用层次遍历的结果构建二叉树,结果可能不对着,需要修改

    class TreeNode:
        def __init__(self, x, left, right):
            self.val = x
            self.left = left
            self.right = right
    def reconstruct(data):
        """
        依据层次遍历结果重构二叉树
        :return: 
        """
        if not data:
            return None
        # data = eval(data)
        n = len(data)
        vals, i = data, 1
        root = TreeNode(data[0])
        queue = [root]
        while queue:
            node = queue.pop(0)
            if i >= n: break
            if vals[i] != None:
                node.left = TreeNode(vals[i])
                queue.append(node.left)
            i += 1
            if i >= n: break
            if vals[i] != None:
                node.right = TreeNode(vals[i])
                queue.append(node.right)
            i += 1
        return root
    layer_node = [1, 2, 3, None, 4, 4, 5, None, None, 6, 7, 8]
    ret = reconstruct(layer_node)
    mid = mid_order(ret)
    print(ret)
    
    按先序和中序
    class Solution:
        def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
            if not preorder:
                return None
            if preorder:
                root=preorder.pop(0)
                root_idx=inorder.index(root)
                in_left=inorder[:root_idx]
                in_right=inorder[root_idx+1:]
                pre_left=preorder[:len(in_left)]
                pre_right=preorder[len(in_left):]
                return TreeNode(root,self.buildTree(pre_left,in_left),self.buildTree(pre_right,in_right))
    

    1.1.5 二叉树路径求和

    class Solution:
        def pathSum(self, root: TreeNode, sum: int) -> List[List[int]]:
            def func(root,has,target):
                if not root:return 
                tmp=has+[root.val]#采用临时变量的原因是之后不用再pop一下
                if not root.left and not root.right:
                    # 求和 
                    has_sum=0
                    for i in tmp:
                        has_sum+=i
                    # 判断目标和
                    if has_sum==target:
                        ret.append(tmp)
                        return
                func(root.left,tmp,target)
                func(root.right,tmp,target)
            ret=[]
            func(root,[],sum)
            return ret
    

    1.1.6 判断是否是平衡二叉树

    class Solution:
        def isBalanced(self, root: TreeNode) -> bool:
            def depth(root):
                if not root:
                    return 0
                return 1+max(depth(root.left),depth(root.right))
            if not root:
                return True
            if self.isBalanced(root.left) and self.isBalanced(root.right) and abs(depth(root.left)-depth(root.right))<=1: 
                return True
            else:
                return False
    

    1.1.7 对称二叉树

    class Solution:
        def isBalanced(self, root: TreeNode) -> bool:
            def depth(root):
                if not root:
                    return 0
                return 1+max(depth(root.left),depth(root.right))
            if not root:
                return True
            if self.isBalanced(root.left) and self.isBalanced(root.right) and abs(depth(root.left)-depth(root.right))<=1: 
                return True
            else:
                return False
    

    1.1.8 二叉树的镜像

    class Solution:
        def mirrorTree(self, root: TreeNode) -> TreeNode:
            if root is None:
                return root
            else:
                self.mirrorTree(root.left)
                self.mirrorTree(root.right)
                temp=root.left
                root.left=root.right
                root.right=temp
                return root
    

    1.1.9 是否是子结构

    class Solution:
        def HasSubtree(self, pRoot1, pRoot2):
            # write code here
            def is_subtree(pRoot1,pRoot2):
                if not pRoot1 and not pRoot2:
                    return True
                if not pRoot1:
                    return False
                if not pRoot2:
                    return True
                if pRoot1.val !=pRoot2.val:
                    return False
                else:
                    return is_subtree(pRoot1.left, pRoot2.left) and is_subtree(pRoot1.right, pRoot2.right)
            if not pRoot1:
                return False
            if not pRoot2:
                return False
            if is_subtree(pRoot1, pRoot2):
                return True
            else:return self.HasSubtree(pRoot1.left, pRoot2) or self.HasSubtree(pRoot1.right, pRoot2)
    

    1.1.10 二叉树的最小深度

    class Solution:
        def minDepth(self, root: TreeNode) -> int:
            if not root:
                return 0
            if not root.left or not root.right:
                return 1+max(self.minDepth(root.left),self.minDepth(root.right))
            else:
                return 1+min(self.minDepth(root.left),self.minDepth(root.right))
    

    1.2 二叉搜索树

    查找

            if not root:return None
            if root.val >val:
                return self.searchBST(root.left,val) 
            elif root.val<val:
                return self.searchBST(root.right,val) 
            else:return root
    

    验证二叉搜索树

    class Solution:
        def isValidBST(self, root: TreeNode) -> bool:
            if not root:
                return True
            # 递归 #需要同时比较左子树和右子树
            def func(root,low=-float("inf"),high=float("inf")):
                if not root:
                    return True
                if low>= root.val or high<=root.val:
                    return False
                else:
                    return func(root.left,low,root.val) and func(root.right,root.val,high)
            return func(root)
    

    2.链表

    2.1 单链表

    2.1.1 删除单链表的某个节点:

    删除中间节点

    class Solution:
        def deleteNode(self,node):
    		"输入仅删除的节点"
            node.val=node.next.val
            node.next=node.next.next
            
    
    class Solution:
        def deleteNode(self, head: ListNode, val: int) -> ListNode:
            if head.val==val:
                return head.next
            p=head
            q=head.next
            while q:
                if q.val != val:
                    p=q
                    q=q.next
                else:
                    p.next=q.next
                    break
            return head
    

    2.1.2 单链表的倒数第k个节点

    双指针

    class Solution:
        def getKthFromEnd(self, head: ListNode, k: int) -> ListNode:
            q=p=head
            while k:# q先走k步
                q=q.next
                k-=1
            while q:#p、q一起走,q到终点的时候,p在倒数dik个位置
                p=p.next
                q=q.next
            return p
    

    2.1.3 单链表的插入

    头插法

    class Solution:
        def insert(self, head: ListNode,node: ListNode):
        node.next=head.next
        head.next=node    
    

    尾插法

    class Solution:
        def insert(self, head: ListNode,node: ListNode):
        p=head
        q=head.next
        while q:
        	p=q
        	q=q.next
        q.next=node
        return head
    

    2.1.4 单链表的逆序

    # Definition for singly-linked list.
    # class ListNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.next = None
    
    class Solution:
        def reverseList(self, head: ListNode) -> ListNode:
            ret=None
            while head:
                p=head.next# head的下一个节点
                #头插
                head.next=ret
                ret=head
                #head 指向原来head的下一个
                head=p
            return ret
    

    2.1.5 删除单链表中重复元素

    class Solution:
        def deleteDuplicates(self, head: ListNode) -> ListNode:
            if not head:
                return None
            p=head
            while p:
                if p.next and p.val==p.next.val:
                    p.next=p.next.next
                else: p=p.next
            return head
    

    3.图

    3.1 有向图

    3.1.1 拓扑排序

    leetcode 中的例题:210. 课程表 II

    
    class Solution(object):
        def findOrder(self, numCourses, prerequisites):
            """
            :type numCourses: int 课程门数
            :type prerequisites: List[List[int]] 课程之间的次序关系
            """
            # 入度表
            rudus = {num: [] for num in range(numCourses)}
            for cur, pre in prerequisites:
                rudus[cur].append(pre)
            chudus = {num: [] for num in range(numCourses)}
            for cur, pre in prerequisites:
                chudus[pre].append(cur)
    
            # 先判断是否有环 判断拓扑排序是否有环
            def dfs(course):
                states[course] = 1
                for next_course in chudus[course]:
                    if states[next_course] == 1:  # 找见了环
                        return False
                    elif states[next_course] == 0:# 继续
                        if not dfs(next_course): return False
                states[course] = 2
                return True
    
            for course in range(numCourses):
                states = [0 for _ in range(numCourses)]
                if not dfs(course):
                    return []
            visited = [True for _ in range(numCourses)]
            ret = []
            while any(visited):
                for cur_course in rudus.keys():
                    if not rudus[cur_course] and visited[cur_course]:  # 当该节点没有前置的时候
                        visited[cur_course] = False
                        ret.append(cur_course)
                        for pre_course in rudus.keys():  # 在其余的节点里删除前置
                            if pre_course == cur_course:
                                continue
                            if cur_course in rudus[pre_course]:
                                rudus[pre_course].remove(cur_course)
            return ret
    
    更多相关内容
  • 程序员刷题app排行榜目的 这可以作为结构化指南,指导您如何构建全栈应用程序,以防您迷路或不知道如何开始。 现在,这将在一个非常高级的概述中编写。 这应该是语言不可知的,没有深入研究框架或哪种语言可以优化您...
  • leetcode刷题app 算法冲冲冲!!!!!!!适合后台人员的算法学习!! 1. 后台学习方法 看刘宇波波的三个视频,看你想看的知识点就行,边看边做对应的题目 视频:三个视频的内容在下面的卡片里面!!链接: 提取码...
  • leetcode刷题app 面试 Google 招聘的网上算法试场,一般一场打进前40可能会收到Google的面试邀约 一些常见的工程师面试问题 一个难度比leetcode难的网站,网站不仅仅有算法,还有数学和其他编程语言的锻炼项目。 ...
  • 程序员刷题app有哪些 Android_QA 2020 年 10 月 27 重磅更新: 最真实的 Android 面经,最详细的面试回答,我都给你准备好啦! 几大公司面试问题: 里面都备注了回答要点! 最重要的,遇到这些面试题该如何回答我都...
  • 计算机考研刷题小程序

    千次阅读 多人点赞 2021-01-23 16:02:44
    开发需求 ...因此我开发了一款专门用于计算机考研的微信小程序,包含了数据结构,计算机网络,操作系统,c语言等类别科目的刷题小程序。题目收录于各大知名考研真题和经典习题 小程序特色 收录各大高效

    开发需求

    近些年了,考研逐渐成为了一场热门的竞争考试,特别是近几年考研报考人数激增,导致各大高校在招生人数相对稳定的情况下,竞争达到了白热化。我们都很清楚,考研中最容易的是政治,但是这门科目大家不会有太大差距的,所以考研最容易拉开分数的是数学和专业课,尤其是专业课,如果你能抓住重点,高分十分容易,且不会想数学那样需要高强度的复习。因此我开发了一款专门用于计算机考研的微信小程序,包含了数据结构,计算机网络,操作系统,c语言等类别科目的刷题小程序。题目收录于各大知名考研真题和经典习题

    小程序特色

    • 收录各大高效=校真题(包含最新题目)
    • 可以接收你的宝贵建议,录入对应高校真题
    • 记录您的的每章错题
    • 可以收藏你喜欢的题目
    • 实时显示答题排名和积分
    • 收录各门科目的文章讲解(您可以联系我上传你认为写的好的文章)
    • 十分好的学习竞争氛围

    小程序展示

    1.我的界面
    在这里插入图片描述

    2.刷题选择科目界面
    在这里插入图片描述

    3.进入刷题分类界面
    在这里插入图片描述
    4.刷题界面

    在这里插入图片描述
    5.我的错题界面
    在这里插入图片描述
    6.科目教程界面
    在这里插入图片描述
    7.教程详细展示
    在这里插入图片描述
    8.排行榜(实时显示你的答题情况)

    在这里插入图片描述
    9.联系客服(可以上传你的文章,可以收录报考高校真题)

    在这里插入图片描述
    10.收藏题目界面

    在这里插入图片描述

    总结

    欢迎大家使用小程序,助力你一战成硕,提高计算机专业水平,下面是小程序码,欢迎体验
    在这里插入图片描述

    展开全文
  • 2009-2020计算机统考408试题刷题版 分科目 这个是我从公众号下下来的然后自己整理了一下,方便打印出来刷题用 希望能对你有所帮助
  • 使用这个学习软件自行学习能快速掌握数据结构内容 我们老师给我的 还不错哦。适合初学数据结构的同学,提供种数据结构,代码,参数及数据结构的逻辑图
  • LeetCode ...特点:题目类型多而且经典 牛客网 ...特点:在线刷题网站,汇集了各大公司的算法面试题。有阶梯式训练题库,帮你选好应该刷的题目,特别适合小白和懒人。 hihocoder https://hihocoder.com/ C

    1. 牛客网

    https://www.nowcoder.com/link/pc_csdncpt_qrsjd_c

    该网站内集成了面试、题库、社群交流、课程教育、面试、招聘内推等多个模块。另外还是一个交流学习的平台,在该网站经常会有大佬对你的问题进行热心帮助。

    2. LeetCode

    https://leetcode-cn.com/

    LeetCode基本所有的程序员都很熟悉了,有很多优秀的程序员都在该网站上刷题,也会有一些面试官会从这上面挑选面试题目。

    3. 在线刷题网站lintcode

    https://www.lintcode.com/

    该网站是一个在线刷题的网站,汇集了各大公司的算法面试题。有阶梯式训练题库,帮你选好应该刷的题目,特别适合小白和懒人。

    4. hihoCoder

    https://hihocoder.com

    该网站是由原北大POJ团队所开发。在该网站上经常会有一些知名大厂举办编程比赛,例如:微软,百度,腾讯,网易等等,该比赛风格与ACM类似。
    另外,该网站每一周每一月都会有周赛,月赛。每周的周赛都是一道比较有意思的题目,可以开阔我们的思路,而月赛的题目都是由北大等一流高校ACM的大佬所准备的题目,通过每周每月的比赛,可以检验自己的真实水平。

    5. VisuAlgo

    https://visualgo.net/zh

    该网站是一个算法可视化网站,目前支持英文,中文,日文等等

    每种算法都会有两种可视化方式:

    • 电子讲座模式:以知识点讲解的模式呈现
    • 示例模式:以动画的方式呈现

    两种方式都可以由你控制进度,帮助你了解算法的每一步执行过程。

    6. 北京大学POJ

    http://poj.org/

    该网站创建的时间比较早,在上面几乎可以找到一些上古的题目,同时也是国内最火的几个OJ之一。

    7. 杭电HDUOJ

    http://acm.hdu.edu.cn/

    中国最受欢迎OJ之一,题目数量多,来源广。

    8. 浙大ZOJ

    https://zoj.pintia.cn/home

    9. 中科大USTCOJ

    http://acm.ustc.edu.cn/ustcoj/

    10. Codehs

    https://codehs.com/

    包含数据结构、游戏设计、动画类编程题。

    11. GeeksforGeeks

    https://www.geeksforgeeks.org/

    GeeksforGeeks网站上包含了许多关于算法和数据结构的文章

    通过该网站可以让你达到以下两个目的:

    • 在线编辑器中进行挑战
    • 在该网站的代码解决方案中,你会看到解题者是如何将一个复杂的问题分解成更简单的部分,并提出代码解决方案
    展开全文
  • 推荐一款前端刷题系统

    千次阅读 2021-11-15 09:33:48
    推荐一款前端刷题系统 大伙好,我是朵拉,临近年底,想必又有...时间就是金钱,这里跟大伙推荐一款免费的在线面试测试,不过暂时主要针对前端的js es6 vue 数据结构算法等;还需完善 是时候展现我的技术了-_-,哈哈哈

    推荐一款前端刷题系统

    大伙好,我是朵拉,临近年底,想必又有一波开发对跳槽蠢蠢欲动,开始寻找着各种机会;同时展开了地毯式全网找面试题,几天下来网盘资料多了几个T;这厂,那厂。。。有种高考逼近,临时抱佛脚,背多少是多少的感觉;

    image.png

    image.png

    image.png

    image.png

    一周后,发现啥也没记住呀

    image.png

    要能来不波在线测试就好了,做到心里有点数;

    于是乎全网搜在线测试.

    时间就是金钱,这里跟大伙推荐一款免费的在线面试测试,不过暂时主要针对前端的js es6 vue 数据结构算法等;还需完善

    是时候展现我的技术了-_-,哈哈哈

     

    想挑战的搜索公众号“ITLove”,选择“面试刷题”,加朵拉vx: ITI2018,送前端面试题大礼包,需要的小伙伴不要错过哦。

    推荐给需要面试找工作的小伙伴们!

    展开全文
  • } [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fkauVOKz-1647174009087)(C:/Users/Hannah/AppData/Roaming/Typora/typora-user-images/image-20220312204506879.png)] 2022.3.12 46....
  • “Python小屋”编程比赛正式开始Python小屋刷题软件客户端使用说明(视频讲解)Python小屋刷题神器最近升级的新功能介绍每次录入新题目时都会更新下面的分类表,请注意查看最新信息。...
  • 使用数组存储不同类型的数据
  • 后端能用就行() 数据库MySQL 功能展示 主页 我的 答题卡 框架设计 题库 题库直接从网上爬取 传送门: 记录一次爬虫题库 数据库结构 这个要写可以写好几页,先带过 前端 参考了软考通 功能实现 刷题部分 刷题模式...
  • 高级数据结构 基础知识 trie树 又叫字典树、前缀树 (图中的红圈表示字符串结尾) 最为高效的字符串查找算法。 // 26 个字母 #define TRIE_MAX_CHAR_NUM 26 struct TrieNode { TrieNode *child[TRIE_MAX_CHAR_NUM...
  • java面试题库app

    2022-03-26 15:42:10
    java面试题库app是一款专为正在找工作的java程序员打造的软件,这款软件集合了精选的Java面试笔试题目及答案,致力于帮助用户通过面试和笔试,有需要的朋友快来下载吧。 java面试题库app特色 1、java基础(全面的...
  • 刷题软件(模拟python二级考试):公众h:露露IT 回复:python二级。
  • 数据结构与算法】起始篇什么是数据结构和算法什么是数据结构什么是算法为什么要学习数据结构和算法1为什么要学习数据结构和算法2为什么要学习数据结构和算法3为什么要学习数据结构和算法4数据结构和算法的重要性...
  • 程序员面试刷题的书哪个好 1. 项目框架结构搭建(webpack + vue) webpack 打包 整合代码 webpack -p hbuilder 打包成移动App vue-cli 2. 使用路由跳转页面(vue-router) :to='/home'> :to='/photo/photoinfo/1'> new...
  • 实现优先级队列最常用的数据结构是堆,堆的常见实现有二叉堆、斐波那契堆、二项堆等。 二叉堆 堆是一种完全二叉树,我们以小根堆为例,小根堆的性质就是,每个节点都小于其左孩子和右孩子,不难发现,这种二叉树,根...
  • 考研刷题小程序云开发实战-目录结构与配置文件。可以清晰的看出,小程序代码是由JSON 配置、WXML 模板、WXSS 样式、JS 逻辑交互这四部分构成的。
  • 【游戏开发创新】使用Unity制作Unity题库,支持题目录入和刷题(面试 | 笔试)
  • 题目描述: 代码如下: //自测-2 #include &lt;stdio.h&gt; #include &lt;math.h&gt; int isprime( int n ); int main ( void ) { int n, count = 0; scanf( "%d"... ...
  • 泛型原理、反射原理、Java虚拟机原理、线程池原理、注解原理、序列化、...数据结构、排序算法、设计模式)APP性能优化(用户体验优化、适配、代码调优)热修复热升级Hook技术、IOC架构设计、NDK(c编程、C++、JNI、...
  • 新星计划Day5【数据结构与算法】 链表Part1

    多人点赞 热门讨论 2022-04-30 11:08:02
    新星计划Day5【数据结构与算法】 链表Part1 ‍博客主页:京与旧铺的博客主页 ✨欢迎关注点赞收藏⭐留言✒ 本文由京与旧铺原创,csdn首发! 系列专栏:java学习 首发时间:2022年4月29日 你做三四月的事,八九月就会...
  • 运行结果如下图所示:[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-1NSZgH0y-1654225565348)(D:\刷题图片\image-20220603105715109.png)] 思路: 运行结果如下[外链图片转存失败,源...
  • [C语言]如何使用C语言创建题库,进行高效刷题?教你如何创建一个简易题库,进行高效刷题!!C语言博大精深,方便生活才是真;
  • 剑指offer刷题 --前端(javascript)

    千次阅读 2020-06-30 19:07:04
    思路 代码 13、调整数组顺序使奇数位于偶数前 题目描述 思路 代码 14、链表中倒数第k个结点 题目描述 思路 代码 15、反转链表 题目描述 思路 代码 16、合并俩个排序的链表 题目描述 思路 代码 17、树的子结构 ...
  • 力扣刷题日记

    2022-07-11 11:29:55
    基本思想是:通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,368
精华内容 1,347
热门标签
关键字:

数据结构刷题app

数据结构 订阅
友情链接: PRead_DataC.rar