精华内容
下载资源
问答
  • 以前总是没搞清楚半到底有多少个字节,有说是4字节的,又说是8字节的,但没有个固定的说法 下面这段话摘抄自Computer system: a programmer's perspective Buses are typically designed to transfer ...

    以前总是没搞清楚半字,字到底有多少个字节,有说字是4字节的,又说字是8字节的,但没有个固定的说法

    下面这段话摘抄自Computer system: a programmer's perspective

    Buses are typically designed to transfer fixed-sized chunks of bytes known as words. The
    number of bytes in a word (the word size) is a fundamental system parameter that
    varies across systems. Most machines today have word sizes of either 4 bytes (32
    bits)or8bytes(64bits).

    翻译过来就是说:总线一般被设计来传输固定大小的一块数据,这块数据被称为字(word),一个字包含的字节数(即字的大小)是各种计算机系统里面的基本参数,而且这个参数在不同的系统里通常是不同的。大多数的现代计算机系统里面,一个字要么是4个字节,要么是8个字节.

    由此我们可以看出,单纯问一个字占多少字节是没有意义的,因为字的大小取决去具体系统的总线宽度,如果是32位的系统,则一个字是4个字节,如果是64位,则是8个字节。
    -

    对字(Word)、半字(Half-Word)、字节(Byte)的概念说明如下:

     

     

     

    字(Word):在ARM体系结构(32位机)中,字的长度为32位,而在8位/16位处理器体系结构中,字的长度一般为16位。

     

    半字(Half-Word):在ARM体系结构(32位机)中,半字的长度为16位,与8位/16位处理器体系结构中字的长度一致。

     

    字节(Byte):在ARM体系结构(32位机)和8位/16位处理器体系结构中,字节的长度均为8位。

    展开全文
  • ARM中的、半、字节是多少位?

    万次阅读 多人点赞 2018-06-25 09:19:37
    字节永远都是8bit,的大小依赖于平台(可以通过sizeof()函数进行查看),但是可以确定的是,多少位,半永远是的一半,双永远是的2倍大小 一、对于嵌入式底层开发人员 (Word):在ARM体系结构中,...

    总结:

    字节永远都是8bit,字的大小依赖于平台(可以通过sizeof()函数进行查看),但是可以确定的是,字是多少位,半字永远是字的一半,双字永远是字的2倍大小

    一、对于嵌入式底层开发人员

    字(Word):在ARM体系结构中,字的长度为32位,而在8位/16位处理器体系结构中,字的长度一般为16位。

    半字(Half-Word):在ARM体系结构中,半字的长度为16位,与8位/16位处理器体系结构中字的长度一致。

    字节(Byte):在ARM体系结构和8位/16位处理器体系结构中,字节的长度均为8位

    ARM 采用的是32位架构.
    ARM 约定:
    Byte : 8 bits
    Halfword :16 bits (2 byte)
    Word : 32 bits (4 byte)

    二、对于应用程序开发人员

    1、字节,byte,8bit,就是8个二进制位,一个ASCII字母占用的空间

    2、字,word,16bit,一个汉字占用的空间

    3、双字,dword,32bit

     

    例如在Visual C++ 6.0中,BYTE与WORD,DWORD本质上都是一种无符号整型,它们在WINDEF.H中被定义,定义如下:
    typedef unsigned char       BYTE;
    typedef unsigned short      WORD;
    typedef unsigned long       DWORD;
     也就是说BYTE是无符号的char型(char型本质上也是一种1个字节的整型),WORD是无符号short型,DWORD是无符号long型。
     而在Visual C++ 6.0中,char型长度为1字节,short型长度为2字节,int和long型长度都为4字节,因此可以认为BYTE与WORD,DWORD定义的变量分别获得了1字节,2字节,4字节内存。

    从windows的计算器也能看出一些端倪:

    注:我的电脑是WIN7  64BIT,CPU是I5系列。可以看出这个计算器和你电脑的操作系统和CPU的位数无关

    我在VS2010实验的结果如下:

    系统环境:WIN7 64BIT    旗舰版    

                     VS2010  64BIT 

                     工程配置属性为WIN32和X64的结果都如下所示

    http://blog.chinaunix.net/uid-21977330-id-3801847.html

     

    展开全文
  • 刷了 3333 题 算法题 后的一点点经验总结 —— 题不是这么刷的!

    1️⃣前言:追忆我的刷题经历

      学习算法最好的方法就是刷题了,上大学的时候刷过一些,最近开始转战 LeetCode。

    🔥让天下没有难学的算法🔥

    C语言免费动漫教程,和我一起打卡!
    🌞《光天化日学C语言》🌞

    入门级C语言真题汇总
    🧡《C语言入门100例》🧡

    几张动图学会一种数据结构
    🌳《画解数据结构》🌳

    组团学习,抱团生长
    🌌《算法入门指引》🌌

    竞赛选手金典图文教程
    💜《夜深人静写算法》💜

    在这里插入图片描述

    2️⃣算法和数据结构的重要性

    👪1、适用人群

    • 这篇文章会从 「算法和数据结构」 零基础开始讲,所以,如果你是算法大神,可以尽情在评论区嘲讽我哈哈,目的当然是帮助想要涉足算法领域,或者正在找工作的朋友,以及将要找工作的大学生,更加有效快速的掌握算法思维,能够在职场面试和笔试中一展身手。
    • 这篇文章中,我会着重讲解一些常见的 「算法和数据结构」 的设计思想,并且配上动图。主要针对面试中常见的问题和新手朋友们比较难理解的点进行解析。当然,后面也会给出面向算法竞赛的提纲,如果有兴趣深入学习的欢迎在评论区留言,一起成长交流。
    • 零基础学算法的最好方法,莫过于刷题了。任何事情都是需要坚持的,刷题也一样,没有刷够足够的题,就很难做出系统性的总结。所以上大学的时候,我花了三年的时间来刷题, 工作以后还是会抽点时间出来刷题。

    千万不要用工作忙来找借口,时间挤一挤总是有的。

    • 我现在上班地铁上一个小时,下班地铁又是一个小时。比如这篇文章的起草,就是在 地铁 上完成的。如何利用这两个小时的时间,做一些有建设性的事情,才是最重要的。刷抖音一个小时过得很快,刷题也是同样的道理。
    • 当然,每天不需要花太多时间在这个上面,把这个事情做成一个规划,按照长期去推进。反正也没有 KPI 压力,就当成是工作之余的一种消遣,还能够提升思维能力。

    所以,无论你是 小学生中学生高中OIer大学ACMer职场人士,只要想开始,一切都不会太晚!

    🎾2、有何作用

    • 我们平常使用的 智能手机、搜索引擎、网站、操作系统、游戏、软件、人工智能,都大量地应用了 「算法与数据结构」 的知识,以及平时你用到的各种库的底层实现,也是通过各种算法和数据结构组合出来的,所以可以说,有程序的地方,就有江湖 算法,有算法就一定会有对应的数据结构。
    • 如果你只是想学会写代码,或许 「算法与数据结构」 并不是那么重要,但是想要往更深一步发展,「算法与数据结构」 是必不可少的。

      现在一些主流的大厂,在面试快结束的时候都会 奉上一道算法题,如果你敲不出来,可能你的 offer 年包就打了 七折,或者直接与 offer 失之交臂,都是有可能的(因为我自己也是万恶的面试官,看到候选人的算法题写不出来我也是操碎了心,但是我一般会给足容错,比如给三个算法题,挑一个写,任意写出一个都行)。

    • 当然,它不能完全代表你的编码能力,因为有些算法确实是很巧妙,加上紧张的面试氛围,想不出来其实也是正常的,但是你能确保面试官是这么想的吗?我们要做的是十足的准备,既然决定出来,offer 当然是越高越好,毕竟大家都要养家糊口,房价又这么贵,如果能够在算法这一块取得先机,也不失为一个捷径。

    所以,你问我算法和数据结构有什么用?我可以很明确的说,和你的年薪息息相关。

    • 当然,面试中 「算法与数据结构」 知识的考察只是面试内容的一部分。其它还有很多面试要考察的内容,当然不是本文主要核心内容,这里就不做展开了。

    📜3、算法简介

    • 算法是什么东西?
    • 它是一种方法,一种解决问题的方案。
    • 举个例子,你现在要去上班,可以选择 走路、跑步、坐公交、坐地铁、自己开车 等等,这些都是解决方案。但是它们都会有一些衡量指标,让你有一个权衡,最后选择你认为最优的策略去做。
    • 而衡量的指标诸如:时间消耗、金钱消耗、是否需要转车、是否可达 等等。

    时间消耗就对应了:时间复杂度
    金钱消耗就对应了:空间复杂度
    是否可达就对应了:算法可行性

    • 当然,是否需要转车,从某种程度上都会影响 时间复杂度 或者 空间复杂度

    🌲4、数据结构

    • 对于实现某个算法,我们往往会用到一些数据结构。
    • 因为我们通常不能一下子把数据处理完,更多的时候需要先把它们放在一个容器或者说缓存里面,等到一定的时刻再把它们拿出来。
    • 这其实是一种 「空间换时间」 思想的体现, 恰当使用数据结构可以帮助我们高效地处理数据。
    • 常用的一些数据结构如下:
    数据结构应用场景
    数组线性存储、元素为任意相同类型、随机访问
    字符串线性存储、元素为字符、结尾字符、随机访问
    链表链式存储、快速删除
    先进后出
    队列先进先出
    哈希表随机存储、快速增删改查
    二叉树对数时间增删改查,二叉查找树、线段树
    多叉树B/B+树 硬盘树、字典树 字符串前缀匹配
    森林并查集 快速合并数据
    树状数组单点更新,成段求和
    • 为什么需要引入这么多数据结构呢?

      答案是:任何一种数据结构是不是 完美的。所以我们需要根据对应的场景,来采用对应的数据结构,具体用哪种数据结构,需要通过刷题不断刷新经验,才能总结出来。

    3️⃣如何开始持续的刷题

    • 有朋友告诉我,题目太难了,根本不会做,每次都是看别人的解题报告。

    📑1、立军令状

    • 所谓 「军令状」,其实就是给自己定一个目标,给自己树立一个目标是非常重要的,有 「目标才会有方向,有目标才会有动力,有目标才会有人生的意义」 。而军令状是贬义的,如果不达成就会有各种惩罚,所以其实你是心不甘情不愿的,于是这件事情其实是无法持久下去的。

    事实证明,立军令状是不可取的。

    • 啊这……所以我们还是要采用一些能够持久下去的方法。

    👩‍❤️‍👩2、培养兴趣

    • 为了让这件事情能够持久下去,一定要培养出兴趣,适时的给自己一些正反馈。正反馈的作用就是每过一个周期,如果效果好,就要有奖励,这个奖励机制可以自己设定,但是 「不能作弊」 ,一旦作弊就像单机游戏修改数值,流失是迟早的事。
    • 举个例子,我们可以给每天制定一些 「不一样的目标和奖励」 ,比如下图所示:
    刷题的第?天目标题数是否完成完成奖励
    11攻击力 + 10
    21防御力 + 10
    32出去吃顿好的
    42攻击力 + 29
    53防御力 + 60
    61攻击力 + 20
    74出去吃顿好的
    81防御力 + 50
    • 当然,这个完成奖励你可以自己定,总而言之,要是对你有诱惑的奖励才是有意义的。

    🚿3、狂切水题

    • 刚开始刷的 300 题一定都是 「水题」 ,刷 「水题」 的目的是让你养成一个每天刷题的习惯。久而久之,不刷题的日子会变得无比煎熬。当然,刷着刷着,你会发现,水题会越来越多,因为刷题的过程中,你已经无形中不断成长起来了。
    • 至少这个方法我用过,非常灵验!推荐刷题从水题开始。

    如果不知道哪里有水题,推荐:
       C语言入门水题:《C语言入门100例》
      C语言算法水题:《LeetCode算法全集》

    💪🏻4、养成习惯

    • 相信如果切了 300 个 「水题」 以后,刷题自然而然就成了习惯,想放弃都难。这个专业上讲,其实叫 沉没成本。有兴趣的可以自行百度,这里就不再累述了。

    🈵5、一周出师

    • 基本上如果能够按照这样的计划去执行,一周以后,一定会有收获,没有收获的话,可以来找我。

    4️⃣简单数据结构的掌握

    🚂1、数组

    内存结构:内存空间连续
    实现难度:简单
    下标访问:支持
    分类:静态数组、动态数组
    插入时间复杂度 O ( n ) O(n) O(n)
    查找时间复杂度 O ( n ) O(n) O(n)
    删除时间复杂度 O ( n ) O(n) O(n)

    🎫2、字符串

    内存结构:内存空间连续,类似字符数组
    实现难度:简单,一般系统会提供一些方便的字符串操作函数
    下标访问:支持
    插入时间复杂度 O ( n ) O(n) O(n)
    查找时间复杂度 O ( n ) O(n) O(n)
    删除时间复杂度 O ( n ) O(n) O(n)

    🎇3、链表

    内存结构:内存空间连续不连续,看具体实现
    实现难度:一般
    下标访问:不支持
    分类:单向链表、双向链表、循环链表、DancingLinks
    插入时间复杂度 O ( 1 ) O(1) O(1)
    查找时间复杂度 O ( n ) O(n) O(n)
    删除时间复杂度 O ( 1 ) O(1) O(1)

    🌝4、哈希表

    内存结构:哈希表本身连续,但是衍生出来的结点逻辑上不连续
    实现难度:一般
    下标访问:不支持
    分类:正数哈希、字符串哈希、滚动哈希
    插入时间复杂度 O ( 1 ) O(1) O(1)
    查找时间复杂度 O ( 1 ) O(1) O(1)
    删除时间复杂度 O ( 1 ) O(1) O(1)

    👨‍👩‍👧5、队列

    内存结构:看用数组实现,还是链表实现
    实现难度:一般
    下标访问:不支持
    分类:FIFO、单调队列、双端队列
    插入时间复杂度 O ( 1 ) O(1) O(1)
    查找时间复杂度:理论上不支持
    删除时间复杂度 O ( 1 ) O(1) O(1)

    👩‍👩‍👦‍👦6、栈

    内存结构:看用数组实现,还是链表实现
    实现难度:一般
    下标访问:不支持
    分类:FILO、单调栈
    插入时间复杂度 O ( 1 ) O(1) O(1)
    查找时间复杂度:理论上不支持
    删除时间复杂度 O ( 1 ) O(1) O(1)

    🌵7、二叉树

    优先队列 是 堆实现的,所以也属于 二叉树 范畴。它和队列不同,不属于线性表。
    内存结构:内存结构一般不连续,但是有时候实现的时候,为了方便,一般是物理连续,逻辑不连续
    实现难度:较难
    下标访问:不支持
    分类:二叉树 和 多叉树
    插入时间复杂度:看情况而定
    查找时间复杂度:理论上 O ( l o g 2 n ) O(log_2n) O(log2n)
    删除时间复杂度:看情况而定

    🌳8、多叉树

    内存结构:内存结构一般不连续,但是有时候实现的时候,为了方便,一般是物理连续,逻辑不连续
    实现难度:较难
    下标访问:不支持
    分类:二叉树 和 多叉树
    插入时间复杂度:看情况而定
    查找时间复杂度:理论上 O ( l o g 2 n ) O(log_2n) O(log2n)
    删除时间复杂度:看情况而定

    🌲9、森林

    🍀10、树状数组

    🌍11、图

    内存结构:不一定
    实现难度:难
    下标访问:不支持
    分类:有向图、无向图
    插入时间复杂度:根据算法而定
    查找时间复杂度:根据算法而定
    删除时间复杂度:根据算法而定

    1、图的概念

    • 在讲解最短路问题之前,首先需要介绍一下计算机中图(图论)的概念,如下:
    • G G G 是一个有序二元组 ( V , E ) (V,E) (V,E),其中 V V V 称为顶点集合, E E E 称为边集合, E E E V V V 不相交。顶点集合的元素被称为顶点,边集合的元素被称为边。
    • 对于无权图,边由二元组 ( u , v ) (u,v) (u,v) 表示,其中 u , v ∈ V u, v \in V u,vV。对于带权图,边由三元组 ( u , v , w ) (u,v, w) (u,v,w) 表示,其中 u , v ∈ V u, v \in V u,vV w w w 为权值,可以是任意类型。
    • 图分为有向图和无向图,对于有向图, ( u , v ) (u, v) (u,v) 表示的是 从顶点 u u u 到 顶点 v v v 的边,即 u → v u \to v uv;对于无向图, ( u , v ) (u, v) (u,v) 可以理解成两条边,一条是 从顶点 u u u 到 顶点 v v v 的边,即 u → v u \to v uv,另一条是从顶点 v v v 到 顶点 u u u 的边,即 v → u v \to u vu

    2、图的存储

    • 对于图的存储,程序实现上也有多种方案,根据不同情况采用不同的方案。接下来以图二-3-1所表示的图为例,讲解四种存储图的方案。

    1)邻接矩阵

    • 邻接矩阵是直接利用一个二维数组对边的关系进行存储,矩阵的第 i i i 行第 j j j 列的值 表示 i → j i \to j ij 这条边的权值;特殊的,如果不存在这条边,用一个特殊标记 ∞ \infty 来表示;如果 i = j i = j i=j,则权值为 0 0 0
    • 它的优点是:实现非常简单,而且很容易理解;缺点也很明显,如果这个图是一个非常稀疏的图,图中边很少,但是点很多,就会造成非常大的内存浪费,点数过大的时候根本就无法存储。
    • [ 0 ∞ 3 ∞ 1 0 2 ∞ ∞ ∞ 0 3 9 8 ∞ 0 ] \left[ \begin{matrix} 0 & \infty & 3 & \infty \\ 1 & 0 & 2 & \infty \\ \infty & \infty & 0 & 3 \\ 9 & 8 & \infty & 0 \end{matrix} \right] 0190832030

    2)邻接表

    • 邻接表是图中常用的存储结构之一,采用链表来存储,每个顶点都有一个链表,链表的数据表示和当前顶点直接相邻的顶点的数据 ( v , w ) (v, w) (v,w),即 顶点 和 边权。
    • 它的优点是:对于稀疏图不会有数据浪费;缺点就是实现相对邻接矩阵来说较麻烦,需要自己实现链表,动态分配内存。
    • 如图所示, d a t a data data ( v , w ) (v, w) (v,w) 二元组,代表和对应顶点 u u u 直接相连的顶点数据, w w w 代表 u → v u \to v uv 的边权, n e x t next next 是一个指针,指向下一个 ( v , w ) (v, w) (v,w) 二元组。
    • 在 C++ 中,还可以使用 vector 这个容器来代替链表的功能;
        vector<Edge> edges[maxn];
    

    3)前向星

    • 前向星是以存储边的方式来存储图,先将边读入并存储在连续的数组中,然后按照边的起点进行排序,这样数组中起点相等的边就能够在数组中进行连续访问了。
    • 它的优点是实现简单,容易理解;缺点是需要在所有边都读入完毕的情况下对所有边进行一次排序,带来了时间开销,实用性也较差,只适合离线算法。
    • 如图所示,表示的是三元组 ( u , v , w ) (u, v, w) (u,v,w) 的数组, i d x idx idx 代表数组下标。
      在这里插入图片描述
    • 那么用哪种数据结构才能满足所有图的需求呢?
    • 接下来介绍一种新的数据结构 —— 链式前向星。

    4)链式前向星

    • 链式前向星和邻接表类似,也是链式结构和数组结构的结合,每个结点 i i i 都有一个链表,链表的所有数据是从 i i i 出发的所有边的集合(对比邻接表存的是顶点集合),边的表示为一个四元组 ( u , v , w , n e x t ) (u, v, w, next) (u,v,w,next),其中 ( u , v ) (u, v) (u,v) 代表该条边的有向顶点对 u → v u \to v uv w w w 代表边上的权值, n e x t next next 指向下一条边。
    • 具体的,我们需要一个边的结构体数组 edge[maxm]maxm表示边的总数,所有边都存储在这个结构体数组中,并且用head[i]来指向 i i i 结点的第一条边。
    • 边的结构体声明如下:
    struct Edge {
        int u, v, w, next;
        Edge() {}
        Edge(int _u, int _v, int _w, int _next) :
            u(_u), v(_v), w(_w), next(_next) 
        {
        }
    }edge[maxm];
    
    • 初始化所有的head[i] = -1,当前边总数 edgeCount = 0
    • 每读入一条 u → v u \to v uv 的边,调用 addEdge(u, v, w),具体函数的实现如下:
    void addEdge(int u, int v, int w) {
        edge[edgeCount] = Edge(u, v, w, head[u]);
        head[u] = edgeCount++;
    }
    
    • 这个函数的含义是每加入一条边 ( u , v , w ) (u, v, w) (u,v,w),就在原有的链表结构的首部插入这条边,使得每次插入的时间复杂度为 O ( 1 ) O(1) O(1),所以链表的边的顺序和读入顺序正好是逆序的。这种结构在无论是稠密的还是稀疏的图上都有非常好的表现,空间上没有浪费,时间上也是最小开销。
    • 调用的时候只要通过head[i]就能访问到由 i i i 出发的第一条边的编号,通过编号到edge数组进行索引可以得到边的具体信息,然后根据这条边的next域可以得到第二条边的编号,以此类推,直到 next域为 -1 为止。
    for (int e = head[u]; ~e; e = edges[e].next) {
        int v = edges[e].v;
        ValueType w = edges[e].w;
        ...
    }
    
    • 文中的 ~e等价于 e != -1,是对e进行二进制取反的操作(-1 的的补码二进制全是 1,取反后变成全 0,这样就使得条件不满足跳出循环)。

    5️⃣简单算法的入门

    • 入门十大算法是 线性枚举、线性迭代、简单排序、二分枚举、双指针、差分法、位运算、贪心、分治递归、简单动态规划。
    • 对于这十大算法,我会逐步更新道这个专栏里面:《LeetCode算法全集》
    • 浓缩版可参考如下文章:《十大入门算法》

    🚊10、简单动态规划

    LeetCode 746. 使用最小花费爬楼梯

      数组的每个下标作为一个阶梯,第 i i i 个阶梯对应着一个非负数的体力花费值 c o s t [ i ] cost[i] cost[i](下标从 0 开始)。每当爬上一个阶梯,都要花费对应的体力值,一旦支付了相应的体力值,就可以选择 向上爬一个阶梯 或者 爬两个阶梯。求找出达到楼层顶部的最低花费。在开始时,可以选择从下标为 0 或 1 的元素作为初始阶梯。
      样例输入: c o s t = [ 1 , 99 , 1 , 1 , 1 , 99 , 1 , 1 , 99 , 1 ] cost = [1, 99, 1, 1, 1, 99, 1, 1, 99, 1] cost=[1,99,1,1,1,99,1,1,99,1]
      样例输出: 6 6 6
    如图所以,蓝色的代表消耗为 1 的楼梯,红色的代表消耗 99 的楼梯。

    a、思路分析

    • 令走到第 i i i 层的最小消耗为 f [ i ] f[i] f[i]
    • 假设当前的位置在 i i i 层楼梯,那么只可能从 i − 1 i-1 i1 层过来,或者 i − 2 i-2 i2 层过来;
    • 如果从 i − 1 i-1 i1 层过来,则需要消耗体力值: f [ i − 1 ] + c o s t [ i − 1 ] f[i-1] + cost[i-1] f[i1]+cost[i1]
    • 如果从 i − 2 i-2 i2 层过来,则需要消耗体力值: f [ i − 2 ] + c o s t [ i − 2 ] f[i-2] + cost[i-2] f[i2]+cost[i2]
    • 起点可以在第 0 或者 第 1 层,于是有状态转移方程:
    • f [ i ] = { 0 i = 0 , 1 min ⁡ ( f [ i − 1 ] + c o s t [ i − 1 ] , f [ i − 2 ] + c o s t [ i − 2 ] ) i > 1 f[i] = \begin{cases} 0 & i=0,1\\ \min ( f[i-1] + cost[i-1], f[i-2] + cost[i-2] ) & i > 1\end{cases} f[i]={0min(f[i1]+cost[i1],f[i2]+cost[i2])i=0,1i>1

    b. 时间复杂度

    • 状态数: O ( n ) O(n) O(n)
    • 状态转移: O ( 1 ) O(1) O(1)
    • 时间复杂度: O ( n ) O(n) O(n)

    c. 代码详解

    class Solution {
        int f[1100];                                                   // (1)
    public:
        int minCostClimbingStairs(vector<int>& cost) {
            f[0] = 0, f[1] = 0;                                        // (2)
            for(int i = 2; i <= cost.size(); ++i) {
                f[i] = min(f[i-1] + cost[i-1], f[i-2] + cost[i-2]);    // (3)
            }
            return f[cost.size()];
        }
    };
    
    • ( 1 ) (1) (1)f[i]代表到达第 i i i 层的消耗的最小体力值。
    • ( 2 ) (2) (2) 初始化;
    • ( 3 ) (3) (3) 状态转移;

    有没有发现,这个问题和斐波那契数列很像,只不过斐波那契数列是求和,这里是求最小值。


    6️⃣刷题顺序的建议

      然后介绍一下刷题顺序的问题,我们刷题的时候千万不要想着一步到位,一开始,没有刷满三百题,姿态放低,都把自己当成小白来处理。
      这里以刷 LeetCode 为例,我目前只刷了不到 50 题,所以我是小白。
      当我是小白时,我只刷入门题,也就是下面这几个专题。先把上面所有的题目刷完,在考虑下一步要做什么。

    👨‍👦1、入门算法

    种类链接
    算法算法入门
    数据结构数据结构入门
    数组字符串专题数组和字符串
    动态规划专题动态规划入门DP路径问题

      当入门的题刷完了,并且都能讲述出来自己刷题的过程以后,我们再来看初级的一些算法和简单的数据结构,简单的数据结构就是线性表了,包含:数组、字符串、链表、栈、队列 等等,即下面这些专题。

    👩‍👧‍👦2、初级算法

    种类链接
    算法初级算法
    栈和队列专题队列 & 栈

      上面的题刷完以后,其实已经算是基本入门了,然后就可以开始系统性的学习了。
      当然,基本如果真的到了这一步,说明你的确已经爱上了刷题了,那么我们可以尝试挑战一下 LeetCode 上的一些热门题,毕竟热门题才是现在面试的主流,能够有更好的结果,这样刷题的时候也会有更加强劲的动力不是吗!

    👩‍👩‍👧‍👦3、中级算法

    种类链接
    算法中极算法
    二叉树专题二叉树
    热门题热门题 TOP 100

    7️⃣系统学习算法和数据结构

    🚍1、进阶动态规划

    文章链接难度等级推荐阅读
    夜深人静写算法(二)- 动态规划入门★☆☆☆☆★★★★★
    夜深人静写算法(二十六)- 记忆化搜索★☆☆☆☆★★★★★
    夜深人静写算法(十九)- 背包总览★☆☆☆☆★★★★★
    夜深人静写算法(二十)- 最长单调子序列★☆☆☆☆★★★★★
    夜深人静写算法(二十一)- 最长公共子序列★☆☆☆☆★★★★★
    夜深人静写算法(二十二)- 最小编辑距离★★☆☆☆★★★★☆
    夜深人静写算法(十四)- 0/1 背包★☆☆☆☆★★★★☆
    夜深人静写算法(十五)- 完全背包★★☆☆☆★★★★☆
    夜深人静写算法(十六)- 多重背包★★☆☆☆★★★★☆
    夜深人静写算法(二十七)- 区间DP★★★☆☆★★★★☆
    夜深人静写算法(二十九)- 数位DP★★★☆☆★★★★★
    夜深人静写算法(十七)- 分组背包★★★☆☆★★★☆☆
    夜深人静写算法(十八)- 依赖背包★★★★☆★★☆☆☆
    夜深人静写算法(六)- RMQ★★★☆☆★★☆☆☆
    树形DP待更新
    组合博弈待更新
    组合计数DP待更新
    四边形不等式待更新
    状态压缩DP/TSP待更新
    斜率优化的动态规划待更新
    插头DP待更新

    🪐2、强劲图论搜索


    1、深度优先搜索

    文章链接难度等级推荐阅读
    夜深人静写算法(一)- 搜索入门★☆☆☆☆★★★☆☆
    夜深人静写算法(八)- 二分图最大匹配★★☆☆☆★★☆☆☆
    最大团待更新
    最小生成树待更新
    树的分治待更新
    迭代加深 IDA*待更新
    有向图强连通分量和2-sat待更新
    无向图割边割点待更新
    带权图的二分图匹配待更新
    哈密尔顿回路待更新
    最近公共祖先待更新
    欧拉回路圈套圈待更新
    最小费用最大流待更新
    最小树形图待更新

    2、广度优先搜索

    文章链接难度等级推荐阅读
    夜深人静写算法(十)- 单向广搜★★☆☆☆★★★★☆
    夜深人静写算法(二十三)- 最短路★★★☆☆★★★★☆
    夜深人静写算法(二十五)- 稳定婚姻★★☆☆☆★★☆☆☆
    夜深人静写算法(二十四)- 最短路径树★★★☆☆★☆☆☆☆
    K 短路待更新
    差分约束待更新
    拓扑排序待更新
    A*待更新
    双向广搜待更新
    最大流 最小割待更新

    0️⃣3、进阶初等数论

    文章链接难度等级推荐阅读
    夜深人静写算法(三)- 初等数论入门★★☆☆☆★★★★☆
    夜深人静写算法(三十)- 二分快速幂★☆☆☆☆★★★★★
    夜深人静写算法(三十一)- 欧拉函数★★★☆☆★★★★★
    夜深人静写算法(三十二)- 费马小定理★★☆☆☆★★★☆☆
    夜深人静写算法(三十三)- 扩展欧拉定理★★★☆☆★★★★☆
    夜深人静写算法(三十四)- 逆元★★★☆☆★★★★☆
    夜深人静写算法(三十五)- RSA 加密解密★★★☆☆★★★★★
    夜深人静写算法(三十六)- 中国剩余定理★★☆☆☆★★★☆☆
    夜深人静写算法(三十七)- 威尔逊定理★★☆☆☆★★★☆☆
    夜深人静写算法(三十八)- 整数分块★★☆☆☆★★★★☆
    卢卡斯定理待更新
    狄利克雷卷积待更新
    莫比乌斯反演待更新
    容斥原理待更新
    拉宾米勒待更新
    Pollard rho待更新
    莫队待更新
    原根待更新
    大步小步算法待更新
    二次剩余待更新
    矩阵二分快速幂待更新
    Polya环形计数待更新

    🛑4、进阶计算几何

    📏5、字符串的匹配

    🎄6、高級数据结构


    🙉饭不食,水不饮,题必须刷🙉

    C语言免费动漫教程,和我一起打卡!
    🌞《光天化日学C语言》🌞

    LeetCode 太难?先看简单题!
    🧡《C语言入门100例》🧡

    数据结构难?不存在的!
    🌳《画解数据结构》🌳

    LeetCode 太简单?算法学起来!
    🌌《夜深人静写算法》🌌

    展开全文
  • 什么构造

    千次阅读 2016-09-30 11:49:59
    构造器的功能和作用的不同 构造器是为了创建一个类的实例。这个过程也可以在创建一个对象的时候用到:Platypus p1 = new Platypus(); 相反,方法的作用是为了执行java代码。 修饰符,返回值和命名的不同 构造器和...

    构造器的功能和作用的不同
    构造器是为了创建一个类的实例。这个过程也可以在创建一个对象的时候用到:Platypus p1 = new Platypus();

    相反,方法的作用是为了执行java代码。

    修饰符,返回值和命名的不同
    构造器和方法在下面三个方便的区别:修饰符,返回值,命名。和方法一样,构造器可以有任何访问的修饰: public, protected, private或者没有修饰(通常被package 和 friendly调用). 不同于方法的是,构造器不能有以下非访问性质的修饰: abstract, final, native, static, 或者 synchronized。

    返回类型也是非常重要的。方法能返回任何类型的值或者无返回值(void),构造器没有返回值,也不需要void。

    最后,谈谈两者的命名。构造器使用和类相同的名字,而方法则不同。按照习惯,方法通常用小写字母开始,而构造器通常用大写字母开始。构造器通常是一个名词,因为它和类名相同;而方法通常更接近动词,因为它说明一个操作。

    “this”的用法
    构造器和方法使用关键字this有很大的区别。方法引用this指向正在执行方法的类的实例。静态方法不能使用this关键字,因为静态方法不属于类的实例,所以this也就没有什么东西去指向。构造器的this指向同一个类中,不同参数列表的另外一个构造器,我们看看下面的代码:

    public class Platypus {

    String name;

    Platypus(String input) {
    name = input;
    }

    Platypus() {
    this(“John/Mary Doe”);
    }

    public static void main(String args[]) {
    Platypus p1 = new Platypus(“digger”);
    Platypus p2 = new Platypus();
    }
    }

    在上面的代码中,有2个不同参数列表的构造器。第一个构造器,给类的成员name赋值,第二个构造器,调用第一个构造器,给成员变量name一个初始值 “John/Mary Doe”.

    在构造器中,如果要使用关键字this,那么,必须放在第一行,如果不这样,将导致一个编译错误。

    “super”的用法
    构造器和方法,都用关键字super指向超类,但是用的方法不一样。方法用这个关键字去执行被重载的超类中的方法。看下面的例子:

    class Mammal {
    void getBirthInfo() {
    System.out.println(“born alive.”);
    }
    }

    class Platypus extends Mammal {
    void getBirthInfo() {
    System.out.println(“hatch from eggs”);
    System.out.print(“a mammal normally is “);
    super.getBirthInfo();
    }
    }

    在上面的例子中,使用super.getBirthInfo()去调用超类Mammal中被重载的方法。

    构造器使用super去调用超类中的构造器。而且这行代码必须放在第一行,否则编译将出错。看下面的例子:

    public class SuperClassDemo {
    SuperClassDemo() {}
    }

    class Child extends SuperClassDemo {
    Child() {
    super();
    }
    }

    在上面这个没有什么实际意义的例子中,构造器 Child()包含了 super,它的作用就是将超类中的构造器SuperClassDemo实例化,并加到 Child类中。

    编译器自动加入代码
    编译器自动加入代码到构造器,对于这个,java程序员新手可能比较混淆。当我们写一个没有构造器的类,编译的时候,编译器会自动加上一个不带参数的构造器,例如:public class Example {}
    编译后将如下代码:

    public class Example {
    Example() {}
    }

    在构造器的第一行,没有使用super,那么编译器也会自动加上,例如:

    public class TestConstructors {
    TestConstructors() {}
    }

    编译器会加上代码,如下:

    public class TestConstructors {
    TestConstructors() {
    super;
    }
    }

    仔细想一下,就知道下面的代码

    public class Example {}

    经过会被编译器加代码形如:

    public class Example {
    Example() {
    super;
    }
    }

    继承

    构造器是不能被继承的。子类可以继承超类的任何方法。看看下面的代码:

    public class Example {
    public void sayHi {
    system.out.println(“Hi”);
    }

    Example() {}
    }

    public class SubClass extends Example {
    }

    类 SubClass 自动继承了父类中的sayHi方法,但是,父类中的构造器 Example()却不能被继承。

    总结 :
    构造方法是一种特殊的方法,与一般的方法不同是:
    1.构造方法的名字必须与定义他的类名完全相同,没有返回类型,甚至连void也没有。
    2.构造方法的调用是在创建一个对象时使用new操作进行的。构造方法的作用是初始化对象。
    3.不能被static、final、synchronized、abstract和native修饰。
    构造方法不能被子类继承。 构造方法可以被重载。
    没有参数的构造方法称为默认构造方法,
    与一般的方法一样,构造方法可以进行任何活动,但是经常将他设计为进行各种初始化活动,
    比如初始化对象的属性。
    在Java中,任何变量在被使用前都必须先设置初值.
    Java提供了为类的成员变量赋初值的专门功能:构造方法(constructor)构造方法是一种特殊的成员方法,
    它的特殊性反映在如下几个方面:
    (1)构造方法名与类名相同.
    (2)构造方法不返回任何值,也没有返回类型.
    (3)每个类可以有零个或多个构造方法.
    (4)构造方法在创建对象时自动执行,一般不能显式地直接调用.

    展开全文
  • 套接地址结构

    千次阅读 2014-01-06 17:09:48
    大多数套接函数都需要一个指向套接地址结构的指针作为参数,每个协议族都定义了它自己的套接地址结构。这些结构的名字均以sockaddr_开头,并以对应每个协议地址族的唯一后缀结尾。 IPv4套接地址结构 IPv4...
  • 结构是一种非常常见的数据结构,并且在很场景下也被用到。其实栈结构跟数组结构很像,只是在数组的基础...数据结构——栈一、什么是栈二、栈结构的方法三、用代码实现一个栈结构(1)创建一个构造函数(2)实现push
  • 单链表详解一、前言二、什么是链表?2.1、链表的概念:2.2、两种重要的单链表2.3、关于单链表的一些基础知识三、单链表的实现3.1、穷举法创建一个简单的链表3.2、遍历链表3.3、得到链表的长度3.4、头插法3.5、尾插法...
  • OCR(文字识别)技术是目前常用的一种AI能力。但一般OCR的识别结果是一种按行输出的半...本课程从百度自定义模板文字识别展开,从理论到案例,详细介绍OCR结构化的相关技术,并理清OCR和结构化之间的关系和适用场景。
  • 套接和套接地址结构定义

    千次阅读 2010-03-01 10:16:00
    套接和套接地址结构定义这段主程序是一段典型的服务器程序。网络通讯最重要的就是套接的使用,在程序的一开始就对套接描述符sockfd和newsockfd进行了定义。接下来定义客户机/服务器的套接地址结构cliaddr...
  • 什么是默认构造函数?

    千次阅读 多人点赞 2017-05-29 01:04:40
    对于C++默认构造函数,我曾经有两点误解: 类如果没有定义任何的构造函数,那么编译器(一定会!)将为类定义一个合成的默认构造函数。 合成默认构造函数会初始化类中所有的数据成员。 第一个误解来自于我学习C++的第...
  • 套接究竟是什么

    千次阅读 2012-05-31 21:25:13
    书上说的端口是数据结构和I/O缓存区”是指硬件端口,网络编程里的端口可以理解为应用程序的ID。 说得形象点,套接就类似我们人类的门 我们打开门,通过门外面的人可以进来 我们推开门,里面的人也可以出去 ...
  • 而用ctrl+鼠标滚轮只能放大或是缩小行间距,对文字没有什么变化。 解决办法如下: 1.打开文档结构图(点击视图,勾选文档结构图) 文档结构图如下图所示 2.点击开始菜单上的样式后面的斜下箭头 ...
  • 单体多字系统以及体并行系统

    千次阅读 2018-01-02 22:59:33
    单体多字系统以及体并行系统
  • 数据结构:八大数据结构分类

    万次阅读 多人点赞 2018-09-05 18:23:28
    数据结构分类 数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中...数组是可以再内存中连续存储个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问,数组下标从0开始...
  • 套接&套接地址结构和bind()函数

    千次阅读 2015-08-03 22:35:38
    我们都知道在网络编程中,可以调用socket()函数来获取一个套接描述符。但是,socket()函数的作用只是返回一个很小的非负整数值吗?并非如此,socket()函数的作用是创建套接的。 创建套接的流程如下 ...
  • 上一篇文章讲解了链表的相关知识,并用代码实现了一个链表结构。那么本文将介绍一下另一种特殊的链表结构,叫做 双向链表。 顾名思义,普通的链表都是从 head 开始往后遍历...数据结构——双向链表一、什么是双向链表二
  • ARM体系结构中字、半、字节介绍

    千次阅读 2012-11-27 20:39:20
    在开始之前首先对(Word)、半(Half-Word)、字节(Byte)的概念作一个说明:  (在计算机中数据都是以二进制的形式存储的,以下的位是指二进制数中的"位"。例如10转化为二进制是1010是四位的)  首先我们学习的...
  • 数据结构——优先级队列一、什么是优先级队列 一、什么是优先级队列 在了解了什么是队列以后,我们再来了解优先级队列,顾名思义,优先级队列就是在队列的基础上给每个元素加上了先后顺序,我们仍然拿排队买票的例子...
  • WORD的文档结构图字体的显示太小的解决 ...不知怎么回事,每次调用WORD的文档结构图,结构图字体的显示比例总要变为32%,很小,根本就无法看清,于是借助网络寻求解决问题的办法,次反复之后,终于
  • 服务器创建套接accept等待连接,这时候可能已经创建了套接对应的缓冲区bufferAccept  客户端connect请求连接并发送数据包,可能已经创建了bufferConnect  服务器这边网卡收到数据后放入内存,一步步被送给...
  • 论文摘要要多少字合适

    万次阅读 2016-04-21 10:43:23
     论文摘要不要列举例证,不讲研究过程,不用图表,不给化学结构式,也不要作自我评价。  撰写论文摘要的常见毛病,一是照搬论文正文中的小标题(目录)或论文结论部分的文字;二是内容不浓缩、不概括,文字篇幅过...
  • 课程分为两部分 第一部分:《计算机体系结构》 分为4篇,硬件篇、软件篇、网络篇、IT行业篇 第二部分:具体的嵌入式技术课程 内容包括,c基础、c、Linux基础/、Linux系统编程和网络编程、8051单片、STM32单片、Arm...
  • 【红黑树】  红黑树(Red Black Tree) 是一种自平衡二叉查找树,是在计算机科学中用到的一种数据结构,典型的用途是实现关键数组。
  • 位(Bit):"位(bit)"是电子计算机中最小的数据单位。每一位的状态只能是0或1。...:""由若干个字节构成,的位数叫做字长,不同档次的机器有不同的字长。例如一台8位机,它的1个就等于1个字节,字长为8
  • 结构化数据与非结构化数据有什么区别?

    万次阅读 多人点赞 2019-08-08 10:53:28
    结构化数据和非结构化数据是大数据的两种类型,这两者之间并不存在真正的冲突。客户如何选择不是基于数据结构,而是基于...非结构化数据分析是一个新兴的行业,在研发方面有很新的投资,但不是一项成熟的技术。了...
  • 某机为定长指令字结构,指令长度16位;......

    万次阅读 多人点赞 2018-09-21 17:27:41
    题目:某机为定长指令字结构,指令长度16位;每个操作数的地址码长6 位,指令分为无操作数、单操作数和双操作数三类。若双操作数指令已有K 种,无操作数指令已有L种,问单操作数指令最多可能有多少种? 上述三...
  • 本文十天后设置为粉丝可见,喜欢的提前关注 不要白嫖请点赞 不要白嫖请点赞 不要白嫖请点赞 文中提到的书我都有电子版,可以评论邮箱发给你。 ...文中提到的书我都有电子版,可以评论邮箱...数据结构是计算机存储、...
  • 视图---> 文档结构图 ---> 左侧
  • 从Jdk 7开始,可以在数值型面值(包括整型面值和浮点面值)插入一个或者个下划线。例如:int x = 123_456_789;在编译的时候,下划线会自动去掉。但是下划线只能用于分隔数字,不能分隔字符与字符,也不能...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,106,458
精华内容 842,583
关键字:

多少的多是什么结构的字