精华内容
下载资源
问答
  • 我觉得互联网技术天生具有开放和共享的基因,全球最大中文社区CSDN开设了知识图谱专栏,为互联网从业者和爱好者提供了知识共创平台。这些年以来,“生态”词早已家喻户晓,在互联网领域,一些事物开始只是某个...

    我觉得互联网技术天生具有开放和共享的基因,全球最大中文社区CSDN开设了知识图谱专栏,为互联网从业者和爱好者提供了一个知识共创平台。这些年以来,“生态”一词早已家喻户晓,在互联网领域,一些事物开始只是某个具体场景下定制的实际应用,但随着知识的不断开放、共享和共创,这些事物逐渐发展壮大,并最终形成了自己的生态系统。

    下面罗列技术领域来自CSDN知识图谱平台,自百度百科和互联网博客,而这些也只是互联网技术领域的冰山一角,大量的知识领域还在不断的创新和发展。来看看下列知识技能自己了解或掌握几个:

    1.Andriod

    Android是一个基于Linux内核的移动操作系统,由Google成立的Open Handset Alliance(OHA,开放手持设备联盟)持续领导与开发,主要设计用于触控荧幕移动设备如智能手机和平板电脑。

    知识库地址:http://lib.csdn.net/base/android


    2.React.js

    React是一个Facebook和Instagram用来创建用户界面的JavaScript库,用于构建“可预期的”和“声明式的”Web用户界面。 该框架的推出主要为了开发随着时间数据不断变化的大规模应用程序。

    知识库地址:http://lib.csdn.net/base/react



    3.人工智能基础

    人工智能(Artificial Intelligence),英文缩写为AI。它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。

    知识库地址:http://lib.csdn.net/base/ai



    4.Java

    Java中动态Web资源开发技术统称为Java Web。其最大用途就是Web应用的开发,可以不用考虑系统平台的差异,在一种系统下开发的应用系统,不加任何修改就能运行在另一种不同的系统中。

    知识库地址:http://lib.csdn.net/base/java



    5.Java EE

    Java EE,全称Java 2 Platform Enterprise Edition。该平台使用分布式多层应用模型来创建企业级应用,主要用来开发“分布式应用”以及“互联网应用” 。

    知识库地址:http://lib.csdn.net/base/javaee



    6.计算机视觉

    通过对采集的图片或视频进行处理以获得相应场景的三维信息,是使用计算机及相关设备对生物视觉的一种模拟,研究相关的理论和技术,试图建立能够从图像或者多维数据中获取‘信息’的人工智能系统。

    知识库地址:http://lib.csdn.net/base/computervison


    7.Objective-C

    Objective-C是扩充C的面向对象编程语言。它主要使用于Mac OS X和GNUstep这两个使用OpenStep标准的系统,而在NeXTSTEP和OpenStep中它更是基本语言。

    知识库地址:http://lib.csdn.net/base/objective-c



    8.知识工程

    人工智能的原理和方法,专家知识才能解决的应用难题求解手段

    知识库地址:http://lib.csdn.net/base/knowledgeengineering



    9.人工智能规划与决策

    专家系统,自动规划和推理机制

    知识库地址:http://lib.csdn.net/base/aiplanning


    10.Mesos

    Mesos是Apache下的开源分布式资源管理框架,它被称为是分布式系统的内核。Mesos最初是由加州大学伯克利分校的AMPLab开发的,后在Twitter得到广泛使用。Twitter从Google的Borg系统中得到启发,然后就开发一个类似的资源管理系统来帮助他们摆脱可怕的“失败之鲸”。后来他们注意到加州大学伯克利分校AMPLab正在开发的名为Mesos的项目,这个项目的负责人是Ben Hindman,Ben是加州大学伯克利分校的博士研究生。后来Ben Hindman加入了Twitter,负责开发和部署Mesos。现在Mesos管理着Twitter超过30,0000台服务器上的应用部署,“失败之鲸”已成往事。其他公司纷至沓来,也部署了Mesos,比如Airbnb(空中食宿网)、eBay(电子港湾)和Netflix。

    知识库地址:


    11.机器翻译

    利用计算机将一种自然语言(源语言)转换为另一种自然语言(目标语言)的过程。它是计算语言学的一个分支,涉及计算机、认知科学、语言学、信息论等学科,是人工智能的终极目标之一

    知识库地址:http://lib.csdn.net/base/machinetranslation


    12.人工智能机器学习

    人工智能的核心,是使计算机具有智能的根本途径,其应用遍及人工智能的各个领域,它主要使用归纳、综合而不是演绎

    知识库地址:http://lib.csdn.net/base/aimachinelearning


    13.人工智能开发框架

    流行的各种人工智能开发框架相关技术汇总

    知识库地址:http://lib.csdn.net/base/aiframework


    14.推荐系统

    协同过滤常常被用于分辨某位特定顾客可能感兴趣的东西。推荐系统是利用 电子商务网站向客户提供商品信息和建议,帮助用户决定应该购买什么产品,模拟销售人员帮助客户完成购买过程。个性化推荐是根据用户的兴趣特点和购买行为,向用户推荐用户感兴趣的信息和商品。随着电子商务规模的不断扩大,商品个数和种类快速增长,顾客需要花费大量的时间才能找到自己想买的商品。这种浏览大量无关的信息和产品过程无疑会使淹没在信息过载问题中的消费者不断流失。为了解决这些问题,个性化推荐系统应运而生。个性化推荐系统是建立在海量数据挖掘基础上的一种高级商务智能平台,以帮助电子商务网站为其顾客购物提供完全个性化的决策支持和信息服务。

    知识库地址:


    15.机器人

    人工智能技术制定,自动执行工作的机器装置

    知识库地址:http://lib.csdn.net/base/robot


    16.智能传感器

    实现自动检测、信息输出和自动控制的检测装置。智能传感器(intelligent sensor)是具有信息处理功能的传感器。智能传感器带有微处理机,具有采集、处理、交换信息的能力,是传感器集成化与微处理机相结合的产物。与一般传感器相比,智能传感器具有以下三个优点:通过软件技术可实现高精度的信息采集,而且成本低;具有一定的编程自动化能力;功能多样化。

    知识库地址:


    17.物联网传输技术

    通信模组和定位模组,物联网传输技术相关知识集合

    知识库地址:


    18.Bootstrap

    Bootstrap,来自 Twitter,是目前很受欢迎的前端框架。Bootstrap 是基于 HTML、CSS、JAVASCRIPT 的,它简洁灵活,使得 Web 开发更加快捷。它由Twitter的设计师Mark Otto和Jacob Thornton合作开发,是一个CSS/HTML框架。Bootstrap提供了优雅的HTML和CSS规范,它即是由动态CSS语言Less写成。Bootstrap一经推出后颇受欢迎,一直是GitHub上的热门开源项目,包括NASA的MSNBC(微软全国广播公司)的Breaking News都使用了该项目。国内一些移动开发者较为熟悉的框架,如WeX5前端开源框架等,也是基于Bootstrap源码进行性能优化而来。

    知识库地址:


    19.计算机网络

    计算机网络系统,即利用通信设备和线路将地理位置不同、功能独立的多个计算机系统互联起来,以功能完善的网络软件实现网络中资源共享和信息传递的系统,它是计算机基础知识的重要分支。

    知识库地址:http://lib.csdn.net/base/computernetworks



    20.Netty

    Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具,用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说,Netty 是一个基于NIO的客户、服务器端编程框架,使用Netty 可以确保你快速和简单的开发出一个网络应用,例如实现了某种协议的客户,服务端应用。Netty相当简化和流线化了网络应用的编程开发过程,例如,TCP和UDP的socket服务开发。“快速”和“简单”并不用产生维护性或性能上的问题。Netty 是一个吸收了多种协议的实现经验,这些协议包括FTP,SMTP,HTTP,各种二进制,文本协议,并经过相当精心设计的项目,最终,Netty 成功的找到了一种方式,在保证易于开发的同时还保证了其应用的性能,稳定性和伸缩性。

    知识库地址:


    21.Git

    Git是一款免费、开源的分布式版本控制系统,用于敏捷高效地处理任何或小或大的项目。与常用的版本控制工具 CVS、Subversion等不同,它采用了分布式版本库的方式,不必服务器端软件支持。

    知识库地址:http://lib.csdn.net/base/git



    22.机器学习

    机器学习是研究计算机怎样模拟或实现人类的学习行为,以获取新的知识或技能,重新组织已有的知识结构使之不断改善自身的性能。它是人工智能的核心,是使计算机具有智能的根本途径。

    知识库地址:http://lib.csdn.net/base/machinelearning



    23.flink

    很多人可能都是在 2015 年才听到 Flink 这个词,其实早在 2008 年,Flink 的前身已经是柏林理工大学一个研究性项目, 在 2014 被 Apache 孵化器所接受,然后迅速地成为了 ASF(Apache Software Foundation)的顶级项目之一。Flink 的最新版本目前已经更新到了 0.10.0 了,在很多人感慨 Spark 的快速发展的同时,或许我们也该为 Flink 的发展速度点个赞。Flink 是一个针对流数据和批数据的分布式处理引擎。它主要是由 Java 代码实现。目前主要还是依靠开源社区的贡献而发展。对 Flink 而言,其所要处理的主要场景就是流数据,批数据只是流数据的一个极限特例而已。再换句话说,Flink 会把所有任务当成流来处理,这也是其最大的特点。Flink 可以支持本地的快速迭代,以及一些环形的迭代任务。并且 Flink 可以定制化内存管理。在这点,如果要对比 Flink 和 Spark 的话,Flink 并没有将内存完全交给应用层。这也是为什么 Spark 相对于 Flink,更容易出现 OOM 的原因(out of memory)。就框架本身与应用场景来说,Flink 更相似与 Storm。

    知识库地址:


    24.Lisp

    因应人工智能而生,LISP是一种通用高级计算机程序语言,长期以来垄断人工智能领域的应用。LISP作为因应人工智能而设计的语言,是第一个声明式系内函数式程序设计语言,有别于命令式系内过程式的C、Fortran和面向对象的Java、C#等结构化程序设计语言。LISP名称源自列表处理(LISt Processing)的英语缩写,由来自麻省理工学院的人工智能研究先驱约翰·麦卡锡(John McCarthy)在1958年基于λ演算所创造,采用抽象数据列表与递归作符号演算来衍生人工智能。

    知识库地址:

    25.Lua

    Lua是一个小巧的脚本语言。是巴西里约热内卢天主教大学(Pontifical Catholic University of Rio de Janeiro)里的一个研究小组,由Roberto Ierusalimschy、Waldemar Celes 和 Luiz Henrique de Figueiredo所组成并于1993年开发。 其设计目的是为了嵌入应用程序中,从而为应用程序提供灵活的扩展和定制功能。Lua由标准C编写而成,几乎在所有操作系统和平台上都可以编译,运行。Lua并没有提供强大的库,这是由它的定位决定的。所以Lua不适合作为开发独立应用程序的语言。Lua 有一个同时进行的JIT项目,提供在特定平台上的即时编译功能。

    Lua脚本可以很容易的被C/C++ 代码调用,也可以反过来调用C/C++的函数,这使得Lua在应用程序中可以被广泛应用。不仅仅作为扩展脚本,也可以作为普通的配置文件,代替XML,ini等文件格式,并且更容易理解和维护。 Lua由标准C编写而成,代码简洁优美,几乎在所有操作系统和平台上都可以编译,运行。  一个完整的Lua解释器不过200k,在目前所有脚本引擎中,Lua的速度是最快的。这一切都决定了Lua是作为嵌入式脚本的最佳选择。

    知识库地址:


    26.语音识别与合成

    将人类的语音中的词汇内容转换为计算机可读的输入,包括语音拨号、语音导航、室内设备控制、语音文档检索、简单的听写数据录入等,其他自然语言处理技术如机器翻译及语音合成技术相结合,可以构建出更加复杂的应用。

    知识库地址:http://lib.csdn.net/base/vras


    27.React Native

    React Native是一款基于JavaScript框架React.js来开发iOS和Android原生App的开源框架,着力于提高多平台开发的开发效率——仅需学习一次,编写任何平台。(Learn once,write anywhere)

    知识库地址:http://lib.csdn.net/base/reactnative



    28.智能芯片

    智能芯片的分类有很多,按照用途的不同,分类也会不同。智能芯片一般与感应系统以及动力传动系统一起作用,相互弥补。发挥各自的优势。一般智能芯片就相当于一个单片机,负责处理收集到的感应信号,再通过电器开关驱动电力马达,将指令传递给传动系统来完成初始要达到的效果。

    知识库地址:


    29.Kylin

    Kylin操作系统是国家高技术研究发展计划(863计划)的重大成果之一,是以国防科技大学为主导,与中软、联想等单位联合设计和开发的具有完全自主版权,可支持多种微处理器和多种计算机体系结构,具有高性能、高可用性和高安全性,并与Linux应用二进制兼容的国产中文服务器操作系统。

    知识库地址:


    30.物联网应用开发平台

    从1999年Kevin Ashton第一次提出这个概念以来,物联网已经经历了迅速的转变。随着近年来连接到物联网的设备在多样性和数量方面出现指数式的增长,物联网已经成为了一种主流技术,在推动现在社会的生活方式方面有着极大的潜力。在物联网的技术与工程上,硬件与软件平台之间目前仍有明确的界限,其中大多数供应商都将精力放在硬件方面。只有极少数供应商提供物联网软件服务:例如,Mattermark根据所获总投资排名的前100名物联网创业公司中,只有13家提供物联网软件服务。

    知识库地址:


    31.物联网系统集成应用服务

    物联网是各终端、各种软件整合互联互动的最终产物,随着国家不断深化智慧城市的推广建设,完善物联网应用的配套设施和技术,物联网背后的市场产值大得不可估量。目前,物联网里单独应用的产品已逐渐减少,越来越多的是通过系统集成,建立产品与软件的大范围应用。

    知识库地址:


    32.JavaScript

    JavaScript是一种属于网络的脚本语言,已经被广泛用于Web应用开发,常用来为网页添加各式各样的动态功能,为用户提供更流畅美观的浏览效果。

    知识库地址:http://lib.csdn.net/base/javascript



    33.PHP

    PHP是一种通用开源脚本语言,语法吸收了C、Java和Perl的特点,利于学习,使用广泛,主要适用于Web开发领域。它支持几乎所有流行的数据库以及操作系统,并可使用C、C++进行程序扩展。

    知识库地址:http://lib.csdn.net/base/php



    34.物理网应用智能终端

    物联网终端是物联网中连接传感网络层和传输网络层,实现采集数据及向网络层发送数据的设备。它担负着数据采集、初步处理、加密、传输等多种功能。物联网各类终端设备总体上可以分为情景感知层、网络接入层、网络控制层以及应用/业务层。每一层都与网络侧的控制设备有着对应关系。物联网终端常常处于各种异构网络环境中,为了向用户提供最佳的使用体验,终端应当具有感知场景变化的能力,并以此为基础,通过优化判决,为用户选择最佳的服务通道。终端设备通过前端的RF模块或传感器模块等感知环境的变化,经过计算,决策需要采取的应对措施。

    知识库地址:


    35.jQuery

    jQuery为一个兼容多浏览器的JavaScript库。它免费、开源,使用MIT许可协议。其语法设计可使开发更加便捷,提供API让开发者可编写插件。利用它,开发者可轻松开发出功能强大的静态或动态网页。

    知识库地址:http://lib.csdn.net/base/jquery



    36.算法与数据结构

    数据结构是计算机存储、组织数据的方式,精心选择的数据结构可以带来更高的运行或者存储效率。算法是一系列解决问题的清晰指令,代表着用系统的方法描述解决问题的策略机制。两者均是研发工作的基础。

    知识库地址:http://lib.csdn.net/base/datastructure



    37.C#

    C#为由C和C++衍生出来的面向对象的编程语言。其综合了VB简单的可视化操作和C++的高运行效率,凭借强大的操作能力、优雅的语法风格、便捷的对面向组件编程的支持,成为了.NET开发的首选语言。

    知识库地址:http://lib.csdn.net/base/csharp



    38.Unity3D

    Unity3D是一个可以让玩家轻松创建诸如三维视频游戏、建筑可视化、实时三维动画等类型互动内容的多平台的综合型游戏开发工具,是一个全面整合的专业游戏引擎。

    知识库地址:http://lib.csdn.net/base/unity3d



    39.MongoDB

    MongoDB是由C++语言编写的分布式存储数据库,旨在为Web应用提供可扩展的高性能数据存储解决方案。是一个介于关系数据库和非关系数据库之间的产品,是非关系数据库当中功能最丰富,最像关系数据库的。

    知识库地址:http://lib.csdn.net/base/mongodb



    40.Hbase

    HBase – Hadoop Database,是一个高可靠性、高性能、面向列、可伸缩的分布式存储系统,利用HBase技术可在廉价PC Server上搭建起大规模结构化存储集群。

    知识库地址:http://lib.csdn.net/base/hbase



    41.大型网站结构

     一个成熟的大型网站(如淘宝、京东等)的系统架构并不是开始设计就具备完整的高性能、高可用、安全等特性,它总是随着用户量的增加,业务功能的扩展逐渐演变完善的,在这个过程中,开发模式、技术架构、设计思想也发生了很大的变化,就连技术人员也从几个人发展到一个部门甚至一条产品线。所以成熟的系统架构是随业务扩展而完善出来的,并不是一蹴而就;不同业务特征的系统,会有各自的侧重点,例如淘宝,要解决海量的商品信息的搜索、下单、支付,例如腾讯,要解决数亿的用户实时消息传输,百度它要处理海量的搜索请求,他们都有各自的业务特性,系统架构也有所不同。剖析大型网站技术架构模式,深入讲述大型互联网架构设计的核心原理,全面介绍大型网站架构需要的方方面面知识/技术。

    知识库地址:http://lib.csdn.net/base/architecture



    42.Bluemix

    Bluemix是一种开放式标准的云平台,用于构建、运行和管理应用程序与服务。它建立在Apache开源项目Cloud Foundry之上,并提供了IBM及其合作伙伴开发的高质量的服务供IT从业人员使用。

    知识库地址:http://lib.csdn.net/base/bluemix



    43.搜索引擎

    搜索引擎(Search Engine)是指根据一定的策略、运用特定的计算机程序从互联网上搜集信息,在对信息进行组织和处理后,为用户提供检索服务,将用户检索相关的信息展示给用户的系统。搜索引擎包括全文索引、目录索引、元搜索引擎、垂直搜索引擎、集合式搜索引擎、门户搜索引擎与免费链接列表等。一个搜索引擎由搜索器 、索引器 、检索器 和用户接口 四个部分组成。搜索器的功能是在互联网 中漫游,发现和搜集信息。索引器的功能是理解搜索器所搜索的信息,从中抽取出索引项,用于表示文档 以及生成文档库的索引表。检索器的功能是根据用户的查询在索引库中快速检出文档,进行文档与查询的相关度评价,对将要输出的结果进行排序,并实现某种用户相关性反馈机制。用户接口的作用是输入用户查询、显示查询结果、提供用户相关性反馈机制。

    知识库地址:http://lib.csdn.net/base/searchengine


    44.计算广告

    计算广告学是一门正在兴起的分支学科,它涉及到大规模搜索和文本分析、信息获取、统计模型、机器学习、分类、优化以及微观经济学。计算广告学所面临的最主要挑战是在特定语境下特定用户和相应的广告之间找到“最佳匹配”。语境可以是用户在搜索引擎中输入的查询词,也可以是用户正在读的网页,还可以是用户正在看的电影,等等。而用户相关的信息可能非常多也可能非常少。潜在广告的数量可能达到几十亿。因此,取决于对“最佳匹配”的定义,面临的挑战可能导致在复杂约束条件下的大规模优化和搜索问题。2008年,第十九届ACM-SIAM学术讨论会上,雅虎研究院资深研究员Andrei Broder首次提出了计算广告学(ComputationalAdvertising)的概念,他认为,计算广告学是一门由信息科学、统计学、计算机科学以及微观经济学等学科交叉融合的新兴分支学科。Andrei Broder只是提出了计算广告学的研究目标——实现语境、广告和受众三者的最佳匹配,并没有从学术的角度给计算广告学一个严谨的界定。 计算广告学作为一门新兴学科,在继承传统广告学核心理论的同时,为了应对科学技术发展带来的新问题和新观念,将计算主义理论和方法应用到广告学研究。计算主义认为,“整个世界都是由算法控制,并按算法所规定的规则演化的。宇宙是一部巨型的计算装置,任何自然事件都是在自然规律作用下的计算过程。现实世界事物的多样性只不过是算法的复杂程度不同的外部表现。”正如伽利略所言:“自然界这本大书是用数学语言所写”。如今,计算的方法已经渗透到宇宙学、物理学、生物学、经济学乃至社会科学等诸多领域。计算已经成为人们认识自然、生命、思维和社会的一种普适的观念和方法。而计算广告学其实质就是研究如何利用计算的方法求解广告活动中各类问题的一门学科。计算广告学是一门广告营销科学,以追求广告投放的综合收益最大化为目标,重点解决用户与广告匹配的相关性和广告的竞价模型的问题。计算广告学涉及到自然语言处理、数据挖掘以及竞价营销、创意设计等诸多学科的融合。对于用户而言存在商务搜索广告、浏览页面投放广告、社区人群广告等多种形式。

    知识库地址:http://lib.csdn.net/base/%E8%AE%A1%E7%AE%97%E5%B9%BF%E5%91%8A


    45.深度学习

    深度学习的概念源于人工神经网络的研究,含多隐层的多层感知器就是一种深度学习结构。它是机器学习研究的一个新领域,模仿人脑机制来解释数据。

    知识库地址:http://lib.csdn.net/base/deeplearning



    46.虚拟现实VR

    虚拟现实(VR,Virtual Reality)是一种可创建和体验虚拟世界的计算机系统。它综合利用计算机图形系统和各种现实及控制等接口设备,在计算机上生成的、可交互的三维环境中提供沉浸感觉的技术。

    知识库地址:http://lib.csdn.net/base/vr



    47.OpenCV

    OpenCV为基于BSD许可(开源)发行的跨平台计算机视觉库,可运行在Linux、Windows和Mac OS上。它轻量级而且高效,提供了Python、Ruby、MATLAB等语言接口,实现了图像处理和计算机视觉方面的很多通用算法。

    知识库地址:http://lib.csdn.net/base/opencv



    48.Scala

    Scala是一种多范式编程语言。它继承了多种语言中的优秀特性,它既支持面向对象的编程方式,也支持函数式编程。它运行在Java虚拟机上,轻松实现和丰富的Java类库互联互通。

    知识库地址:http://lib.csdn.net/base/scala



    49.AngularJS

    AngularJS是一款优秀的前端JS框架,已被用于Google的多款产品当中。该框架有着诸多特性,最为核心的是:MVVM、模块化、自动化双向数据绑定、语义化标签、依赖注入等等。

    知识库地址:http://lib.csdn.net/base/angularjs



    50.Python

    Python是一种面向对象、解释型计算机程序设计语言,语法简洁清晰,具有丰富和强大的库。在设计上坚持清晰划一风格,使得它成为一门易读、易维护,并且被大量用户所欢迎的、用途广泛的语言。

    知识库地址:http://lib.csdn.net/base/python



    51.NodeJS

    Node.js为基于Chrome JavaScript运行时建立的平台, 可用于搭建响应速度快、易于扩展的网络应用。它使用事件驱动,非阻塞I/O模型而得以轻量和高效,非常适合在分布式设备上运行的数据密集型的实时应用。

    知识库地址:http://lib.csdn.net/base/nodejs



    52.HTML5

    HTML5是HTML最新修订版本,2014年10月由万维网联盟(W3C)完成标准制定。其设计目的是为了在移动设备上支持多媒体。它简单易学,且增加了很多有趣新特性。

    知识库地址:http://lib.csdn.net/base/html5




    53.CSS3

    CSS3是最新的CSS标准,该标准是朝着模块化发展的,以前的规范作为一个模块实在是太庞大而且比较复杂,所以,把它分解为一些小的模块,更多新的模块也被加入进来。

    知识库地址:http://lib.csdn.net/base/css3



    54.嵌入式开发

    嵌入式系统开发,即对于除了电脑之外的所有电子设备上操作系统的开发,开发对象有手机、掌上电脑、机电系统等。常用嵌入式系统包括WinCE、Linux、Android等,编程语言可采用C、C++或汇编语言。

    知识库地址:http://lib.csdn.net/base/embeddeddevelopment



    55.Cocos引擎

    Cocos引擎是由触控科技推出的游戏开发一站式解决方案,包含了从新建立项、游戏制作、到 打包上线的全套流程。开发者可以通过Cocos快速生成代码、编辑资源和动画,最终输出适合于多个平台的游戏产品。

    知识库地址:http://lib.csdn.net/base/cocos



    56.微信开发

    微信开发即微信公众平台开发,将企业信息、服务、活动等通过微信网页的方式表现。开发者利用微信开放的技术接口可进行二次开发,将公众账号由一个媒体型营销工具转化成提供服务的产品。

    知识库地址:http://lib.csdn.net/base/wechat



    57.Kubernetes

    Kubernetes作为Docker生态圈中重要一员,是Google多年大规模容器管理技术的开源版本,是产线实践经验的最佳表现。其提供应用部署、维护、 扩展机制等功能,利用Kubernetes能方便地管理跨机器运行容器化的应用,其主要功能如下:
    1) 使用Docker对应用程序包装(package)、实例化(instantiate)、运行(run)。
    2) 以集群的方式运行、管理跨机器的容器。
    3) 解决Docker跨机器容器之间的通讯问题。
    4) Kubernetes的自我修复机制使得容器集群总是运行在用户期望的状态。
    当前Kubernetes支持GCE、vShpere、CoreOS、OpenShift、Azure等平台,除此之外,也可以直接运行在物理机上。

    知识库地址:


    58.Kafka

    Kafka是一种高吞吐量的分布式发布订阅消息系统,它可以处理消费者规模的网站中的所有动作流数据。 这种动作(网页浏览,搜索和其他用户的行动)是在现代网络上的许多社会功能的一个关键因素。 这些数据通常是由于吞吐量的要求而通过处理日志和日志聚合来解决。 对于像Hadoop的一样的日志数据和离线分析系统,但又要求实时处理的限制,这是一个可行的解决方案。Kafka的目的是通过Hadoop的并行加载机制来统一线上和离线的消息处理,也是为了通过集群来提供实时的消费。

    知识库地址:


    59.VMWare

    VMware(中文名威睿”,纽约证券交易所“代码:VMW) 虚拟机软件,是全球桌面到数据中心虚拟化解决方案的领导厂商。全球不同规模的客户依靠VMware来降低成本和运营费用、确保业务持续性、加强安全性并走向绿色。2008年,VMware年收入达到19亿美元,拥有逾150,000的用户和接近22,000多家合作伙伴,是增长最快的上市软件公司之一。VMware总部设在加利福尼亚州的帕罗奥多市(Palo Alto)。

    VMware在虚拟化和云计算基础架构领域处于全球领先地位,所提供的经客户验证的解决方案可通过降低复杂性以及更灵活、敏捷地交付服务来提高IT效率。VMware使企业可以采用能够解决其独有业务难题的云计算模式。VMware提供的方法可在保留现有投资并提高安全性和控制力的同时,加快向云计算的过度。 VMware拥有 400,000多家客户和55,000多家合作伙伴,它的解决方案可帮助各种规模的组织降低成本、提高业务灵活性并确保选择自由。

    知识库地址:


    60.Hyper-V

    Hyper-V是微软的一款虚拟化产品,是微软第一个采用类似Vmware和Citrix开源Xen一样的基于hypervisor的技术。这也意味着微软会更加直接地与市场先行者VMware展开竞争,但竞争的方式会有所不同。
    Hyper-V是微软提出的一种系统管理程序虚拟化技术,能够实现桌面虚拟化。Hyper-V最初预定在2008年第一季度,与Windows Server 2008同时发布。Hyper-V Server 2012完成RTM版发布。

    知识库地址:


    61.Docker

    Docker是一个开源、可以将任何应用包装在"LXC容器”中运行的工具。如果说VMware、KVM包装的虚拟机,那该工具包装的则是应用。它是一个实至名归的PaaS。

    知识库地址:http://lib.csdn.net/base/docker



    62.软件测试

    软件测试是在规定条件下对程序进行操作,以发现程序错误,衡量软件质量,并对其是否能满足设计要求进行评估的过程。它是帮助识别开发完成的计算机软件的正确度、完全度和质量的软件过程。是SQA的重要子域。

    知识库地址:http://lib.csdn.net/base/softwaretest



    63.微服务

    微服务架构是一种特定的软件应用程序设计方式——将大型软件拆分为多个独立可部署服务组合而成的套件方案,其中各项服务都拥有自己的进程并利用轻量化机制(通常为HTTP源API)实现通信。

    知识库地址:http://lib.csdn.net/base/microservice



    64.操作系统

    操作系统是管理和控制计算机硬件与软件资源的计算机程序,是直接运行在“裸机”上的最基本的系统软件,任何其他软件都必须在操作系统的支持下才能运行。

    知识库地址:http://lib.csdn.net/base/operatingsystem



    65.C++

    C++是在C语言基础上开发出的一种面向对象编程语言。其编程领域众广,常用于系统开发,引擎开发等应用领域,是至今为止最受广大程序员受用的最强大编程语言之一。

    知识库地址:http://lib.csdn.net/base/cplusplus



    66.C

    C语言是一门通用计算机编程语言,应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。

    知识库地址:http://lib.csdn.net/base/c



    67.PostgreSQL

    PostgreSQL是以加州大学伯克利分校计算机系开发的 POSTGRES,现在已经更名为PostgreSQL,版本 4.2为基础的对象关系型数据库管理系统(ORDBMS)。PostgreSQL支持大部分 SQL标准并且提供了许多其他现代特性:复杂查询、外键、触发器、视图、事务完整性、MVCC。同样,PostgreSQL 可以用许多方法扩展,比如, 通过增加新的数据类型、函数、操作符、聚集函数、索引。免费使用、修改、和分发 PostgreSQL,不管是私用、商用、还是学术研究使用。

    知识库地址:


    68.SQL Server

    SQL Server 是Microsoft 公司推出的关系型数据库管理系统。具有使用方便可伸缩性好与相关软件集成程度高等优点,可跨越从运行Microsoft Windows 98 的膝上型电脑到运行Microsoft Windows 2012 的大型多处理器的服务器等多种平台使用。
    Microsoft SQL Server 是一个全面的数据库平台,使用集成的商业智能 (BI)工具提供了企业级的数据管理。Microsoft SQL Server 数据库引擎为关系型数据和结构化数据提供了更安全可靠的存储功能,使您可以构建和管理用于业务的高可用和高性能的数据应用程序。

    知识库地址:


    69.无人驾驶

    依靠车内的以计算机系统为主的智能系统实现车辆自动驾驶

    知识库地址:http://lib.csdn.net/base/autonomous


    70.自然语言理解和处理

    实现人与计算机之间用自然语言进行有效通信的各种理论和方法

    知识库地址:http://lib.csdn.net/base/nlp


    71.Apache Spark

    Spark是当前最流行的开源大数据内存计算框架,用Scala语言实现,由UC伯克利大学AMPLab实验室开发并于2010年开源。以通用、易用为目标,高速发展后成为最活跃的Apache开源项目。

    知识库地址:http://lib.csdn.net/base/spark



    72.Hive

    Hive是基于Hadoop的一个数据仓库工具,可以将结构化的数据文件映射为一张数据库表,并提供简单的sql查询功能,可以将sql语句转换为MapReduce任务进行运行。

    知识库地址:http://lib.csdn.net/base/hive



    73.区块链

    区块链(Blockchain):比特币背后的技术,无需中心服务器,可实现各类存储数据公开、透明、可追溯。

    知识库地址:http://lib.csdn.net/base/blockchain



    74.Redis

    Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库,并提供多种语言的API。其特点是高性能、持久存储,适应高并发的应用场景。

    知识库地址:http://lib.csdn.net/base/redis



    75.Oracle

    Oracle Database简称Oracle,是甲骨文公司的一款关系型数据库管理系统。具有系统可移植性好、使用方便、功能强等特点,适用于各类大、中、小、微机环境。

    知识库地址:http://lib.csdn.net/base/oracle



    76.Go

    Go是Google开发的一种编译型,可并行化,并具有垃圾回收功能的编程语言,并且它还是开源的。使用Go编译的程序可以媲美C或C++代码的速度,而且更加安全、支持并行进程。

    知识库地址:http://lib.csdn.net/base/go



    77..NET

    NET Framework是微软用于Windows的新托管代码编程模型,是一个 Microsoft Windows 组件,用户可通过各种分发渠道获得它。

    知识库地址:http://lib.csdn.net/base/dotnet



    78.Rust

    Rust是Mozilla公司推出的一门全新的编程语言,并希望成为一门系统编程语言,运行性能高、避免几乎所有的段错误和保证线程安全。这意味着该语言可以用于建造高效可靠的系统。

    知识库地址:http://lib.csdn.net/base/rust



    79.信息无障碍

    信息无障碍,即任何人在任何情况下都能平等的、方便地、无障碍地获取、利用信息。其包括两个主要范畴:电子和信息技术无障碍及网络无障碍,并遵循国际标准。WCAG2.0。信息无障碍是我国信息化发展规划中的重要组成部分,也是我国社会主义现代化建设事业进程中的主要内容,大力推进信息无障碍事业的发展、为广大残疾人无障碍地获取信息服务、使广大残障人士能够平等地参与到社会活动中来,既是新时期社会发展进步的具体体现,也是弘扬人道主义精神、保障残疾人合法权益,享受现代文明生活的内在要求。目前信息无障碍建设在基础理论研究、标准化研究、社会推广、产品制造、社会基础信息建设和专用服务提供等六个不同的方面取得了初步成效,并且其中很多成果都是针对国内用户的实际需求展开的,初步为今后实施有中国特色的信息无障碍推广工作奠定了基础。

    知识库地址:http://lib.csdn.net/base/accessibility



    80.Linux

    Linux是一个免费的,基于POSIX和Unix的多用户、多任务、支持多线程和多CPU的操作系统。它支持32位和64位硬件,且继承了Unix以网络为核心的设计思想,是一个性能稳定的多用户网络操作系统。

    知识库地址:http://lib.csdn.net/base/linux



    81.MySQL

    MySQL是最流行的关系型数据库管理系统,在Web应用方面是最好的RDBMS应用软件之一,作为开放源码软件,可大大降低总体拥有成本。因其社区版的性能卓越,搭配PHP和Apache可组成良好的开发环境。

    知识库地址:http://lib.csdn.net/base/mysql



    82.Hadoop

    Hadoop是一个由Apache基金会所开发的分布式系统基础架构。用户可在不了解分布式底层细节的情况下,开发分布式程序。充分利用集群的威力进行高速运算和存储。

    知识库地址:http://lib.csdn.net/base/hadoop



    83.OpenStack

    OpenStack是一个由NASA和Rackspace合作研发并发起的,以Apache许可证授权的自由软件和开放源代码项目。OpenStack是一个开源的云计算管理平台项目,由几个主要的组件组合起来完成具体工作。OpenStack支持几乎所有类型的云环境,项目目标是提供实施简单、可大规模扩展、丰富、标准统一的云计算管理平台。OpenStack通过各种互补的服务提供了基础设施即服务(IaaS)的解决方案,每个服务提供API以进行集成。OpenStack覆盖了网络、虚拟化、操作系统、服务器等各个方面。它是一个正在开发中的云计算平台项目,根据成熟及重要程度的不同,被分解成核心项目、孵化项目,以及支持项目和相关项目。每个项目都有自己的委员会和项目技术主管,而且每个项目都不是一成不变的,孵化项目可以根据发展的成熟度和重要性,转变为核心项目。

    知识库地址:http://lib.csdn.net/base/openstack



    84.IOS

    iOS是由苹果公司开发的移动操作系统。原名叫iPhone OS,因为iPad,iPhone,iPod touch都使用iPhone OS,所以2010WWDC大会上宣布改名为iOS。

    知识库地址:http://lib.csdn.net/base/ios



    85.直播技术

    中国已在2016年进入直播时代,这种成本低廉、互动性高、部署便捷、稳定可靠的方式,最初局限于游戏直播和在线聊天,而现在泛生活类、娱乐类直播开始逐渐流行。

    知识库地址:http://lib.csdn.net/base/liveplay


    86.敏捷

    敏捷是以用户的需求进化为核心,采用迭代、循序渐进的方法进行软件开发、管理。它是针对传统的瀑布开发模式的弊端而产生的一种新的模式,目标是提高生产效率和响应能力。

    知识库地址:http://lib.csdn.net/base/agile



    87.Swift

    Swift是一门新的编程语言,用于编写iOS和OS X应用程序。它结合了C和Objective-C的优点并且不受C兼容性的限制。它使用安全的编程模式并添加了很多新特性,使编程更简单,扩展性更强更有趣。

    知识库地址:http://lib.csdn.net/base/swift



    88.BI商业智能

    BI(Business Intelligence)即商务智能,它是一套完整的解决方案,用来将企业中现有的数据进行有效的整合,快速准确地提供报表并提出决策依据,帮助企业做出明智的业务经营决策。

    商业智能的概念最早在1996年提出。当时将商业智能定义为一类由数据仓库(或数据集市)、查询报表、数据分析、数据挖掘、数据备份和恢复等部分组成的、以帮助企业决策为目的技术及其应用。而这些数据可能来自企业的CRM、SCM等业务系统。
    商业智能能够辅助的业务经营决策,既可以是操作层的,也可以是战术层和战略层的决策。为了将数据转化为知识,需要利用数据仓库、联机分析处理(OLAP)工具和数据挖掘等技术。因此,从技术层面上讲,商业智能不是什么新技术,它只是数据仓库、OLAP和数据挖掘等技术的综合运用。

    知识库地址:


    89.Saas

    SaaS是Software-as-a-Service(软件即服务)的简称,随着互联网技术的发展和应用软件的成熟, 在21世纪开始兴起的一种完全创新的软件应用模式。它与“on-demand software”(按需软件),the application service provider(ASP,应用服务提供商),hosted software(托管软件)所具有相似的含义。它是一种通过Internet提供软件的模式,厂商将应用软件统一部署在自己的服务器上,客户可以根据自己实际需求,通过互联网向厂商定购所需的应用软件服务,按定购的服务多少和时间长短向厂商支付费用,并通过互联网获得厂商提供的服务。用户不用再购买软件,而改用向提供商租用基于Web的软件,来管理企业经营活动,且无需对软件进行维护,服务提供商会全权管理和维护软件,软件厂商在向客户提供互联网应用的同时,也提供软件的离线操作和本地数据存储,让用户随时随地都可以使用其定购的软件和服务。对于许多小型企业来说,SaaS是采用先进技术的最好途径,它消除了企业购买、构建和维护基础设施和应用程序的需要。
    SaaS 应用软件的价格通常为“全包”费用,囊括了通常的应用软件许可证费、软件维护费以及技术支持费,将其统一为每个用户的月度租用费。 对于广大中小型企业来说,SaaS是采用先进技术实施信息化的最好途径。但SaaS绝不仅仅适用于中小型企业,所有规模的企业都可以从SaaS中获利。

    知识库地址:


    90.PaaS

    PaaS是Platform-as-a-Service的缩写,意思是平台即服务。 把服务器平台作为一种服务提供的商业模式。通过网络进行程序提供的服务称之为SaaS(Software as a Service),而云计算时代相应的服务器平台或者开发环境作为服务进行提供就成为了PaaS(Platform as a Service)。
    所谓PaaS实际上是指将软件研发的平台(计世资讯定义为业务基础平台)作为一种服务,以SaaS的模式提交给用户。因此,PaaS也是SaaS模式的一种应用。但是,PaaS的出现可以加快SaaS的发展,尤其是加快SaaS应用的开发速度。在2007年国内外SaaS厂商先后推出自己的PAAS平台。

    知识库地址:


    91.IaaS

    IaaS(Infrastructure as a Service),即基础设施即服务。提供给消费者的服务是对所有计算基础设施的利用,包括处理CPU、内存、存储、网络和其它基本的计算资源,用户能够部署和运行任意软件,包括操作系统和应用程序。消费者不管理或控制任何云计算基础设施,但能控制操作系统的选择、存储空间、部署的应用,也有可能获得有限制的网络组件(例如路由器、,防火墙,、负载均衡器等)的控制。

    知识库地址:


    92.ext.js

    ExtJS是一个用javascript写的,主要用于创建前端用户界面,是业界最强大的桌面应用程序开发平台,无与伦比的跨浏览器兼容性,先进的MVC架构,无插件图表,和现代的UI部件。

    知识库地址:


    93.Ruby

    Ruby,一种简单快捷的面向对象(面向对象程序设计)脚本语言,在20世纪90年代由日本人松本行弘(Yukihiro Matsumoto)开发,遵守GPL协议和Ruby License。它的灵感与特性来自于 Perl、Smalltalk、Eiffel、Ada以及 Lisp 语言。由 Ruby 语言本身还发展出了JRuby(Java平台)、IronRuby(.NET平台)等其他平台的 Ruby 语言替代品。Ruby的作者于1993年2月24日开始编写Ruby,直至1995年12月才正式公开发布于fj(新闻组)。因为Perl发音与6月诞生石pearl(珍珠)相同,因此Ruby以7月诞生石ruby(红宝石)命名。

    知识库地址:


    95.R语言

    R是用于统计分析、绘图的语言和操作环境。R是属于GNU系统的一个自由、免费、源代码开放的软件,它是一个用于统计计算和统计制图的优秀工具。

    知识库地址:


    96.Storm

    Storm是Twitter开源的分布式实时大数据处理框架,最早开源于github,从0.9.1版本之后,归于Apache社区,被业界称为实时版Hadoop。随着越来越多的场景对Hadoop的MapReduce高延迟无法容忍,比如网站统计、推荐系统、预警系统、金融系统(高频交易、股票)等等,大数据实时处理解决方案(流计算)的应用日趋广泛,目前已是分布式技术领域最新爆发点,而Storm更是流计算技术中的佼佼者和主流。

    知识库地址:


    97.erlang

    Erlang(['ə:læŋ])是一种通用的面向并发的编程语言,它由瑞典电信设备制造商爱立信所辖的CS-Lab开发,目的是创造一种可以应对大规模并发活动的编程语言和运行环境。Erlang问世于1987年,经过十年的发展,于1998年发布开源版本。Erlang是运行于虚拟机的解释性语言,但是现在也包含有乌普萨拉大学高性能Erlang计划(HiPE)开发的本地代码编译器,自R11B-4版本开始,Erlang也开始支持脚本式解释器。在编程范型上,Erlang属于多重范型编程语言,涵盖函数式、并发式及分布式。顺序执行的Erlang是一个及早求值, 单次赋值和动态类型的函数式编程语言。

    知识库地址:


    如若以上知识介绍存在不准确的地方,大家可在评论区留言,共同完善知识体系。

    展开全文
  • 数据结构知识整理

    万次阅读 多人点赞 2018-07-30 18:50:47
    章:绪论 1.数据结构:是一门研究非数值计算的程序设计问题中计算机的操作对象以及他们之间的关系和操作等的学科。 2.数据结构涵盖的内容: 3.基本概念和术语: 数据:对客观事物的符号表示,在计算机科学...

    基于严蔚敏及吴伟民编著的清华大学C语言版教材并结合网上相关资料整理(http://www.docin.com/p-2027739005.html)

    第一章:绪论

    1.数据结构:是一门研究非数值计算的程序设计问题中计算机的操作对象以及他们之间的关系和操作等的学科。

    2.数据结构涵盖的内容:

    3.基本概念和术语:

    数据:对客观事物的符号表示,在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。

    数据元素:数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理。

    数据对象:性质相同的数据元素的集合,是数据的一个子集。

    数据结构:相互之间存在一种或多种特定关系的数据元素的集合。

    数据类型:一个值的集合和定义在这个值集上的一组操作的总称。

    4.算法和算法分析

    1)算法是对特定问题求解步骤的一种描述,它是指令的有限序列,其中每一条指令表示一个或多个操作。

    算法五个特性:有穷性,确定性,可行性,输入,输出。

    2)算法设计要求:正确性,可读性,健壮性,效率与低存储量需求。

    3)算法分析:时间复杂度,空间复杂度,稳定性

     

    第二章:线性表

    1.线性结构特点:在数据元素的非空有限集合中,(1)存在唯一的一个被称做“第一个”的数据元素;(2)存在唯一的一个被称做“最后一个”的数据元素;(3)除第一个之外,集合中的每个数据元素均只有一个前驱;(4)除最后一个之外,集合中每个数据元素均只有一个后继。

    2.线性表定义:有限个性质相同的数据元素组成的序列。

    3.线性表的存储结构:顺序存储结构和链式存储结构

    顺序存储定义:把逻辑上相邻的数据元素存储在物理上相邻的存储单元中的存储结构。

    通常用数组来描述数据结构中的顺序存储结构。

    链式存储结构: 其结点在存储器中的位置是随意的,即逻辑上相邻的数据元素在物理上不一定相邻。通过指针来实现。

    数据结构的基本运算:修改、插入、删除、查找、排序

    4.线性表的顺序表示和实现

    1)修改:通过数组的下标便可访问某个特定元素并修改。

    时间复杂度O(1)

    2) 插入:在线性表的第i个位置前插入一个元素

    实现步骤:

       ①将第n至第i 位的元素逐一向后移动一个位置;

       ②将要插入的元素写到第i个位置;

       ③表长加1。

       注意:事先应判断: 插入位置i 是否合法?表是否已满?

       应当符合条件: 1≤i≤n+1  或  i=[1, n+1]

       核心语句:

    for (j=n; j>=i; j--)

    a[j+1]=a[ j ]; 

    a[ i ]=x;   

    n++;

      插入时的平均移动次数为:n(n+1)/2÷(n+1)=n/2≈O(n)

    3)删除:删除线性表的第i个位置上的元素

      实现步骤:

      ①将第i+1 至第n 位的元素向前移动一个位置;

      ②表长减1。

      注意:事先需要判断,删除位置i 是否合法?

      应当符合条件:1≤i≤n  或  i=[1, n]

      核心语句:

    {

        for ( j=i+1; j<=n; j++ )

        a[j-1]=a[j]; 

        n--;

    }

      顺序表删除一元素的时间效率为:T(n)=(n-1)/2 O(n)

      顺序表插入、删除算法的平均空间复杂度为O(1)

    5.线性表的链式表示和实现

    线性链表:用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的)。

    一个数据元素称为一个结点,包括两个域:存储数据元素信息的域称为数据域;存储直接后继存储位置的域称为指针域。指针域中存储的信息称作指针或链。

    由于链表的每个结点中只包含一个指针域,故线性链表又称为单链表。

    1)单链表的修改(或读取)

    思路:要修改第i个数据元素,必须从头指针起一直找到该结点的指针preturn p;  

    然后才能:p->data=new_value

    读取第i个数据元素的核心语句是:

    Linklist *find(Linklist *head ,int i)

    { 

       int j=1;

       Linklist *p;

       P=head->next;

       While((p!=NULL)&&(j<i))

       {

           p=p->next;

           j++;

        }

    }

    2)单链表的插入

    链表插入的核心语句:

    Step 1:s->next=p->next;

    Step 2:p->next=s;

    3)单链表的删除

    删除动作的核心语句(要借助辅助指针变量q):

    q = p->next;           //首先保存b的指针,靠它才能找到c;

    p->next=q->next;  //将a、c两结点相连,淘汰b结点;

    free(q) ;               //彻底释放b结点空间

    4)双向链表的插入操作

    设p已指向第i 元素,请在第 i 元素前插入元素 x:

    ① ai-1的后继从 ai ( 指针是p)变为 x(指针是s) :

                    s->next = p  ;   p->prior->next = s ;

    ② ai  的前驱从ai-1 ( 指针是p->prior)变为 x ( 指针是s);

                    s->prior = p ->prior ; p->prior = s ;

    5)双向链表的删除操作

    设p指向第i 个元素,删除第 i 个 元素

    后继方向:ai-1的后继由ai ( 指针p)变为ai+1(指针 p ->next );

                       p ->prior->next =  p->next  ;

    前驱方向:ai+1的前驱由ai ( 指针p)变为ai-1 (指针 p -> prior );

                     p->next->prior = p ->prior ;

    6.循环链表

    循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点,整个链表形成一个环。

    循环链表的操作和线性链表基本一致,差别仅在于算法中的循环条件不是p或p->next是否为空,而是它们是否等于头指针。

    学习重点:

    • 线性表的逻辑结构,指线性表的数据元素间存在着线性关系。在顺序存储结构中,元素存储的先后位置反映出这种线性关系,而在链式存储结构中,是靠指针来反映这种关系的。

    • 顺序存储结构用一维数组表示,给定下标,可以存取相应元素,属于随机存取的存储结构。

    • 链表操作中应注意不要使链意外“断开”。因此,若在某结点前插入一个元素,或删除某元素,必须知道该元素的前驱结点的指针。

    • 掌握通过画出结点图来进行链表(单链表、循环链表等)的生成、插入、删除、遍历等操作。

    • 数组(主要是二维)在以行序/列序为主的存储中的地址计算方法。

    补充重点:

    • 每个存储结点都包含两部分:数据域和指针域(链域)

    • 在单链表中,除了首元结点外,任一结点的存储位置由 其直接前驱结点的链域的值 指示。

    • 在链表中设置头结点有什么好处?

        头结点即在链表的首元结点之前附设的一个结点,该结点的数据域可以为空,也可存放表长度等附加信息,其作用是为了对链表进行操作时,可以对空表、非空表的情况以及对首元结点进行统一处理,编程更方便。

    • 如何表示空表?

    (1)无头结点时,当头指针的值为空时表示空表;

    (2)有头结点时,当头结点的指针域为空时表示空表。

    • 链表的数据元素有两个域,不再是简单数据类型,编程时该如何表示?

     因每个结点至少有两个分量,且数据类型通常不一致,所以要采用结构数据类型。

    • sizeof(x)——  计算变量x的长度(字节数);

              malloc(m) —  开辟m字节长度的地址空间,并返回这段空间的首地址;

              free(p)   —— 释放指针p所指变量的存储空间,即彻底删除一个变量。

    • 链表的运算效率分析:

    (1)查找 

    因线性链表只能顺序存取,即在查找时要从头指针找起,查找的时间复杂度为 O(n)。

    (2) 插入和删除 

    因线性链表不需要移动元素,只要修改指针,一般情况下时间复杂度为 O(1)。

    但是,如果要在单链表中进行前插或删除操作,因为要从头查找前驱结点,所耗时间复杂度将是 O(n)。

    例:在n个结点的单链表中要删除已知结点*P,需找到它的前驱结点的地址,其时间复杂度为 O(n)

    • 顺序存储和链式存储的区别和优缺点?

        顺序存储时,逻辑上相邻的数据元素,其物理存放地址也相邻。顺序存储的优点是存储密度大,存储空间利用率高;缺点是插入或删除元素时不方便。

      链式存储时,相邻数据元素可随意存放,但所占存储空间分两部分,一部分存放结点值,另一部分存放表示结点间关系的指针。链式存储的优点是插入或删除元素时很方便,使用灵活。缺点是存储密度小,存储空间利用率低。

    • 顺序表适宜于做查找这样的静态操作;

    • 链表宜于做插入、删除这样的动态操作。

    • 若线性表的长度变化不大,且其主要操作是查找,则采用顺序表;

    • 若线性表的长度变化较大,且其主要操作是插入、删除操作,则采用链表。

    ① 数组中各元素具有统一的类型;

    ② 数组元素的下标一般具有固定的上界和下界,即数组一旦被定义,它的维数和维界就不再改变。

    ③数组的基本操作比较简单,除了结构的初始化和销毁之外,只有存取元素和修改元素值的操作。

    • 三元素组表中的每个结点对应于稀疏矩阵的一个非零元素,它包含有三个数据项,分别表示该元素的 行下标  、列下标 和 元素值 。

    第三章:栈和队列

    1.栈:限定仅在表尾进行插入或删除操作的线性表。

    栈的基本操作:在栈顶进行插入或删除,栈的初始化、判空及取栈顶元素等。

    入栈口诀:堆栈指针top “先压后加”

    出栈口诀:堆栈指针top “先减后弹”

    top=0表示空栈。

     

    2.栈的表示和实现

         1)构造一个空栈S

        Status InitStack(SqStack &S)

        {

            S.base = (SElemType *) malloc(STACK_INIT_SIZE * sizeof(SElemType));

            if(!S.base) exit (OVERFLOW); //存储分配失败

                S.top = S.base;

                S.stacksize = STACK_INIT_SIZE;

                return OK;

        }

     

        2)返回栈顶元素

           Status GetTop(SqStack S, SElemType e) 

            {//若栈不空,则用e返回S的栈顶元素,并返回OK,否则返回ERROR

                if(S.top == S.base) return ERROR;

                e = *(S.top-1);

                return OK; 

            }//GetTop

     

        3)顺序栈入栈函数PUSH()

    Status Push(SqStack &S, SElemType e)

    { //插入元素e为新的栈顶元素

        if(S.top-S.base>=S.stacksize)//栈满,追加存储空间

       {

        s.base = (SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));

        if(!S.base) exit(OVERFLOW);//存储分配失败

        S.top = S.base + S.stacksize;

        S.stacksize += STACKINCREMENT;

        }

        *S.top++ =e;

        return OK:

    }//PUSH

    4)顺序栈出栈函数POP()

    status Pop( SqStack &S,SElemType &e)

    { //若栈不空,则删除S的栈顶元素,用e返回其值,并返回OK,否则返回ERROR

        if(S.top == S.base) return ERROR; 

        e=* —S.top;

        return OK;

            }

    3.栈的应用

    数制转换,括号匹配的检验,行编辑程序,迷宫求解,表达式求值,递归实现。

    4.队列:是一种先进先出的线性表,它只允许在表的一端进行插入,而在另一端删除元素。

    允许插入的一端叫做队尾,允许删除的一端叫做队头。

    除了栈和队列外,还有一种限定性数据结构是双端队列。双端队列是限定插入和删除操作在表的两端进行的线性表。

    5.链队列结点类型定义:

     typedef Struct QNode{

         QElemType        data;     //元素

         Struct   QNode   *next;  //指向下一结点的指针

       }Qnode , * QueuePtr ;

    链队列类型定义:

     typedef  struct {

      QueuePtr     front ; //队首指针

      QueuePtr     rear ; //队尾指针

      }  LinkQueue;

    链队示意图:

    ①  空链队的特征:front=rear

    ②  链队会满吗?一般不会,因为删除时有free动作。除非内存不足!

    ③  入队(尾部插入):rear->next=S; rear=S;

        出队(头部删除):front->next=p->next;

    6.顺序队

    顺序队类型定义:

    #define    QUEUE-MAXSIZE  100  //最大队列长度

         typedef    struct {

                QElemType     *base;    //队列的基址

                 int                    front;     //队首指针

                 int                     rear;    //队尾指针

           }SqQueue

    建队核心语句:

    q.base=(QElemType *)malloc(sizeof (QElemType)* QUEUE_MAXSIZE);       //分配空间

    顺序队示意图:

    7.循环队列:

    队空条件 :  front = rear       (初始化时:front = rear )

    队满条件: front = (rear+1) % N         (N=maxsize)

    队列长度(即数据元素个数):L=(N+rear-front)% N

    1)初始化一个空队列

    Status   InitQueue ( SqQueue  &q ) //初始化空循环队列 q

    {   

    q.base=(QElemType *)malloc(sizeof(QElemType)* QUEUE_MAXSIZE);   //分配空间

    if (!q.base)  exit(OVERFLOW);//内存分配失败,退出程序

       q.front =q.rear=0; //置空队列

        return OK;

     } //InitQueue;

     

    2)入队操作

    Status   EnQueue(SqQueue  &q,  QElemType e)

    {//向循环队列 q 的队尾加入一个元素 e

       if ( (q.rear+1) %  QUEUE_MAXSIZE ==  q.front)

                        return  ERROR ; //队满则上溢,无法再入队

            q.rear = ( q.rear + 1 ) %  QUEUE_MAXSIZE;

            q.base [q.rear] = e;    //新元素e入队

            return  OK;

     }// EnQueue;

     

    3)出队操作

    Status     DeQueue ( SqQueue  &q,    QElemType &e)

     {//若队列不空,删除循环队列q的队头元素,

            //由 e 返回其值,并返回OK

          if ( q.front = = q.rear )   return ERROR;//队列空

          q.front=(q.front+1) % QUEUE_MAXSIZE; 

          e = q.base [ q.front ] ;

         return OK;

        }// DeQueue

    • 链队列空的条件是首尾指针相等,而循环队列满的条件的判定,则有队尾加1等于队头和设标记两种方法。

    补充重点:

    1. 为什么要设计堆栈?它有什么独特用途?

    2. 什么叫“假溢出” ?如何解决?

     调用函数或子程序非它莫属;

     递归运算的有力工具;

     用于保护现场和恢复现场;

     简化了程序设计的问题。                         

    2.为什么要设计队列?它有什么独特用途?

     离散事件的模拟(模拟事件发生的先后顺序,例如 CPU芯片中的指令译码队列);

     操作系统中的作业调度(一个CPU执行多个作业);

     简化程序设计。

    答:在顺序队中,当尾指针已经到了数组的上界,不能再有入队操作,但其实数组中还有空位置,这就叫“假溢出”。解决假溢出的途径———采用循环队列。

    4.在一个循环队列中,若约定队首指针指向队首元素的前一个位置。那么,从循环队列中删除一个元素时,其操作是先 移动队首位置 ,后 取出元素

    5.线性表、栈、队的异同点:

    相同点:逻辑结构相同,都是线性的;都可以用顺序存储或链表存储;栈和队列是两种特殊的线性表,即受限的线性表(只是对插入、删除运算加以限制)。

    不同点:① 运算规则不同:

    线性表为随机存取;

    而栈是只允许在一端进行插入和删除运算,因而是后进先出表LIFO

    队列是只允许在一端进行插入、另一端进行删除运算,因而是先进先出表FIFO

     用途不同,线性表比较通用;堆栈用于函数调用、递归和简化设计等;队列用于离散事件模拟、OS作业调度和简化设计等。

     

    第四章:串

    1.串是数据元素为字符的线性表,串的定义及操作。

    串即字符串,是由零个或多个字符组成的有限序列,是数据元素为单个字符的特殊线性表。

    串比较:int strcmp(char *s1,char *s2);            

    求串长:int strlen(char *s);                          

    串连接:char  strcat(char *to,char *from)   

    子串T定位:char strchr(char *s,char *c);

    2.串的存储结构,因串是数据元素为字符的线性表,所以存在“结点大小”的问题。

    模式匹配算法 

    串有三种机内表示方法:

     

    3.模式匹配算法 :

    算法目的:确定主串中所含子串第一次出现的位置(定位)

    定位问题称为串的模式匹配,典型函数为Index(S,T,pos)

    BF算法的实现—即编写Index(S, T, pos)函数

    BF算法设计思想:

    将主串S的第pos个字符和模式T的第1个字符比较,

    若相等,继续逐个比较后续字符;

    若不等,从主串S的下一字符(pos+1)起,重新与T第一个字符比较。 

    直到主串S的一个连续子串字符序列与模式T相等。返回值为S中与T匹配的子序列第一个字符的序号,即匹配成功。

    否则,匹配失败,返回值 0。

    Int Index_BP(SString S, SString T, int pos)

    { //返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数值为0.

     // 其中,T非空,1≤pos≤StrLength(S)

        i=pos;      j=1;

       while ( i<=S[0] && j<=T[0] ) //如果i,j二指针在正常长度范围,

         {  

           if (S[i] = = T[j] ) {++i, ++j; }   //则继续比较后续字符

           else {i=i-j+2; j=1;} //若不相等,指针后退重新开始匹配

          }

      if(j>T[0]) return i-T[0];  //T子串指针j正常到尾,说明匹配成功,  else return 0;        //否则属于i>S[0]情况,i先到尾就不正常

    } //Index_BP

    补充重点:

    1.空串和空白串有无区别?

    答:有区别。

    空串(Null String)是指长度为零的串;

    而空白串(Blank  String),是指包含一个或多个空白字符‘  ’(空格键)的字符串.

    2.“空串是任意串的子串;任意串S都是S本身的子串,除S本身外,S的其他子串称为S的真子串。”

     

    第五章:数组和广义表

    重点:二维数组的位置计算。

    矩阵的压缩存储:特殊矩阵(三角矩阵,对称矩阵),稀疏矩阵,

     

    第六章:树和二叉树

    1.树:是n(n≥0)个结点的有限集。(1)有且仅有一个特定的称为根(root)的结点;(2)当n>1时,其余的结点分为m(m≥0)个互不相交的有限集合T1,T2,…,Tm。每个集合本身又是棵树,被称作这个根的子树 。

    2.二叉树:是n(n≥0)个结点的有限集合,由一个根结点以及两棵互不相交的、分别称为左子树和右子树的二叉树组成。

    二叉树的性质,存储结构。

    性质1: 在二叉树的第i层上至多有2^(i-1)个结点(i>0)。

    性质2: 深度为k的二叉树至多有2^k-1个结点(k>0)。

    性质3: 对于任何一棵二叉树,如果其终端结点数为n0,度为2的结点数有n2个,则叶子数n0=n2+1

    性质4: 具有n个结点的完全二叉树的深度必为 [log2n]+1

    性质5: 对完全二叉树,若从上至下、从左至右编号,则编号为i 的结点,其左孩子编号必为2i,其右孩子编号为2i+1;其双亲的编号必为i/2(i=1 时为根,除外)。

    二叉树的存储结构:

    1).顺序存储结构

    按二叉树的结点“自上而下、从左至右”编号,用一组连续的存储单元存储。

    若是完全/满二叉树则可以做到唯一复原。

    不是完全二叉树:一律转为完全二叉树!

    方法很简单,将各层空缺处统统补上“虚结点”,其内容为空。

    缺点:①浪费空间;②插入、删除不便 

    2).链式存储结构

    用二叉链表即可方便表示。一般从根结点开始存储。

    lchild

    data

    rchild

    优点:①不浪费空间;②插入、删除方便

    3.二叉树的遍历。

    指按照某种次序访问二叉树的所有结点,并且每个结点仅访问一次,得到一个线性序列。

    遍历规则:二叉树由根、左子树、右子树构成,定义为D、 L、R

    若限定先左后右,则有三种实现方案:

      DLR               LDR                   LRD

    先序遍历           中序遍历          后序遍历

    4.线索二叉树

    1)线索二叉树可以加快查找前驱与后继结点,实质就是将二叉链表中的空指针改为指向前驱或后继的线索,线索化就是在遍历中修改空指针。

    通常规定:对某一结点,若无左子树,将lchild指向前驱结点;若无右子树,将rchild指向后继结点。

    还需要设置左右两个tag,用来标记当前结点是否有子树。

    若ltag==1,lchild指向结点前驱;若rtag==1,rchild指向结点后继。

    2)线索二叉树的存储结构如下:

    typedef struct ThreadNode{

    ElemType data;

    struct ThreadNode *lchild, *rchild;

    int ltag, rtag;

    }ThreadNode, *ThreadTree;

    5.树和森林

    1)树有三种常用存储方式:

    ①双亲表示法     ②孩子表示法    ③孩子—兄弟表示法

    2)森林、树、二叉树的转换

    (1)将树转换为二叉树

    树中每个结点最多只有一个最左边的孩子(长子)和一个右邻的兄弟。按照这种关系很自然地就能将树转换成相应的二叉树:a.在所有兄弟结点之间加一连线

    b.对每个结点,除了保留与其长子的连线外,去掉该结点与其它孩子的连线。

    (2)将一个森林转换为二叉树:

    具体方法是:a.将森林中的每棵树变为二叉树;

    b.因为转换所得的二叉树的根结点的右子树均为空,故可将各二叉树的根结点视为兄弟从左至右连在一起,就形成了一棵二叉树。

    (3)二叉树转换为树

    是树转换为二叉树的逆过程。

    a.加线。若某结点X的左孩子结点存在,则将这个左孩子的右孩子结点、右孩子的右孩子结点、右孩子的右孩子的右孩子结点,都作为结点X的孩子。将结点X与这些右孩子结点用线连接起来。

    b.去线。删除原二叉树中所有结点与其右孩子结点的连线。

     

    (4)二叉树转换为森林:

    假如一棵二叉树的根节点有右孩子,则这棵二叉树能够转换为森林,否则将转换为一棵树。

    a.从根节点开始,若右孩子存在,则把与右孩子结点的连线删除。再查看分离后的二叉树,若其根节点的右孩子存在,则连线删除。直到所有这些根节点与右孩子的连线都删除为止。

    b.将每棵分离后的二叉树转换为树。

    6.树和森林的遍历

    • 树的遍历

    ① 先根遍历:访问根结点;依次先根遍历根结点的每棵子树。

    ② 后根遍历:依次后根遍历根结点的每棵子树;访问根结点。

     

    • 森林的遍历

    ① 先序遍历

    若森林为空,返回;

    访问森林中第一棵树的根结点;

    先根遍历第一棵树的根结点的子树森林;

    先根遍历除去第一棵树之后剩余的树构成的森林。

    ② 中序遍历

    若森林为空,返回;

    中根遍历森林中第一棵树的根结点的子树森林;

    访问第一棵树的根结点;

    中根遍历除去第一棵树之后剩余的树构成的森林。

     

    7.哈夫曼树及其应用

    Huffman树:最优二叉树(带权路径长度最短的树)

    Huffman编码:不等长编码。

    树的带权路径长度:(树中所有叶子结点的带权路径长度之和)

    构造Huffman树的基本思想:权值大的结点用短路径,权值小的结点用长路径。

    构造Huffman树的步骤(即Huffman算法):

    (1) 由给定的 n 个权值{ w1, w2, …, wn }构成n棵二叉树的集合F = { T1, T2, …, Tn } (即森林) ,其中每棵二叉树 Ti 中只有一个带权为 wi 的根结点,其左右子树均空。

    (2) 在F 中选取两棵根结点权值最小的树 做为左右子树构造一棵新的二叉树,且让新二叉树根结点的权值等于其左右子树的根结点权值之和。

    (3) 在F 中删去这两棵树,同时将新得到的二叉树加入 F中。

    (4) 重复(2) 和(3) , 直到 F 只含一棵树为止。这棵树便是Huffman树。

    具体操作步骤:

    应用:用于通信编码

      在通信及数据传输中多采用二进制编码。为了使电文尽可能的缩短,可以对电文中每个字符出现的次数进行统计。设法让出现次数多的字符的二进制码短些,而让那些很少出现的字符的二进制码长一些。假设有一段电文,其中用到 4 个不同字符A,C,S,T,它们在电文中出现的次数分别为 7 , 2 , 4 , 5 。把 7 , 2 , 4 , 5 当做 4 个叶子的权值构造哈夫曼树如图(a) 所示。在树中令所有左分支取编码为 0 ,令所有右分支取编码为1。将从根结点起到某个叶子结点路径上的各左、右分支的编码顺序排列,就得这个叶子结点所代表的字符的二进制编码,如图(b) 所示。这些编码拼成的电文不会混淆,因为每个字符的编码均不是其他编码的前缀,这种编码称做前缀编码。

     

    第七章 图

    1.图的定义,概念、术语及基本操作(https://blog.csdn.net/eyishion/article/details/53234255)

    1)图的定义

    图(Graph)是由顶点的有穷非空集合和顶点之间边的集合组成;

    通常表示为:G(V,E),G表示一个图,V是图G中顶点的集合,E是图G中边的集合;

    注意:在图中数据元素称之为顶点(Vertex),而且顶点集合有穷非空;在图中任意两个顶点之间都可能有关系,顶点之间的逻辑关系用边来表示。

    2)图的分类

    • 按照有无方向,分为无向图有向图

    无向图:如果图中任意两个顶点之间的边都是无向边,则称该图为无向图。

    无向边:若顶点M到顶点N的边没有方向,称这条边为无向边,用无序偶对(M,N)或(N,M)表示。

    无向图是有顶点构成。如下图所示就是一个无向图G1:

    无向图G1= (V1,{E1}),其中顶点集合 V1={A,B,C,D};边集合E1={(A,B),(B,C),(C,D),(D,A)}

    有向图:如果图中任意两个顶点之间的边都是有向边,则称该图为有向图。

    有向边:若顶点M到顶点N的边有方向,称这条边为有向边,也称为弧,用偶序对 < M, N >表示;M表示弧尾,N表示弧头

    有向图是有顶点构成,如下图所示是一个有向图G2:

    有向图G2=(V2,{E2}),其中顶点集合 V2={A,B,C,D};弧集合E2={< A,D>,< B,A>,< C,A>,< B,C>}

    对于弧< A,D>来说, A是弧尾,D是弧头

    注意:无向边用 小括号 “()”表示,有向边用“<>”表示。

    无向完全图:在无向图中,如果任意两个顶点之间都存在边,则称该图为无向完全图。

    含有n个顶点的无向完全图有n * (n-1)/2条边。下面是一个无向完全图

    4个顶点,6条无向边,每个顶点对应3条边 ,一共4个顶点 总共 4*3,每个顶点对应的边都重复计算了一次,所以整体要除以2。

    对于n各 顶点和e条边的无向图满足:0<=e <= n(n-1)/2

    有向完全图:在有向图中,如果任意两个顶点之间都存在方向互为相反的两条弧,则称该图为有向完全图。

    含有n个顶点的无向完全图有n * (n-1)条边。下面是一个有向完全图

    4个顶点,12条弧,一共4个顶点 总共 4*3。

    2,按照弧或边的多少,分为稀疏图稠密图

    若边或弧的个数e<=NlogN(N是顶点的个数),称为系数图,否则称为稠密图;

    3,按照边或弧是否带权,其中带权的图统称为

    有些图的边或弧具有与它相关的数字,这种与图的边或弧相关的数叫做权。

    有向网中弧带权的图叫做有向网;

    无向网中边带权的图叫做无向网;

    比如下图就是一个无向图

     

    图的顶点和边间关系

    邻接点 度 入度 出度

    对于无向图,假若顶点v和顶点w之间存在一条边,则称顶点v和顶点w互为邻接点,边(v,w)和顶点v和w相关联。

    顶点v的是和v相关联的边的数目,记为TD(v);

    上面这个无向图G1,A和B互为邻接点,A和D互为邻接点,B和C互为邻接点,C和D互为邻接点;

    A的度是2,B的度是2,C的度是2,D的度是2;所有顶点度的和为8,而边的数目是4;

    图中边的数目e = 各个顶点度数和的一半。

    对于有向图来说,与某个顶点相关联的弧的数目称为度(TD);以某个顶点v为弧尾的弧的数目定义为顶点v的出度(OD);以顶点v为弧头的弧的数目定义为顶点的入度(ID)

    度(TD) = 出度(OD) + 入度(ID);

    比如上面有向图,

    A的度为3 ,A的入度 2,A的出度是1

    B的度为2 ,B的入度 0,B的出度是2

    C的度为2 ,C的入度 1,C的出度是1

    D的度为1 ,D的入度 1,D的出度是0

    所有顶点的入度和是4,出度和也是4,而这个图有4个弧

    所以 有向图的弧 e = 所有顶点入度的和 = 所有顶点出度的和

    路径 路径长度 简单路径 回路 (环) 简单回路(简单环)

    设图G=(V,{E})中的一个顶点序列{u=Fi0,Fi1,Fi2,….Fim=w}中,(Fi,j-1,Fi,j)∈E 1 ≤j ≤m,则称从顶点u到顶点w之间存在一条路径,路径上边或弧的数目称作路径长度

    若路径中的顶点不重复出现的路径称为简单路径

    若路径中第一个顶点到最后一个顶点相同的路径称为回路或环

    若路径中第一个顶点和最后一个顶点之外,其余顶点不重复出现的回路,称为简单回路或简单环

    比如下图 :

    从B 到 D 中顶点没有重复出现 ,所以是简单路径 ,边的数目是2,所以路径长度为 2。

    图1和图2都是一个回路(环),图1中出了第一个顶点和最后一个顶点相同之外,其余顶点不相同,所以是简单环(简单回路),图2,有与顶点C重复就不是一个简单环了;

    连通图相关术语

    连通图

    在无向图G(V,{E})中,如果从顶点V到顶点W有路径,则称V和W是连通的。如果对于图中任意两个顶点Vi、Vj∈V,Vi和Vj都是连通的,则称G是连通图。

    如下图所示:

    图1,顶点A到顶点E就无法连通,所以图1不是连通;图2,图3,图4属于连通图;

    连通分量

    若无向图为非连通图,则图中各个极大连通子图称作此图的连通分量;

    图1是无向非连通图,由两个连通分量,分别是图2和图3。图4尽管也是图1的子图,但是它不满足极大连通,也就说极大连通应当是包含ABCD四个顶点,比如图2那样;

    强连通图

    在有向图G(V,{E})中,如果对于每一对Vi ,Vj∈V,Vi≠Vj,从Vi到Vj和从Vj到Vi都存在有向路径,则称G是强连通图。

    图1不是强连通图因为D到A不存在路径,图2属于强连通图。

    强连通分量

    若有向图不是强连通图,则图中各个极大强连通子图称作此图的强连通分量;

    图1不是强连通图,但是图2是图1的强连通子图,也就是强连通分量;

    生成树和生成森林

    生成树

    假设一个连通图有n个顶点和e条边,其中n-1条边和n个顶点构成一个极小连通子图,称该极小连通子图为此连通图的生成树;

    图1是一个连通图含有4个顶点和4条边,图2,图3,图4含有3条边和4个顶点,构成了一个极小连通图子图,也称为生成树,为什么是极小连通子图,因为图2,图3,图4中少一条边都构不成一个连通图,多一条边就变成一个回路(环),所以是3条边和4个顶点构成的极小连通子图。图5尽管也是3个边4个顶点,但不是连通图。

    生成森林

    如果一个有向图恰有一个顶点的入度为0,其余顶点的入度为1,则是一颗有向树

    入度为0,相当于根节点,入度为1,相当于分支节点;,比如下面的有向图就是一个有向树

    顶点B的入度是0,其余顶点的入度是1;

    一个有向图的生成森林由若干颗有向树组成,含有图中全部顶点,但有足以构成若干颗不相交的有向树的弧;

    有向图1去掉一些弧后分解成2颗有向树,图2和图3,这两颗树就是有向图图1的生成森林;

    2.图的存储结构

    1).邻接矩阵(数组)表示法

    ① 建立一个顶点表和一个邻接矩阵

    ② 设图 A = (V, E) 有 n 个顶点,则图的邻接矩阵是一个二维数组 A.Edge[n][n]。

    注:在有向图的邻接矩阵中,

       第i行含义:以结点vi为尾的弧(即出度边);

       第i列含义:以结点vi为头的弧(即入度边)。

    邻接矩阵法优点:容易实现图的操作,如:求某顶点的度、判断顶点之间是否有边(弧)、找顶点的邻接点等等。

    邻接矩阵法缺点:n个顶点需要n*n个单元存储边(弧);空间效率为O(n^2)。

    2).邻接表(链式)表示法

    ① 对每个顶点vi 建立一个单链表,把与vi有关联的边的信息(即度或出度边)链接起来,表中每个结点都设为3个域:

    ② 每个单链表还应当附设一个头结点(设为2个域),存vi信息;

    ③ 每个单链表的头结点另外用顺序存储结构存储。

    邻接表的优点:空间效率高;容易寻找顶点的邻接点;

    邻接表的缺点:判断两顶点间是否有边或弧,需搜索两结点对应的单链表,没有邻接矩阵方便。

    3.图的遍历

    遍历定义:从已给的连通图中某一顶点出发,沿着一些边,访遍图中所有的顶点,且使每个顶点仅被访问一次,就叫做图的遍历,它是图的基本运算。

    图的遍历算法求解图的连通性问题、拓扑排序和求关键路径等算法的基础。

    图常用的遍历:一、深度优先搜索;二、广度优先搜索 

    深度优先搜索(遍历)步骤:(如下图)

    ① 访问起始点 v;

    ② 若v的第1个邻接点没访问过,深度遍历此邻接点;

    ③ 若当前邻接点已访问过,再找v的第2个邻接点重新遍历。

    基本思想:——仿树的先序遍历过程。

    遍历结果:v1->v2->v4->v8->v5-v3->v6->v7

    广度优先搜索(遍历)步骤:

    ① 在访问了起始点v之后,依次访问 v的邻接点;

    ② 然后再依次(顺序)访问这些点(下一层)中未被访问过的邻接点;

    ③ 直到所有顶点都被访问过为止。

    遍历结果:v1->v2->v3->v4->v5-v6->v7->v8

    4.图的连通性问题

    1)对无向图进行遍历时,对于连通图,仅需从图中任一顶点出发,进行深度优先搜索或广度优先搜索,便可访问到图中所有顶点。

    2)最小生成树:在连通网的所有生成树中,所有边的代价和最小的生成树。

    构造最小生成树有很多算法,但是他们都是利用了最小生成树的同一种性质:MST性质(假设N=(V,{E})是一个连通网,U是顶点集V的一个非空子集,如果(u,v)是一条具有最小权值的边,其中u属于U,v属于V-U,则必定存在一颗包含边(u,v)的最小生成树),下面就介绍两种使用MST性质生成最小生成树的算法:普里姆算法和克鲁斯卡尔算法。

    Kruskal算法特点:将边归并,适于求稀疏网的最小生成树。

    Prime算法特点: 将顶点归并,与边数无关,适于稠密网。

    Prime算法构造最小生成树过程如下图:

    Kruskal算法构造最小生成树过程如下图:

    5.有向无环图及其应用

    有向无环图(Directed Acyclic Graph简称DAG)G进行拓扑排序,是将G中所有顶点排成一个线性序列,使得图中任意一对顶点u和v,若边(u,v)∈E(G),则u在线性序列中出现在v之前。

    1)拓扑排序

    拓扑排序对应施工的流程图具有特别重要的作用,它可以决定哪些子工程必须要先执行,哪些子工程要在某些工程执行后才可以执行。

    我们把顶点表示活动、边表示活动间先后关系的有向图称做顶点活动网(Activity On Vertex network),简称AOV网。

    一个AOV网应该是一个有向无环图,即不应该带有回路,因为若带有回路,则回路上的所有活动都无法进行(对于数据流来说就是死循环)。在AOV网中,若不存在回路,则所有活动可排列成一个线性序列,使得每个活动的所有前驱活动都排在该活动的前面,我们把此序列叫做拓扑序列(Topological order),由AOV网构造拓扑序列的过程叫做拓扑排序(Topological sort)。AOV网的拓扑序列不是唯一的,满足上述定义的任一线性序列都称作它的拓扑序列。

    拓扑排序的实现:

    a.在有向图中选一个没有前驱的顶点并且输出

    b.从图中删除该顶点和所有以它为尾的弧(白话就是:删除所有和它有关的边)

    c.重复上述两步,直至所有顶点输出,或者当前图中不存在无前驱的顶点为止,后者代表我们的有向图是有环的,因此,也可以通过拓扑排序来判断一个图是否有环。

    2)关键路径

    AOE-网是一个带权的有向无环图,其中,顶点表示事件,弧表示活动,权表示活动持续的时间。通常,AOE-网可用来估算工程的完成时间。

    关键路径:在AOE网中,从始点到终点具有最大路径长度(该路径上的各个活动所持续的时间之和)的路径称为关键路径。

    关键活动:关键路径上的活动称为关键活动。关键活动:e[i]=l[i]的活动

    由于AOE网中的某些活动能够同时进行,故完成整个工程所必须花费的时间应该为始点到终点的最大路径长度。关键路径长度是整个工程所需的最短工期。

    与关键活动有关的量

    (1)事件的最早发生时间ve[k]:ve[k]是指从始点开始到顶点vk的最大路径长度。这个长度决定了所有从顶点vk发出的活动能够开工的最早时间。 

    (2)事件的最迟发生时间vl[k]:vl[k]是指在不推迟整个工期的前提下,事件vk允许的最晚发生时间。

    (3)活动的最早开始时间e[i]:若活动ai是由弧<vk vj>表示,则活动ai的最早开始时间应等于事件vk的最早发生时间。因此,有:e[i]=ve[k]

    (4)活动的最晚开始时间l[i]:活动ai的最晚开始时间是指,在不推迟整个工期的前提下, ai必须开始的最晚时间。若ai由弧<vkvj>表示,则ai的最晚开始时间要保证事件vj的最迟发生时间不拖后。因此,有:l[i]=vl[j]-len<vk,vj

    示例如下:

    6.最短路径

    从某顶点出发,沿图的边到达另一顶点所经过的路径中,各边上权值之和最小的一条路径叫做最短路径。

    1)迪杰斯塔拉算法--单源最短路径

     

    所有顶点间的最短路径—用Floyd(弗洛伊德)算法

    第八章:查找

    查找表是称为集合的数据结构。是元素间约束力最差的数据结构:元素间的关系是元素仅共在同一个集合中。(同一类型的数据元素构成的集合)

    1.静态查找表

      1)顺序查找(线性查找)

      技巧:把待查关键字key存入表头或表尾(俗称“哨兵”),这样可以加快执行速度。

    int Search_Seq( SSTable  ST , KeyType  key ){

    ST.elem[0].key =key;

    for( i=ST.length; ST.elem[ i ].key!=key;  - - i  );

          return i;

    } // Search_Seq

    //ASL=(1+n)/2,时间效率为 O(n),这是查找成功的情况:

    顺序查找的特点:

    优点:算法简单,且对顺序结构或链表结构均适用。

           缺点: ASL 太大,时间效率太低。

      2)折半查找(二分查找)——只适用于有序表,且限于顺序存储结构。

      若关键字不在表中,怎样得知并及时停止查找?

      典型标志是:当查找范围的上界≤下界时停止查找。

      ASL的含义是“平均每个数据的查找时间”,而前式是n个数据查找时间的总和,所以:

     

    3)分块查找(索引顺序查找)

    思路:先让数据分块有序,即分成若干子表,要求每个子表中的数据元素值都比后一块中的数值小(但子表内部未必有序)。然后将各子表中的最大关键字构成一个索引表,表中还要包含每个子表的起始地址(即头指针)。

    特点:块间有序,块内无序。

    查找:块间折半,块内线性

    查找步骤分两步进行:

    ① 对索引表使用折半查找法(因为索引表是有序表);

    ② 确定了待查关键字所在的子表后,在子表内采用顺序查找法(因为各子表内部是无序表);

    查找效率ASL分析:

    2.动态查找表

    1)二叉排序树和平衡二叉树

    • 二叉排序树的定义----或是一棵空树;或者是具有如下性质的非空二叉树:

     (1)若它的左子树不空,则左子树上所有结点的值均小于根的值;

     (2)若它的右子树不空,则右子树的所有结点的值均大于根的值;

     (3)它的左右子树也分别为二叉排序树。

    二叉排序树又称二叉查找树。

    二叉排序树的查找过程:

    BiTree SearchBST(BiTree T, KeyType key)

    {

            //在根指针T所指二叉排序树中递归地查找某关键字等于key的数据元素,

            //若查找成功,则返回指向该数据元素结点的指针,否则返回空指针

            if ((!T)||EQ(key, T->data.key))  return(T); //查找结束

            else if LT(key, T->data.key) return (SearchBST(T->lchild, key)); //在左子树中继续查找

            else return (SearchBST(T->rchild,key)); //在右子树中继续查找

    }

    • 二叉排序树的插入

            思路:查找不成功,生成一个新结点s,插入到二叉排序树中;查找成功则返回。

       SearchBST (K,  &t) { //K为待查关键字,t为根结点指针

       p=t;       //p为查找过程中进行扫描的指针

       while(p!=NULL)

    {

       case {

                   K= p->data:  {查找成功,return true;}

                   K< p->data :  {q=p;p=p->lchild }  //继续向左搜索

                   K> p->data :  {q=p;p=p->rchild } //继续向右搜索

                }

      }  //查找不成功则插入到二叉排序树中

    s =(BiTree)malloc(sizeof(BiTNode)); 

    s->data=K; s ->lchild=NULL; s ->rchild=NULL;

          //查找不成功,生成一个新结点s,插入到二叉排序树叶子处

    case {

                t=NULL:   t=s;   //若t为空,则插入的结点s作为根结点

                K < q->data: q->lchild=s;  //若K比叶子小,挂左边

                K > q->data: q->rchild=s; //若K比叶子大,挂右边

            }

    return OK;

    }

    • 二叉排序树的删除

    假设:*p表示被删结点的指针; PL和PR 分别表示*P的左、右孩子指针;

    *f表示*p的双亲结点指针;并假定*p是*f的左孩子;则可能有三种情况:

    *p有两颗子树,有两种解决方法:

    法1:令*p的左子树为 *f的左子树,*p的右子树接为*s的右子树;如下图(c)所示  //即 fL=PL  ;   SR=PR   ;

    法2:直接令*p的直接前驱(或直接后继)替代*p,然后再从二叉排序树中删去它的直接前驱(或直接后继) 。如图(d),当以直接前驱*s替代*p时,由于*s只有左子树SL,则在删去*s之后,只要令SL为*s的双亲*q的右子树即可。 // *s为*p左子树最右下方的结点

    删除算法如下:

    Status Delete(BiTree &p)

    {

        //从二叉排序树种删除结点p,并重接它的左或右子树

        if(!p->rchild) //右子树空,只需重接它的左子树

        {

            q=p;

            p=p->lchild;

            free(q);

        }

        else if(!p->lchild) //左子树空,只需重接它的右子树

        {

            q=p;

            p=p->rchild;

            free(q);

        }

        else //左右子树都不空

        {

            q=p; 

            s=p->lchild;

            while(s->rchild)  //转左,然后向右到尽头(找p的直接前驱) 图(b)

            {

                q=s;

                s=s->rchild;

            }

            p->data = s->data; //s指向被删结点的“前驱”

            if(q!=p)  //重接*q的右子树

            {

                q->rchild=s->lchild;

            }

            else  //q=p,说明s->rchild为空(即:p->lchild->rchild为空),重接*q的左子树

            {

                q->lchild=s->lchild;

            }

             delete s;

        }//end else 左右子树都不空

        return TRUE;

    }

    二叉排序树查找分析:和折半查找类似,与给定值比较的关键字个数不超过树的深度。然而,折半查找长度为n的表的判定树是惟一的,而含有n个结点的二叉排序树却不惟一。

    含有n个结点的二叉排序树的平均查找长度和树的形态有关。当先后插入的关键字有序时,构成的二叉排序树蜕变为单支树。树的深度为n,其平均查找长度为(n+1)/2(和顺序查找相同),这是最差的情况。最好的情况是二叉排序树的形态和折半查找的判定树相同,其平均查找长度和log2n成正比。

    (n>=2)

     

    • 平衡二叉树

    又称AVL树,即它或者是一颗空树,或者具有如下性质:它的左子树和右子树都是平衡二叉树,且左子树与右子树的深度之差的绝对值不超过1。

    平衡因子:该结点的左子树的深度减去它的右子树的深度。

    平衡二叉树的特点:任一结点的平衡因子只能取:-1、0 或 1。

    如果在一棵AVL树中插入一个新结点,就有可能造成失衡,此时必须重新调整树的结构,使之恢复平衡。我们称调整平衡过程为平衡旋转

    平衡旋转可以归纳为四类:单向右顺时针旋转(LL);单向左逆时针旋转(RR);双向旋转先左逆时针后右顺时针(LR);双向旋转先右顺时针后左逆时针(RL)

    平衡二叉树查找分析:

    时间复杂度为O(logn)

    3.B-树和B+树

    B+树是应文件系统所需而出的一种B树的变型树。一棵m阶的B+树和m阶的B-树的差异在于:

    1.有n棵子树的结点中含有n个关键字,每个关键字不保存数据,只用来索引,所有数据都保存在叶子节点。

    2.所有的叶子结点中包含了全部关键字的信息,及指向含这些关键字记录的指针,且叶子结点本身依关键字的大小自小而大顺序链接。

    3.所有的非终端结点可以看成是索引部分,结点中仅含其子树(根结点)中的最大(或最小)关键字。

    通常在B+树上有两个头指针,一个指向根结点,一个指向关键字最小的叶子结点。

    B-树:一棵m阶的B-树或者是一棵空树,或者是满足下列要求的m叉树:

    • 树中的每个结点至多有m棵子树;

    • 若根结点不是叶子结点,则至少有两棵子树;

    • 除根结点外,所有非终端结点至少有[ m/2 ] ( 向上取整 )棵子树。

    • 所有的非终端结点中包括如下信息的数据(n,A0,K1,A1,K2,A2,….,Kn,An)

    其中:Ki(i=1,2,…,n)为关键码,且Ki < K(i+1),

    Ai 为指向子树根结点的指针(i=0,1,…,n),且指针A(i-1) 所指子树中所有结点的关键码均小于Ki (i=1,2,…,n),An 所指子树中所有结点的关键码均大于Kn。n 为关键码的个数。

    • 所有的叶子结点都出现在同一层次上,并且不带信息(可以看作是外部结点或查找失败的结点,实际上这些结点不存在,指向这些结点的指针为空)。

     

    4.哈希表

    哈希表(Hash table,也叫散列表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表

     

    1)哈希函数构造方法

    • 直接定址法

    取关键字或关键字的某个线性函数值为散列地址。

    即 H(key) = key 或 H(key) = a*key + b,其中a和b为常数。

    • 除留余数法

    取关键字被某个不大于散列表长度 m 的数 p 求余,得到的作为散列地址。

    即 H(key) = key % p, p < m。

    • 数字分析法

    当关键字的位数大于地址的位数,对关键字的各位分布进行分析,选出分布均匀的任意几位作为散列地址。

    仅适用于所有关键字都已知的情况下,根据实际应用确定要选取的部分,尽量避免发生冲突。

    • 平方取中法

    先计算出关键字值的平方,然后取平方值中间几位作为散列地址。

    随机分布的关键字,得到的散列地址也是随机分布的。

    • 折叠法(叠加法)

    将关键字分为位数相同的几部分,然后取这几部分的叠加和(舍去进位)作为散列地址。

    用于关键字位数较多,并且关键字中每一位上数字分布大致均匀。

    • 随机数法

    选择一个随机函数,把关键字的随机函数值作为它的哈希值。

    通常当关键字的长度不等时用这种方法。

    构造哈希函数的方法很多,实际工作中要根据不同的情况选择合适的方法,总的原则是尽可能少的产生冲突

    通常考虑的因素有关键字的长度分布情况哈希值的范围等。

    如:当关键字是整数类型时就可以用除留余数法;如果关键字是小数类型,选择随机数法会比较好。

     

    2)哈希冲突的解决方法

     

    • 开放定址法

    Hi=(H(key) + di) MOD m i=1,2,…,k (k<=m)

    当冲突发生时,使用某种探测技术在散列表中形成一个探测序列。沿此序列逐个单元地查找,直到找到给定的关键字,或者碰到一个开放的地址(即该地址单元为空)为止(若要插入,在探查到开放的地址,则可将待插入的新结点存人该地址单元)。查找时探测到开放的地址则表明表中无待查的关键字,即查找失败。

    当冲突发生时,使用某种探查(亦称探测)技术在散列表中寻找下一个空的散列地址,只要散列表足够大,空的散列地址总能找到

    按照形成探查序列的方法不同,可将开放定址法区分为线性探查法、二次探查法、双重散列法等。

    a.线性探查法

    hi=(h(key)+i) % m ,0 ≤ i ≤ m-1

    基本思想是:探查时从地址 d 开始,首先探查 T[d],然后依次探查 T[d+1],…,直到 T[m-1],此后又循环到 T[0],T[1],…,直到探查到 有空余地址 或者到 T[d-1]为止。

    b.二次探查法

    hi=(h(key)+i*i) % m,0 ≤ i ≤ m-1

    基本思想是:探查时从地址 d 开始,首先探查 T[d],然后依次探查 T[d+1^2],T[d+2^2],T[d+3^2],…,等,直到探查到 有空余地址 或者到 T[d-1]为止。缺点是无法探查到整个散列空间。

    c.双重散列法

    hi=(h(key)+i*h1(key)) % m,0 ≤ i ≤ m-1

    基本思想是:探查时从地址 d 开始,首先探查 T[d],然后依次探查 T[d+h1(d)], T[d + 2*h1(d)],…,等。

    该方法使用了两个散列函数 h(key) 和 h1(key),故也称为双散列函数探查法。

    定义 h1(key) 的方法较多,但无论采用什么方法定义,都必须使 h1(key) 的值和 m 互素,才能使发生冲突的同义词地址均匀地分布在整个表中,否则可能造成同义词地址的循环计算。

    该方法是开放定址法中最好的方法之一。

    • 链接法(拉链法)

    将所有关键字为同义词的结点链接在同一个单链表中。若选定的散列表长度为 m,则可将散列表定义为一个由 m 个头指针组成的指针数组 T[0..m-1] 。

    凡是散列地址为 i 的结点,均插入到以 T[i] 为头指针的单链表中。

    T 中各分量的初值均应为空指针。

    在拉链法中,装填因子 α 可以大于 1,但一般均取 α ≤ 1。

    3.哈希表的查找及其分析

    哈希表是实现关联数组(associative array)的一种数据结构,广泛应用于实现数据的快速查找。

    查找过程中,关键字的比较次数,取决于产生冲突的多少,产生的冲突少,查找效率就高,产生的冲突多,查找效率就低。因此,影响产生冲突多少的因素,也就是影响查找效率的因素。

    影响产生冲突多少有以下三个因素:

    1)哈希函数是否均匀;

    2)处理冲突的方法;

    3)哈希表的加载因子。

     

    第九章:内部排序

    排序:将一个数据元素(或记录)的任意序列,重新排列成一个按关键字有序的序列。

    稳定性——若两个记录A和B的关键字值相等,且排序后A、B的先后次序保持不变,则称这种排序算法是稳定的。

    1.插入排序

    思想:每步将一个待排序的对象,按其关键码大小,插入到前面已经排好序的一组对象的适当位置上,直到对象全部插入为止。

    简言之,边插入边排序,保证子序列中随时都是排好序的。

    1)  直接插入排序

        在已形成的有序表中线性查找,并在适当位置插入,把原来位置上的元素向后顺移。

    时间效率: 因为在最坏情况下,所有元素的比较次数总和为(0+1+…+n-1)→O(n^2)。

    其他情况下也要考虑移动元素的次数。 故时间复杂度为O(n^2)

    空间效率:仅占用1个缓冲单元——O(1)

    算法的稳定性:稳定

    直接插入排序算法的实现:

    void InsertSort ( SqList &L ) 

    { //对顺序表L作直接插入排序

     for ( i = 2;  i <=L.length; i++) //假定第一个记录有序

    {

         L.r[0]= L.r[i];

           j=i-1 ;                      //先将待插入的元素放入“哨兵”位置

         while(L[0] .key<L[j].key)

        {  

            L.r[j+1]= L.r[j];

            j--  ;                    

        }      //只要子表元素比哨兵大就不断后移

        L.r[j+1]= L.r[0];      //直到子表元素小于哨兵,将哨兵值送入

                                     //当前要插入的位置(包括插入到表首)

    }

    }

    2)折半插入排序

    子表有序且为顺序存储结构,则插入时采用折半查找定可加速。

    优点:比较次数大大减少,全部元素比较次数仅为O(nlog2n)。

    时间效率:虽然比较次数大大减少,可惜移动次数并未减少, 所以排序效率仍为O(n^2) 。

    空间效率:仍为 O(1)

    稳 定  性: 稳定

     

    3)希尔排序—不稳定

    基本思想:先将整个待排记录序列分割成若干子序列,分别进行直接插入排序,待整个序列中的记录“基本有序”时,再对全体记录进行一次直接插入排序。

    优点:让关键字值小的元素能很快前移,且序列若基本有序时,再用直接插入排序处理,时间效率会高很多。

    时间效率:当n在某个特定范围内,希尔排序所需的比较和移动次数约为n^1.3,当n->无穷,可减少到n(log2n)^2

    空间效率:O(1)

    4)快速排序

    基本思想:从待排序列中任取一个元素 (例如取第一个) 作为中心,所有比它小的元素一律前放,所有比它大的元素一律后放,形成左右两个子表;然后再对各子表重新选择中心元素并依此规则调整,直到每个子表的元素只剩一个。此时便为有序序列了。

    优点:因为每趟可以确定不止一个元素的位置,而且呈指数增加,所以特别快!

    前提:顺序存储结构

    时间效率:O(nlog2n) —因为每趟确定的元素呈指数增加

    空间效率:O(log2n)—因为递归要用栈(存每层low,high和pivot)

    稳 定 性: 不 稳 定 — —因为有跳跃式交换。

    算法:

    int partition(SqList &L,int low,int high)

    {

      L.r[0] = L.r[low];

      pivot key = L.r[low].key;

        while(low < high)

        {

         while(low<high&&L.r[high]>=pivot) high--;

         L.r[low] = L.r[high];

         while(low<high&&L.r[low]<=pivot) low++;

         L.r[high] = L.r[low];

        }

        L.r[low] = pivot;

        return low;

    }

     

    5)冒泡排序

    基本思路:每趟不断将记录两两比较,并按“前小后大”(或“前大后小”)规则交换。

    优点:每趟结束时,不仅能挤出一个最大值到最后面位置,还能同时部分理顺其他元素;一旦下趟没有交换发生,还可以提前结束排序。

    前提:顺序存储结构

    冒泡排序的算法分析:

    时间效率:O(n^2) —因为要考虑最坏情况

    空间效率:O(1) —只在交换时用到一个缓冲单元

    稳 定 性: 稳定  —25和25*在排序前后的次序未改变

    冒泡排序的优点:每一趟整理元素时,不仅可以完全确定一个元素的位置(挤出一个泡到表尾),还可以对前面的元素作一些整理,所以比一般的排序要快。

    选择排序:选择排序的基本思想是:每一趟在后面n-i 个待排记录中选取关键字最小的记录作为有序序列中的第i  个记录。

    6)简单选择排序

    思路异常简单:每经过一趟比较就找出一个最小值,与待排序列最前面的位置互换即可。

    ——首先,在n个记录中选择最小者放到r[1]位置;然后,从剩余的n-1个记录中选择最小者放到r[2]位置;…如此进行下去,直到全部有序为止。

    优点:实现简单

    缺点:每趟只能确定一个元素,表长为n时需要n-1趟

    前提:顺序存储结构

    时间效率:O(n^2)——虽移动次数较少,但比较次数较多

    空间效率:O(1)

    算法稳定性——不稳定

    Void SelectSort(SqList  &L ) 

    {

    for (i=1;  i<L.length; ++i)

    {

         j = SelectMinKey(L,i);  //在L.r[i..L.length]中选择key最小的记录

         if( i!=j )   r[i] <--> r[j]; //与第i个记录交换

          } //for

      }  //SelectSort

     

    7)堆排序

    设有n个元素的序列 k1,k2,…,kn,当且仅当满足下述关系之一时,称之为堆。

    如果让满足以上条件的元素序列 (k1,k2,…,kn)顺次排成一棵完全二叉树,则此树的特点是:树中所有结点的值均大于(或小于)其左右孩子,此树的根结点(即堆顶)必最大(或最小)。

    堆排序算法分析:

    时间效率:O(nlog2n)。因为整个排序过程中需要调用n-1次HeapAdjust( )算法,而算法本身耗时为log2n;

    空间效率:O(1)。仅在第二个for循环中交换记录时用到一个临时变量temp。

    稳定性: 不稳定。

    优点:对小文件效果不明显,但对大文件有效。

     

    8)归并排序----稳定

    将两个或两个以上有序表组合成一个新的有序表。

    时间复杂度:O(nlogn)

    空间复杂度:和待排记录等数量的辅助空间。

     

    9)基数排序

    时间复杂度:对于n各记录(每个记录含d个关键字,每个关键字取值范围为rd个值)进行链式基数排序的时间复杂度为O(d(n+rd)),其中每一趟分配的时间复杂度为O(n),每一趟收集的时间复杂度为O(rd)

    10)各种内部排序方法的比较讨论

    (1) 从平均时间性能看,快速排序最佳,其所需时间最省,但快速排序的最坏情况下的时间性能不如堆排序和快速排序。后两者相比较,在n较大时,归并排序所需时间较堆排序省,但它所需的辅助存储量最多。

    (2)基数排序的时间复杂度可写成O(dn)。因此,它最适用于n值很大而关键字较小的序列。

    (3)从方法的稳定性来比较,基数排序是稳定的内排方法,所需时间复杂度为O(n^2)的简单排序方法也是稳定的,然而,快速排序、堆排序和希尔排序等时间性能较好的排序方法是不稳定的。

    展开全文
  • ffmpeg.c函数结构简单分析(画图)

    万次阅读 多人点赞 2014-10-04 00:12:40
    前一阵子研究转码的时候看了FFmpeg的源代码。由于ffmpeg.c的代码相对比较长,而且其中有相当部分是AVFilter有关的代码(这...先说明一下自己画的结构图的规则:中仅画出了比较重要的函数之间的调用关系。粉红色的
    前一阵子研究转码的时候看了FFmpeg的源代码。由于ffmpeg.c的代码相对比较长,而且其中有相当一部分是AVFilter有关的代码(这一部分一直不太熟),因此之前学习FFmpeg的时候一直也没有好好看一下其源代码。最近正好看了看AVFilter的知识,顺便就看了下FFmpeg的源代码,在这里画图理一下它的结构。目前好多地方还没有弄明白,等到以后慢慢完善了。

    先说明一下自己画的结构图的规则:图中仅画出了比较重要的函数之间的调用关系。粉红色的函数是FFmpeg编解码类库(libavcodec,libavformat等)的API。绿色的函数是FFmpeg的libavfilter的API。其他不算很重要的函数就不再列出了。

    PS:有一部分代码可能和ffmpeg.c有一些出入。因为本文使用的ffmpeg.c的代码是移植到VC之后的代码。

    在看ffmpeg.c的代码之前,最好先看一下简单的代码了解FFmpeg解码,编码的关键API:
     

    100行代码实现最简单的基于FFMPEG+SDL的视频播放器

    最简单的基于FFmpeg+SDL的音频播放器

    最简单的基于FFMPEG的视频编码器(YUV编码为H.264)

    最简单的基于FFMPEG的音频编码器(PCM编码为AAC)

    最简单的基于FFmpeg的转码程序

     

    函数调用结构图

    FFmpeg的总体函数调用结构图如下图所示



    上图所示本是一张高清大图。但是页面显示不下。因此上传了一份:

    http://my.csdn.net/leixiaohua1020/album/detail/1788075

    上面地址的那张图保存下来的话就是一张清晰的图片了。

    下文将会对主要函数分别解析。

    main()

    main()是FFmpeg的主函数。
    调用了如下函数
    av_register_all():注册所有编码器和解码器。
    show_banner():打印输出FFmpeg版本信息(编译时间,编译选项,类库信息等)。
    parse_options():解析输入的命令。
    transcode():转码。
    exit_progam():退出和清理。
     
    下图红框中的内容即为show_banner()的输出结果。


     

    parse_options()



    parse_options()解析全部输入选项。即将输入命令“ffmpeg -i xxx.mpg -vcodec libx264 yyy.mkv”中的“-i”,“-vcodec”这样的命令解析出来。其函数调用结构如下图所示。

    注:定义位于cmdutils.c中。


    调用了如下函数:
    parse_option():解析一个输入选项。具体的解析步骤不再赘述。parse_options()会循环调用parse_option()直到所有选项解析完毕。FFmpeg的每一个选项信息存储在一个OptionDef结构体中。定义如下:
    typedef struct OptionDef {
        const char *name;
        int flags;
    #define HAS_ARG    0x0001
    #define OPT_BOOL   0x0002
    #define OPT_EXPERT 0x0004
    #define OPT_STRING 0x0008
    #define OPT_VIDEO  0x0010
    #define OPT_AUDIO  0x0020
    #define OPT_INT    0x0080
    #define OPT_FLOAT  0x0100
    #define OPT_SUBTITLE 0x0200
    #define OPT_INT64  0x0400
    #define OPT_EXIT   0x0800
    #define OPT_DATA   0x1000
    #define OPT_PERFILE  0x2000     /* the option is per-file (currently ffmpeg-only).
             implied by OPT_OFFSET or OPT_SPEC */
    #define OPT_OFFSET 0x4000       /* option is specified as an offset in a passed optctx */
    #define OPT_SPEC   0x8000       /* option is to be stored in an array of SpecifierOpt.
             Implies OPT_OFFSET. Next element after the offset is
             an int containing element count in the array. */
    #define OPT_TIME  0x10000
    #define OPT_DOUBLE 0x20000
         union {
            void *dst_ptr;
            int (*func_arg)(void *, const char *, const char *);
            size_t off;
        } u;
        const char *help;
        const char *argname;
    } OptionDef;

    其中的重要字段:
    name:用于存储选项的名称。例如“i”,“f”,“codec”等等。
    flags:存储选项值的类型。例如:HAS_ARG(包含选项值),OPT_STRING(选项值为字符串类型),OPT_TIME(选项值为时间类型。
    u:存储该选项的处理函数。
    help:选项的说明信息。
    FFmpeg使用一个名称为options,类型为OptionDef的数组存储所有的选项。有一部分通用选项存储在cmdutils_common_opts.h中。cmdutils_common_opts.h内容如下:
        { "L"          , OPT_EXIT, {(void*)show_license},      "show license" },
        { "h"          , OPT_EXIT, {(void*) show_help},         "show help", "topic" },
        { "?"          , OPT_EXIT, {(void*)show_help},         "show help", "topic" },
        { "help"       , OPT_EXIT, {(void*)show_help},         "show help", "topic" },
        { "-help"      , OPT_EXIT, {(void*)show_help},         "show help", "topic" },
        { "version"    , OPT_EXIT, {(void*)show_version},      "show version" },
        { "formats"    , OPT_EXIT, {(void*)show_formats  },    "show available formats" },
        { "codecs"     , OPT_EXIT, {(void*)show_codecs   },    "show available codecs" },
        { "decoders"   , OPT_EXIT, {(void*)show_decoders },    "show available decoders" },
        { "encoders"   , OPT_EXIT, {(void*)show_encoders },    "show available encoders" },
        { "bsfs"       , OPT_EXIT, {(void*)show_bsfs     },    "show available bit stream filters" },
        { "protocols"  , OPT_EXIT, {(void*)show_protocols},    "show available protocols" },
        { "filters"    , OPT_EXIT, {(void*)show_filters  },    "show available filters" },
        { "pix_fmts"   , OPT_EXIT, {(void*)show_pix_fmts },    "show available pixel formats" },
        { "layouts"    , OPT_EXIT, {(void*)show_layouts  },    "show standard channel layouts" },
        { "sample_fmts", OPT_EXIT, {(void*)show_sample_fmts }, "show available audio sample formats" },
        { "loglevel"   , HAS_ARG,  {(void*)opt_loglevel},      "set libav* logging level", "loglevel" },
        { "v",           HAS_ARG,  {(void*)opt_loglevel},      "set libav* logging level", "loglevel" },
        { "debug"      , HAS_ARG,  {(void*)opt_codec_debug},   "set debug flags", "flags" },
        { "fdebug"     , HAS_ARG,  {(void*)opt_codec_debug},   "set debug flags", "flags" },
        { "report"     , 0,        {(void*)opt_report}, "generate a report" },
        { "max_alloc"  , HAS_ARG,  {(void*) opt_max_alloc},     "set maximum size of a single allocated block", "bytes" },
        { "cpuflags"   , HAS_ARG | OPT_EXPERT, {(void*) opt_cpuflags}, "force specific cpu flags", "flags" },

    options数组的定义位于ffmpeg_opt.c中:
    const OptionDef options[] = {
        /* main options */
    #include "cmdutils_common_opts.h"//包含了cmdutils_common_opts.h中的选项
        { "f", HAS_ARG | OPT_STRING | OPT_OFFSET,           { (void*)OFFSET(format) },
            "force format", "fmt" },
        { "i", HAS_ARG | OPT_PERFILE,          { (void*) opt_input_file },
            "input file name", "filename" },
        { "y", OPT_BOOL,          { &file_overwrite },
            "overwrite output files" },
        { "n", OPT_BOOL,          { &no_file_overwrite },
            "do not overwrite output files" },
        { "c", HAS_ARG | OPT_STRING | OPT_SPEC,{ (void*) OFFSET(codec_names) },
            "codec name", "codec" },
        { "codec",          HAS_ARG | OPT_STRING | OPT_SPEC,{(void*) OFFSET(codec_names) },
            "codec name", "codec" },
        { "pre",            HAS_ARG | OPT_STRING | OPT_SPEC,{ (void*) OFFSET(presets) },
            "preset name", "preset" },
        { "map",            HAS_ARG | OPT_EXPERT | OPT_PERFILE,          { (void*) opt_map },
            "set input stream mapping",
            "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
        { "map_channel",    HAS_ARG | OPT_EXPERT | OPT_PERFILE,          {(void*)opt_map_channel },
            "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
        { "map_metadata",   HAS_ARG | OPT_STRING | OPT_SPEC,{ (void*)OFFSET(metadata_map) },
            "set metadata information of outfile from infile",
            "outfile[,metadata]:infile[,metadata]" },
        { "map_chapters",   HAS_ARG | OPT_INT | OPT_EXPERT | OPT_OFFSET, { (void*) OFFSET(chapters_input_file) },
            "set chapters mapping", "input_file_index" },
        { "t", HAS_ARG | OPT_TIME | OPT_OFFSET,{(void*) OFFSET(recording_time) },
            "record or transcode \"duration\" seconds of audio/video",
            "duration" },
        { "fs",HAS_ARG | OPT_INT64 | OPT_OFFSET,            { (void*) OFFSET(limit_filesize) },
            "set the limit file size in bytes", "limit_size" },
        { "ss",HAS_ARG | OPT_TIME | OPT_OFFSET,{ (void*) OFFSET(start_time) },
            "set the start time offset", "time_off" },
       …//选项太多,不一一列出
    };

    在这里,例举一个选项的OptionDef结构体:输入
    { "i",HAS_ARG | OPT_PERFILE, { (void*) opt_input_file }, "input file name", "filename" }
    在这个结构体中,可以看出选项的名称为“i”,选项包含选项值(HAS_ARG),选项的处理函数是opt_input_file(),选项的说明是“input file name”。下面可以详细看一下选项的处理函数opt_input_file()。该函数的定义位于ffmpeg_opt.c文件中。可以看出,调用了avformat_alloc_context()初始化了AVFormatContext结构体,调用了avformat_open_input()函数打开了“-i”选项指定的文件。此外,调用了avformat_find_stream_info()等完成了一些初始化操作。此外,调用了av_dump_format()打印输出输入文件信息。
    static int opt_input_file(void *optctx, const char *opt, const char *filename)
    {
        //略…
        /* open the input file with generic avformat function */
        err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
        if (err < 0) {
            print_error(filename, err);
            exit(1);
        }
       
        //略…
        /* Set AVCodecContext options for avformat_find_stream_info */
        opts = setup_find_stream_info_opts(ic, codec_opts);
        orig_nb_streams = ic->nb_streams;
     
        /* If not enough info to get the stream parameters, we decode the
           first frames to get it. (used in mpeg case for example) */
        ret = avformat_find_stream_info(ic, opts);
        if (ret < 0) {
            av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
            avformat_close_input(&ic);
            exit(1);
        }
       
        //略…
        /* dump the file content */
        av_dump_format(ic, nb_input_files, filename, 0);
       
        //略…
        return 0;
    }
     
    再例举一个输出文件处理函数opt_output_file()。这里需要注意,输出文件的处理并不包含在OptionDef类型的数组options中。因为FFmpeg中指定输出文件时并不包含选项名称,这是一个比较特殊的地方。一般的选项格式是“-名称 值”,例如指定输入文件的时候,选项格式是“-i xxx.flv”。而指定输出文件的时候,直接指定“值”即可,这是新手可能容易搞混的地方。
    例如,最简单的转码命令如下(输出文件前面不包含选项):
    ffmpeg -i xxx.mpg xxx.mkv
    而不是
    ffmpeg -i xxx.mpeg -o xxx.mkv
     
    下面简单看一下opt_output_file()函数的定义。该函数的定义同样位于ffmpeg_opt.c文件中。这个函数的定义特别长,完成了输出视频的初始化工作。在这里就不列出代码了。该函数首先调用avformat_alloc_output_context2()初始化AVFormatContext结构体。而后根据媒体类型的不同,分别调用new_video_stream(),new_audio_stream(),new_subtitle_stream()等创建不同的AVStream。实际上上述的几个创建AVStream的函数调用了new_output_stream()。而new_output_stream()又调用了FFmpeg类库的API函数avformat_new_stream()。
     
    void opt_output_file(void *optctx, const char *filename)
    {
        //略…
        err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
     
        if (!oc) {
            print_error(filename, err);
            exit(1);
        }
        //略…
       new_video_stream();
       …
       new_audio_stream();
       …
       new_subtitle_stream ();
        //略…
     
    }
     


    transcode()


    transcode()的功能是转码。其函数调用结构如下图所示。

    调用了如下函数
    transcode_init():转码的初始化工作。
    check_keyboard_interaction():检测键盘操作。例如转码的过程中按下“Q”键之后,会退出转码。
    transcode_step():进行转码。
    print_report():打印转码信息,输出到屏幕上。
    flush_encoder():输出编码器中剩余的帧。
    其中check_keyboard_interaction(),transcode_step(),print_report()三个函数位于一个循环之中会不断地执行。

    下图红框所示即为print_report()打印输出到屏幕上的信息。


    下面简单介绍两个重要的函数transcode_init()和transcode_step()。

    transcode_init()

    transcode_init()调用了以下几个重要的函数:
    av_dump_format():在屏幕上打印输出格式信息。注意是输出格式的信息,输入格式的信息的打印是在parse_options()函数执行过程中调用opt_input_file()的时候打印到屏幕上的。
    init_input_stream():其中调用了avcodec_open2()打开编码器。
    avformat_write_header():写输出文件的文件头。
     

    transcode_step()

    transcode_step()调用了如下函数:
    process_input():完成解码工作。
    transcode_from_filter():未分析。
    reap_filters():完成编码工作。
     

    process_input()

    process_input()主要完成了解码的工作。其函数调用结构如下图所示。

    process_input()调用了如下函数:
    get_input_packet():获取一帧压缩编码数据,即一个AVPacket。其中调用了av_read_frame()。
    output_packet():解码压缩编码的数据并将之送至AVFilterContext。
     
    output_packet()调用了如下函数:
    decode_video():解码一帧视频(一个AVPacket)。
    decode_audio():解码音频(并不一定是一帧,是一个AVPacket)。
    do_streamcopy():如果不需要重新编码的话,则调用此函数,一般用于封装格式之间的转换。速度比转码快很多。
     
    decode_video()调用了如下函数:
    avcodec_decode_video2():解码一帧视频。
    rate_emu_sleep():要求按照帧率处理数据的时候调用,可以避免FFmpeg处理速度过快。常用于网络实时流的处理(RTP/RTMP流的推送)。
    configure_filtergraph():设置AVFilterGraph。
    av_buffersrc_add_frame():将解码后的数据(一个AVFrame)送至AVFilterContext。
     
    decode_audio()调用的函数和decode_video()基本一样。唯一的不同在于其解码音频的函数是avcodec_decode_audio4()
     

    configure_filtergraph()

    未分析。


     
     

    reap_filters()

    reap_filters()主要完成了编码的工作。其函数调用结构如下图所示。

    reap_filters()调用了如下函数
    av_buffersink_get_buffer_ref():从AVFilterContext中取出一帧解码后的数据(结构为AVFilterBufferRef,可以转换为AVFrame)。
    avfilter_copy_buf_props():AVFilterBufferRef转换为AVFrame。
    do_audio_out():编码音频。
    do_video_out():编码视频。
    avfilter_unref_buffer():释放资源。
     
    do_video_out()调用了如下函数
    avcodec_encode_video2():编码一帧视频。
    write_frame():写入编码后的视频压缩数据。
     
    write_frame()调用了如下函数:
    av_bitstream_filter_filter():使用AVBitStreamFilter的时候,会调用此函数进行处理。
    av_interleaved_write_frame():写入压缩编码数据。
     
    do_audio_out()调用的函数与do_video_out()基本上一样。唯一的不同在于视频编码函数avcodec_encode_video2()变成了音频编码函数avcodec_encode_audio2()。

     


    exit_program()

    exit_program()主要完成了清理工作。调用关系如下图所示。

     
    调用了如下函数:
    avfilter_graph_free():释放AVFilterGraph。
    avformat_free_context():释放输出文件的AVFormatContext。
    av_bitstream_filter_close():关闭AVBitStreamFilter。
    avformat_close_input():关闭输入文件。
     
     

    附录

    FFmpeg转码时在屏幕上的输出。

    (转码命令为ffmpeg -i cuc_ieschool.flv cuc_ieschool.mkv)
     
    F:\movie>ffmpeg -i cuc_ieschool.flv cuc_ieschool.mkv
    //版本信息(main()->show_banner())
    ffmpeg version N-65018-gad91bf8 Copyright (c) 2000-2014 the FFmpeg developers
      built on Jul 26 2014 22:01:46 with gcc 4.8.3 (GCC)
      configuration: --enable-gpl --enable-version3 --disable-w32threads --enable-av
    isynth --enable-bzlib --enable-fontconfig --enable-frei0r --enable-gnutls --enab
    le-iconv --enable-libass --enable-libbluray --enable-libbs2b --enable-libcaca --
    enable-libfreetype --enable-libgme --enable-libgsm --enable-libilbc --enable-lib
    modplug --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrw
    b --enable-libopenjpeg --enable-libopus --enable-librtmp --enable-libschroedinge
    r --enable-libsoxr --enable-libspeex --enable-libtheora --enable-libtwolame --en
    able-libvidstab --enable-libvo-aacenc --enable-libvo-amrwbenc --enable-libvorbis
     --enable-libvpx --enable-libwavpack --enable-libwebp --enable-libx264 --enable-
    libx265 --enable-libxavs --enable-libxvid --enable-decklink --enable-zlib
      libavutil      52. 92.101 / 52. 92.101
      libavcodec     55. 69.100 / 55. 69.100
      libavformat    55. 49.100 / 55. 49.100
      libavdevice    55. 13.102 / 55. 13.102
      libavfilter     4. 11.102 /  4. 11.102
      libswscale      2.  6.100 /  2.  6.100
      libswresample   0. 19.100 /  0. 19.100
      libpostproc    52.  3.100 / 52.  3.100

    //输入信息(main()->parse_options()->opt_input_file()->av_dump_format())

    Input #0, flv, from 'cuc_ieschool.flv':
      Metadata:
        metadatacreator : iku
        hasKeyframes    : true
        hasVideo        : true
        hasAudio        : true
        hasMetadata     : true
        canSeekToEnd    : false
        datasize        : 932906
        videosize       : 787866
        audiosize       : 140052
        lasttimestamp   : 34
        lastkeyframetimestamp: 30
        lastkeyframelocation: 886498
        encoder         : Lavf55.19.104
      Duration: 00:00:34.16, start: 0.000000, bitrate: 318 kb/s
        Stream #0:0: Video: h264 (Main), yuv420p, 512x288 [SAR 1:1 DAR 16:9], 183 kb
    /s, 15.17 fps, 15 tbr, 1k tbn, 30 tbc
        Stream #0:1: Audio: mp3, 44100 Hz, stereo, s16p, 128 kb/s
    [libx264 @ 003de900] using SAR=1/1
    [libx264 @ 003de900] using cpu capabilities: MMX2 SSE2Fast SSSE3 SSE4.2 AVX
    [libx264 @ 003de900] profile High, level 2.1
    [libx264 @ 003de900] 264 - core 142 r2431 ac76440 - H.264/MPEG-4 AVC codec - Cop
    yleft 2003-2014 - http://www.videolan.org/x264.html - options: cabac=1 ref=3 deb
    lock=1:0:0 analyse=0x3:0x113 me=hex subme=7 psy=1 psy_rd=1.00:0.00 mixed_ref=1 m
    e_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chro
    ma_qp_offset=-2 threads=6 lookahead_threads=1 sliced_threads=0 nr=0 decimate=1 i
    nterlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1
    b_bias=0 direct=1 weightb=1 open_gop=0 weightp=2 keyint=250 keyint_min=15 scenec
    ut=40 intra_refresh=0 rc_lookahead=40 rc=crf mbtree=1 crf=23.0 qcomp=0.60 qpmin=
    0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00

    //输出信息(main()->transcode()->transcode_init()->av_dump_format())

    Output #0, matroska, to 'cuc_ieschool.mkv':
      Metadata:
        metadatacreator : iku
        hasKeyframes    : true
        hasVideo        : true
        hasAudio        : true
        hasMetadata     : true
        canSeekToEnd    : false
        datasize        : 932906
        videosize       : 787866
        audiosize       : 140052
        lasttimestamp   : 34
        lastkeyframetimestamp: 30
        lastkeyframelocation: 886498
        encoder         : Lavf55.49.100
        Stream #0:0: Video: h264 (libx264) (H264 / 0x34363248), yuv420p, 512x288 [SA
    R 1:1 DAR 16:9], q=-1--1, 15 fps, 1k tbn, 15 tbc
        Metadata:
          encoder         : Lavc55.69.100 libx264
        Stream #0:1: Audio: vorbis (libvorbis) (oV[0][0] / 0x566F), 44100 Hz, stereo
    , fltp
        Metadata:
          encoder         : Lavc55.69.100 libvorbis

    //输出Stream Maping 信息(main()->transcode()->transcode_init())

    Stream mapping:
      Stream #0:0 -> #0:0 (h264 (native) -> h264 (libx264))
      Stream #0:1 -> #0:1 (mp3 (native) -> vorbis (libvorbis))

    //一行字(main()->transcode())

    Press [q] to stop, [?] for help

    //输出信息(main()->transcode()->print_report())

    frame=   95 fps=0.0 q=27.0 size=     119kB time=00:00:06.57 bitrate= 148.4kbits/
    frame=  161 fps=158 q=27.0 size=     304kB time=00:00:10.99 bitrate= 226.8kbits/
    frame=  197 fps=130 q=27.0 size=     433kB time=00:00:13.41 bitrate= 264.4kbits/
    frame=  240 fps=119 q=27.0 size=     613kB time=00:00:16.32 bitrate= 307.5kbits/
    frame=  280 fps=111 q=27.0 size=     788kB time=00:00:18.90 bitrate= 341.2kbits/
    frame=  322 fps=106 q=27.0 size=     965kB time=00:00:21.76 bitrate= 363.1kbits/
    frame=  373 fps=106 q=27.0 size=    1115kB time=00:00:25.16 bitrate= 363.0kbits/
    frame=  431 fps=107 q=27.0 size=    1291kB time=00:00:29.00 bitrate= 364.6kbits/
    frame=  505 fps=111 q=27.0 size=    1453kB time=00:00:33.90 bitrate= 351.1kbits/
    frame=  510 fps=108 q=-1.0 Lsize=    1508kB time=00:00:34.15 bitrate= 361.7kbits/s

    //最后一次输出

    video:1085kB audio:403kB subtitle:0kB other streams:0kB global headers:4kB muxin
    g overhead: 1.365477%

    //avcodec_close()的时候输出(libx264专有的输出信息)

    [libx264 @ 003de900] frame I:4     Avg QP:17.21  size:  4880
    [libx264 @ 003de900] frame P:259   Avg QP:21.94  size:  3391
    [libx264 @ 003de900] frame B:247   Avg QP:26.87  size:   859
    [libx264 @ 003de900] consecutive B-frames: 18.6% 46.3% 12.4% 22.7%
    [libx264 @ 003de900] mb I  I16..4: 23.0% 57.5% 19.4%
    [libx264 @ 003de900] mb P  I16..4:  4.2%  7.5%  4.2%  P16..4: 30.1% 12.2%  5.7%
     0.0%  0.0%    skip:36.2%
    [libx264 @ 003de900] mb B  I16..4:  0.3%  0.5%  0.4%  B16..8: 28.8%  4.4%  1.0%
     direct: 1.4%  skip:63.2%  L0:40.4% L1:49.9% BI: 9.7%
    [libx264 @ 003de900] 8x8 transform intra:47.7% inter:41.7%
    [libx264 @ 003de900] coded y,uvDC,uvAC intra: 47.4% 27.8% 5.0% inter: 13.2% 4.4%
     0.3%
    [libx264 @ 003de900] i16 v,h,dc,p: 22% 36%  9% 33%
    [libx264 @ 003de900] i8 v,h,dc,ddl,ddr,vr,hd,vl,hu: 23% 26% 28%  3%  3%  3%  4%
     3%  4%
    [libx264 @ 003de900] i4 v,h,dc,ddl,ddr,vr,hd,vl,hu: 22% 25% 20%  5%  6%  5%  6%
     5%  6%
    [libx264 @ 003de900] i8c dc,h,v,p: 71% 18% 10%  1%
    [libx264 @ 003de900] Weighted P-Frames: Y:0.8% UV:0.8%
    [libx264 @ 003de900] ref P L0: 69.3% 12.3% 14.1%  4.3%  0.0%
    [libx264 @ 003de900] ref B L0: 83.9% 15.3%  0.7%
    [libx264 @ 003de900] ref B L1: 96.0%  4.0%
    [libx264 @ 003de900] kb/s:261.17


    展开全文
  • lisp函数知识大全

    千次阅读 2015-03-27 17:19:02
    若将函数名(大小写都可)作为表中的第个元素函数变元(若有的话)作为表中后面的元素,就可以调用那个函数。本章按字母顺序列出AutoLISP所有基本函数。用户会发现其中许多函数都是标准函数,可在LISP程序设计语言...

    AutoLISP提供了大量的预定义函数。若将函数名(大小写都可)作为表中的第一个元素函数变元(若有的话)作为表中后面的元素,就可以调用那个函数。本章按字母顺序列出AutoLISP所有基本函数。用户会发现其中许多函数都是标准函数,可在LISP程序设计语言中找到。还有一些函数是由 AutoCAD提供的且专用于交互图形环境。

    1 FLATLAND 系统变量--与老版本的兼容性
        AutoLISP版本10支持AutoCAD的最新增强型三维图形功能,则时继续保证与AutoCAD
    老版本的兼容性。FLATLAND系统变量就是用来控制该兼容性的。当FLATLAND为零时,实
    现新三维功能;否则各函数操作与AutoLISP版本9的一样。FLATLANDR的设置作用于下列
    AutoLISP函数:
         DISTANCE       GRREAD       POLAR
         ENTGET         INITGET      TBLNEXT
         GETDIST        INTERS       TBLSEARCH
         GETPOINT       OSNAP
    在各函数说明中,已注明FLATLAND对上述函数起作用的方式。

    2 ( + <数> <数> ...)
        这个函数返回所有<数>的总和。其中的<数>可以是整型或实型的。如果所有的<数>
    都是整数,其结果也是整数;如果其中有一个是实型的,那么其它整型数将转换为实型
    数结果将是实型数。例如:
         (+ 1 2)          returns 3
         (+ 1 2 3 4.5)    returns 10.5
         (+ 1 2 3 4.0)    returns 10.0

    3 ( - <数> <数>   ...)
        这个函数把第一个<数>减去第二个<数>,返回它们的差。如果给定的<数>多于两个,
    那么将第一个<数>减去其后所有数之和,并返回最后的结果。如果只给了一个<数>,即返
    回零减这个<数>的结果。此函数中的<数>可以是实型或整型,按标准规则进行类型转换。
    例如:
         (- 50 40)        returns 10
         (- 50 40.0 2)    returns 8.0
         (- 50 40.0 2.5) returns 7.5
         (- 8)            returns -8

    4 (* <数> <数>...)
       这个函数返回所有<数>的乘积.其中<数>可以是实型或整型.按标准规则进行类型转换
    例如:
         (* 2 3)          returns 6
         (* 2 3 4.0)      returns 24.0
         (* 3 -4.5)       returns -13.5

    5 (/ <数> <数>...)
       这个函数将第一个<数>除以第二个<数>,返回其商.如果给出的<数>多于两个,则把第
    一个<数>除以其它所有<数>的乘积,并返回最后的商.此函数中的<数>可以是实型或整型,
    类型的转换按标准规则进行.例如:
         (/ 100 2)        returns 50
         (/ 100 2.0)      returns 50.0
         (/ 100 20.0 2)   returns 2.5
         (/ 135 360)      returns 0
         (/ 135 360.0)    returns 0.375

    6 (= <原子> <原子>...)
       这是"等于"关系函数.如果所有指定的<原子>在数值上是相等的,则返回T;否则返回
    空(nil).这个函数适用于数和字符串.例如:
         (= 4 4.0)        returns T
         (= 20 388)       returns nil
         (= 2.4 2.4 2.4) returns T
         (= 499 499 500) returns nil
         (= "me" "me")    returns T
         (= "me" "you")   returns nil

    7 (/= <原子1> <原子2>...)
       这是一个"不等于"关系函数.如果<原子1>数值上不等于<原子2>,则返回T;否则返回
    nil.如果提供的<变元>多于两个,则函数无定义.例如:
         (/= 10 20)       returns T
         (/= "you" "you") returns nil
         (/= 5.43 5.44)   returns T

    8 (< <原子> <原子>...)
       这是一个"小于"关系函数.如果第一个<原子>值小于第二个,则返回T;否则返回nil.
    如果所给的<原子>多于两个,那么当每个<原子>都小于其右边的<原子>时,则返回T.
    例如:
         (< 10 20)        returns T
         (< "b" "c")      returns T
         (< 357 33.2)     returns nil
         (< 2 3 88)       returns T
         (< 2 3 4 4)      returns nil

    9   (<= <原子> <原子>...)
       这是一个"小于或等于"关系函数.如果第一个<原子>值大于或等于第二个原子,则返
    回T;否则返回nil.如果所给的<原子>多于两个,则当每一个<原子>都小于或等于其右边
    的<原子>时,才返回T.例如:
         (<= 10 20)       returns T
         (<= "b" "b")     returns T
         (<= 357 33.2)    returns nil
         (<= 2 9 9)       returns T
         (<= 2 9 4 5)     returns nil

    10   (> <原子> <原子>...)
       这是一个"大于"关系函数.如果第一个<原子>值大于第二个,则返回T;否则返回nil.
    若所给定的<原子>多于两个,当每个<原子>都大于其右边的<原子>时,则返回T. 例如:
         (> 120 17)       returns T
         (> "c" "b")      returns T
         (> 3.5 1792)     returns nil
         (> 77 4 2)       returns T
         (> 77 4 4)       returns nil

    11   (>= <原子> <原子>...)
       这是一个"大于或等于"关系函数.如果第一个<原子>值大于或等于第二个,则返回T;
    否则返回nil.如果给出的<原子>多于两个,当每一个<原子>都大于或等于其右边的<原子>
    时才返回T. 例如:
         (>= 120 17)      returns T
         (>= "c" "c")     returns T
         (>= 3.5 1792)    returns nil
         (>= 77 4 4)      returns T
         (>= 77 4 9)      returns nil

    12   (~ <数>)
       这个函数返回<数>的按位非(NOT),即补码.<数>必须为整数.例如:
         (~ 3)            returns -4
         (~ 100)          returns -101
         (~ -4)           returns 3

    13   (1+ <数>)
       这个函数返回<数>加1(增量)的结果. <数>可以是实数或整数. 例如:
         (1+ 5)           returns 6
         (1+ -17.5)       returns -16.5

    14   (1- <数>)
       这个函数返回<数>加1(增量)的结果. <数>可以是实型或整型数. 例如:
         (1- 5)           returns 4
         (1- -17.5)       returns -18.5

    15   (abs <数>)
       这个函数返回<数>的绝对值. <数>可以是实型数或整型的. 例如:
         (abs 100)        returns 100
         (abs -100)       returns 100
         (abs -99.25)     returns 99.25

    16   (and <表达式>...)
       这个函数返回所列出的表达式的逻辑"与"(AND). 如果其中任何一个表达式的结果等
    于nil,则停止求值并返回<nil>;否则返回T. 例如,对于下面给定的赋值:
         (setq a 103)
         (setq b nil)
         (setq c "string")
    那么
         (and 1.4 a c)    returns T
         (and 1.4 a b c) returns nil

    17   (angle <点1> <点2>)
       这个函数返回从UCS坐标系统点<pt1>到UCS坐标系统<pt2>的一直线的角度,该角度从
    当前作图平面的X轴开始反时针方向计算(以弧度为单位). 如果提供了三维点,则将其投
    影至当前作图平面. 例如:
         (angle '(1.0 1.0) '(1.0 4.0))    return 1.5708
         (angle '(5.0 1.33) '(2.4 1.33))   return 3.14159

    18   (angtos <角> [ <方式> [ <精度> ] ] )
       这个函数处理<角>(实型数,单位为弧度),返回一个对应于<角>的字符串.该字符串是
    根据所设置的<方式>、<精度>及AutoCAD DIMZIN变量,对<角>编辑后所得. 其中<方式>变
    元是一个整型数,它指示完成什么类型的编辑,如下所示:
           ANGTOS方式        编辑格式
          -----------------------------------------
       0                度
       1                度/分/秒
       2                梯度
       3                弧度
       4                测地单位
    其中<精度>变元是一个整型数,它选择所需要的十进制精度的小数位数. <方式>和<精度>
    与AutoCAD系统变量AUNITS和AUPREC相对应,如果没有指明<方式>和<精度>,则使用AUNITS
    和AUPREC的当前值.
        例如,已知DIMZIN=0和下面的赋值:
          (setq pt1 '(5.0 1.33))
          (setq pt2 '(2.4 1.33))
          (setq a   (angle pt1 pt2))
    那么,
          (angtos a 0 0)     returns "180"
          (angtos a 0 4)     returns "180.0000"
          (angtos a 1 4)     returns "180d0'0" "
          (angtos a 3 4)     returns "3.1416r"
          (angtos a 4 2)     returns "W"
        ANGTOS可接受一负<角>变元,但总是先将其化为相当的正值(在0 ~ 2π弧度间),
    然后再执行指定的变换. 例如:
          (angtos 0.785398 0 4)   returns "45.0000"
          (angtos -0.785398 0 4) returns "315.0000"

    19   (append <表达式>...)
       这个函数将所有的表( <表达式> )放置在一起,作为一个表. 例如:
          (append '(a b) '(c d))        returns (a b c d)
          (append '((a)(b)) '((c)(d))) returns ((a)(b)(c)(d))
        APPEND需要的变元必须是表.

    20   (apply <函数> <表>)
       它执行由<函数>给定的函数,<表>指定了函数的变元. 例如:
         (apply '+ '(1 2 3))               return 6
         (apply 'strcat '("a" "b" "c"))     return "abc"
       APPLY既可用于内部函数(子程序),也可用于用户定义的函数(即那些用DEFUN或者
       LAMBDA产生的函数).
    21   (ascii <字符串> )
       这个函数返回<字符串>中第一个字符的ASCII字符码(整数).它和BASIC语言中的ASC函
    数相似. 例如:
         (ascii "A")     return 65
         (ascii "a")     return 97
         (ascii "BIG")   return 66

    22   (assoc <项> <关联表> )
       这个函数在<关联表中>以<项>作为关键字进行搜索,返回<关联表>中对应元素的值.如
    果在关联表中找不到作为关键字的<项>,ASSOC返回nil. 例如,假设表"al"定义为:
         (( name box) (width 3) (size 4.7263) (depth 5) )
    那么,
         (assoc 'size a1)     returns (size 4.7263)
         (assoc 'weight a1)    returns nil
    关联表常用于储存数据,这些数据可通过"关键字"存取.它和程序设计语言的数组或结构
    相似.本章后面描述的SUBST函数提供了一种方便的方法可把关联表中与关键字关联的值
    进行替换.

    23   (atan <数1> [<数2>] )
       如果没有给出<数2>,ATAN将返回<数1>的反正切值,其单位为弧度.<数1>可以为负值;
    返回的角度的范围为:-pi 到 +pi弧度. 例如:
         (atan 0.5)                returns 0.463648
         (atan 1.0)                returns 0.785398
         (atan -1.0)               returns -0.785398
         (angtos (atan -1.0) 0 4) returns "315.0000"
    如果给出<数1>和<数2>,则返回<数1>/<数2>的反正切值,其单位为弧度.如果<数2>为零,
    即返回的角度值为1.570796弧度(90度或-90度),这取决于<数1>是正数还是负数.例如:
         (atan 2.0 3.0)                 returns 0.588003
         (angtos (atan 2.0 3.0) 0 4)    returns "33.6901"
         (atan 2.0 -3.0)                returns 2.55359
         (angtos (atan 2.0 -3.0) 0 4)   returns "146.3099"
         (atan -2.0 3.0)                returns -0.588003
         (atan -2.0 -3.0)               returns -2.55359
         (atan 1.0 0.0)                 returns 1.5708
         (angtos (atan 1.0 0.0) 0 4)    returns "90.0000"
         (atan -0.5 0.0)                returns -1.5708
         (angtos (atan -0.5 0.0) 0 2)   returns "270.00"

    24   (atof <字符串> )
       这个函数将字符串换为实型数. 并返回此值. 例如:
         (atof "97.1")    returns 97.1
         (atof "3")       returns 3.0

    25   (atoi <字符串> )
       这个函数将字符串转换为整数,并返回此值. 例如:
         (atoi "97")      returns 97
         (atoi "3")       returns 3
         (atoi "3.9")     returns 3

    26   (atom <项> )
       如果<项>是一个表,此函数返回nil;否则返回T. 任何不是表的东西都被认为是一个原
    子(atom). 例如,对于以下的赋值:
         (setq a '(x y z))
         (setq b 'a)
    那么,
         (atom 'a)        returns T
         (atom   a)        returns nil
         (atom 'b)        returns T
         (atom   b)        returns T
         (atom '(a b c))   returns nil
    有些LISP对ATOM的解释有差异,因此在使用互相移植的程序时要加以注意.

    27   (Boole <函数> <整型1> <整型2> )
       这是一个通用的位方式boolean函数.其中<func>是一个0到15之间的整数,它表示16种
    可能的双变量Boolean函数中的一种.后面的整型变元根据这个函数和下列的真值表进行
    方式(即逻辑)组合:
         <整数1>        <整数2>       <func>位
       -----------------------------------------------------
           0              0              8
           0              1              4
           1              0              2
           1              1              1
    <整数1>的每一位和<整数2>的相应位配对,选择真值表中的一水平行.其结果位是0或1,
    将取决于对应真值表中这一行中<func>位的设置情况.如果<func>中位的设置适当,结果
    位就为1,否则结果位为0.
          <func>的一些值等效于标准的Boolean操作:AND, OR , XOR和NOT,如下所示:
       func        操作         结果位为1时的条件
       --------------------------------------------------------
        1          AND           两个输入位都为1
        6          XOR           只有其中一个输入位为1
        7          OR            有一个或两个输入位为1
        8          NOT           两个输入位都为0(即补码)
    例如:
         (Boole 1 12 5)
       指定了数12和5的逻辑"与"(AND).其结果为4.同样:
         (Boole 6 6 5)
       指定了数6和5的逻辑"异或"(XOR),返回结果为3
       可以使用<func>的其他值来完成其它的Boolean操作,这些操作可能没有标准名称.例
    如,如果<func>为4,那么当<整数2>中的位是1而<整数1>中的相应位是零时,其结果位才为
    1. 因此:
         (Boole 4 3 14)
    将返回结果12.

    28   (boundp <原子> )
       如果<原子>有一个值约束它(不管值的范围),那么此函数返回T;若没有值约束<原子>
    (或受nil约束),则返回nil. 例如,对于下列赋值:
         (setq a 2)
         (setq b nil)
    那么:
         (boundp 'a)    returns T
         (boundp 'b)    returns nil

    29   caar, cadr, cddr, cadar等等
       AutoLISP支持CAR和CDR的连接,其深度可达四级. 例如,已知赋值:
         (setq x '((a b) c d))
    那么:
         (caar x)   is equivalent to    (car (car x))        returning   a
         (cdar x)   is equivalent to    (cdr (car x))        returning   (b)
         (cadar x) is equivalent to    (car (cdr (car x))) returning   b
         (cadr x)   is equivalent to    (car (cdr x))        returning   c
         (cddr x)   is equivalent to    (cdr (cdr x))        returning   (d)
         (caddr x) is equivalent to    (car (cdr (cdr x))) returning   d
       在AutoLISP中常使用CADR来取得二维点或三维点的Y坐标(即由两个或三个实数组成
    的表中第二个元素). 同样,使用CADDR可取得三维点的Z坐标. 例如,已知赋值:
         (setq pt2 '(5.25 1.0))      (a 2D point)
         (setq pt3 '(5.25 1.0 3.0)) (a 3D point)
    那么:
         (car pt2)     returns 5.25
         (cadr pt2)    returns 1.0
         (caddr pt2)   returns nil
         (car pt3)     returns 5.25
         (cadr pt3)    returns 1.0
         (caddr pt3)   returns 3.0

    30   (car <表> )
    这个函数返回<表>的第一个元素.如果<表>是空的,则返回nil. 例如:
         (car '(a b c))      returns a
         (car '((a b) c))    returns (a b)
         (car '( ))          returns nil

    31   (cdr <表> )
    这个函数返回除<表>中第一个元素以外的所有元素的表. 如果<表>是空的,则返回nil.
    例如:
         (cdr '(a b c))     returns (b c)
         (cdr '((a b) c))    returns (c)
         (cdr '())           returns nil
    如果<表>变元是一个点对,即一对中间用点隔开的元素表(见下面的CONS),CDR则返回没
    有表括号的第二个元素. 例如:
         (cdr '(a . b))        returns b
         (cdr '(1 . "TEXT"))   returns "TEXT"

    32   (chr <表> )
    这个函数把代表ASCII码的整型数转换为只有一个字符的字符串,并返回此结果(类似于
    BASIC中的CHR$函数). 例如:
         (chr 65)    returns "A"
         (chr 66)    returns "B"
         (chr 97)    returns "a"

    33   (close <文件描述符> )
    这个函数关闭指定的文件,返回nil. 其中<文件描述符>是从调用OPEN函数得到的. 在
    CLOSE函数执行之后,此文件描述符就不再有效.
    例如,假设X是一个有效的打开文件的描述符.
         (close x)
    将关闭与X相关联的文件,返回nil.

    34   (command <变元>...)
    这个函数在AutoLISP内部执行AutoCAD命令,它总是返回nil. 其中<变元>代表AutoCAD
    的命令及其子命令;对每一个变元都作处理,然后作为对相应提示的响应送给AutoCAD.命
    令名和选择项作为字符串传送,二维点作为两个实数的表传送,三维点作为三个实数的表
    传送.只有当AutoCAD发出"Command:"提示时,命令名才被AutoCAD识别.例如:
         (setq pt1 '(1.45 3.23))
         (setq pt2 (getpoint "Enter a point: "))
         (command "line" pt1 pt2)
         (command "")
    假设AutoCAD的"Command:"提示已出现,那么以上的表达式将为点"pt1"置值,提示用户输
    入点"pt2",执行AutoCAD的LINE命令,用两点作为此命令的输入.COMMAND的变元可以是字
    符串,实数,整数或点,这要看AutoCAD命令执行时需要什么.一个空字符串("")等效于在
    键盘上打一个空格.调用COMMAND而不加任何变元等效于在键盘上按CTRL-C键,它将取消
    AutoCAD的大多数命令.
    如果AutoCAD系统变量CMDECHO(可通过SETVAR和GETVAR存取)被置为零,那么从COMMAND
    函数中执行的命令将不会在屏幕上显示.COMMAND函数是在AutoLISP中调用AutoCAD命令的
    一种基本方法.
    在COMMAND函数内不能使用GETxxx用户输入函数(GETANGLE,GETSTRING,GETINT,GETPOINT
    等).如果试图用GETxxx函数,则会显示出错信息:"error: AutoCAD rejected function"
    [出错:AutoCAD拒绝执行函数],并中止函数的执行.如果需要提示,则应提前发出GETxxx函
    数,如上例所示,或把它们放在几个连续的COMMAND函数调用中间.
    AutoCAD的DTEXT和SKETCH命令均能直接从键盘和数字化仪读入,因此不能和AutoLISP的
    COMMAND函数一起使用.同样,COMMAND函数不能用于执行PLOT,PRPLOT或SCRIPT命令.

        为用户输入暂停

    如果在执行AutoCAD命令过程中,预定义符号PAUSE是作为COMMAND函数的一个变元出现
    时,则会暂停COMMAND函数的进程,等待用户直接输入或拖曳输入.这类似于在菜单中具有
    暂停功能的反斜杠.
    若在暂停COMMAND函数时使用一条透明命令,COMMAND函数继续暂停.这样,当暂停COMMAND
    时用户可随心所欲地Z00M(缩放目标)或PAN(平移图纸).当AutoCAD接收到有效输入且不是
    透明命令时,则返回COMMAND进程并继续往下执行. 例如
           (Command "circle" "5,5" pause "line" "5,5" "7,5" "")
    先执行circle命令,置圆心为(5,5),然后暂停以便屏幕上拖曳圆的半径.当拾取了所要
    的点(或键入所要的半径值)后,函数继续执行,画一条从5,5到7,5的直线.

    AutoLISP的PAUSE不能暂停菜单输入.如果在COMMAND函数暂停时,激活了一个菜单项,
    那么菜单项中的输入值会满足PAUSE的要求.如果还要暂停菜单项,则必须在菜单项中用一
    个反斜杠.一旦发现了有效输入,AutoCAD将会继续执行COMMAND函数和菜单项.
       注意:
          1. PAUSE符号当前是由一个反斜杠组成的字串.用户可直接使用一个反斜杠而不用
    PAUSE符号;但若用一个菜单项调用COMMAND函数,则反斜杠不会暂停COMMAND函
    数,而暂停正在读入的菜单项. 同样,暂停机制在AutoLISP的将来版本中可能会
    有一个不同的触发值. 因此我们建议使用PAUSE符号,而不宜显式使用反斜杠.
          2. 当一条命令正在等待输入正文串或属性值时出现了PAUSE,那么只有在系统变量
    TEXTEVAL不为零时,AutoCAD才为输入暂停.否则,认为PAUSE符号(一个反斜杠)
    的值等效于正文输入,且不为输入暂停.
          3. 当COMMAND函数进程被暂停时,该函数仍处于"激活"态,所以用户此时不可键入
    另一个AutoLISP表达式进行求值.

    35   (cond ( <测试1> <结果1> ) ...)
       这个函数接受任意数目的表作为变元.它计算每一个表的第一项(按提供的表的顺序),
    直到有一项的返回值不为nil为止.然后它计算测试成功的那个子表中后面的那些表达式,
    返回子表中最后那个表达式的值.如果子表中只有一个表达式(即没有<结果>项);则返回
    <测试>表达式的值.COND是AutoLISP中最基本的条件函数.
       例如,下列的函数使用COND完成绝对值的计算:
         (cond ( (minusp a) (- a) )
       ( t   a )
         )
    如果"a"的值为-10,它将会返回10.如上所示,COND可以作为"Case"类型的函数.它常常
    用T作为缺省的<测试>表达式.下面是另一个简单的例子.在符号S中用户响应的字符串是
    已知的,该函数测试用户的响应,若用户响应是Y或y,则返回1;若响应是N或n,则返回0;否
    则返回nil.
         (cond (( = s "Y") 1)
        (( = s "y") 1)
        (( = s "N") 0)
        (( = s "n") 0)
        (t nil)
         )

    36   (Cons <新的第一个元素> <表> )
       这是一个基本的表构造函数.它将一个元素<新的第一个元素>加入<表>的开头,并返回
    加入之后的表. 例如:
         (cons 'a '(b c d))    returns   (a b c d)
         (cons '(a) '(b c d)) returns   ((a) b c d)

         注意,第一个元素可以是原子或是表.
         CONS也可在<表>的变元位置上接受一个原子,用以构造前面讲过的点对表,即中间用
    点隔开的一对元素的结构.当显示这种结构时,AutoLISP在第一个和第二个元素之间打印
    出一个点.这种结构占的存储空间比普通表小,使用CDR函数可返回第二个原子. 如:
         (cons 'a 2)           returns (a . 2)
         (car (cons 'a 2))      returns a
         (cdr (cons 'a 2))      returns 2
       点对表是一种特殊的表,某些只处理常规表的函数不能把它当作变元接受.

     

    72   (log <数> )
       这个函数返回<数>的自然对数,其结果为实数,例如:
         (log 4.5)     returns 1.50408
         (log 1.22)    returns 0.198851

    73   (logand <数> <数>... )
       这个函数返回表中一系列<数>的按位方式的逻辑"与"结果.其中<数>必须是整数,结果
    也是一个整数. 例如:
         (logand 7 15 3)    returns 3
         (logand 2 3 15)    returns 2
         (logand 8 3 4)     returns 0

    74   (logior <数> <数>... )
       这个函数返回表中一系列<数>的按位方式的逻辑"或"结果.其中<数>必须为整数,其结
    果也是整数. 例如:
         (logior 1 2 4 )     returns 7
         (logior 9 3 )       returns 11

    75   (lsh <数1> <位数> )
       这个函数返回<数1>被<位数>变换后的逻辑位值.<数1>和<位数>必须是整数,其结果也
    是整数.
       如果<位数>为正,<数1>就变换至左位;如果为负,则变换至右位.在这两种情况下,移入
    位为"零",移出位丢弃.如果有位"1"移入或移出了整数的最高位(在DOS机上是第十六位,在
    32位工作站上是第32位),整数的符号就会改变.
       例如:
         (lsh 2 1)        returns 4
         (lsh 2 -1)        returns 1
         (lsh 40 2)        returns 160
         (lsh 16384 1)     returns -32768 on DOS machines
         (lsh 16384 -1)    returns 32768   on 32-bit workstations

    76   (mapcar <函数> <表1>... <表n> )
       MAPCAR返回<函数>的执行结果,它分别把<表1>到<表n>的每个元素作为<函数>的变元.
    <函数>后面的表的数目必须要与<函数>所需要的变元数目相匹配. 例如:
         (setq a 10 b 20 c 30)
         (mapcar '1+ (list a b c))     returns (11 21 31)
    这等效于:
         (1+ a)
         (1+ b)
         (1+ c)
    只是MAPCAR返回的结果为一个表.同理:
         (mapcar '+ '(10 20 30) '(4 3 2))     returns (14 23 32)
    和下列写法等效:
         (+ 10 4)
         (+ 20 3)
         (+ 30 2)
    LAMBDA函数可以指定一个"无名"函数,此"无名"函数可由MAPCAR执行.当有些函数变元是
    常数时或用其它手段提供时,这种方法便显得非常有用. 例如:
         (mapcar '(lambda (x) (+ x 3)) '(10 20 30))   returns (13 23 33)
    和:
         (mapcar '(lambda (x y z)
       (* x (- y z))
            )
    '(5 6) '(20 30) '(14 5.0)
         )                returns   (30 150.0)

    77   (max <数> <数>... )
       这个函数返回所给<数>中最大的数.每一个<数>必须是实数或整数. 例如:
         (max 4.07 -144)     returns 4.07
         (max -88 19 5 2)     returns 19

    78   (member <表达式> <表> )
       这个函数搜索表中的<表达式>,返回<表>中从第一次<表达式>出现到最后所剩的内容.
    如果在<表>中没有出现过<表达式>,MEMBER将返回nil. 例如:
         (member 'c '(a b c d e))    returns (c d e)
         (member 'q '(a b c d e))    returns nil

    79   (menucmd <串> )
       MENUCMD函数为LISP程序提供一种手段,以实现在AutoCAD菜单中各子菜单之间的转换.
    这样,LISP程序可和相关的菜单文件一起运行,并在需要用户输入时显示出适当的可供选择
    的子菜单.MENUCMD总是返回nil.<串>变元的形式是:
           类 = 子菜单
    其中
           类代表某一指定的菜单类名,有效的菜单类名有:
           S          表示屏幕菜单(SCREEN)
           B          表示按钮菜单(BUTTONS)
           I          表示图标菜单(ICON)
           P1-P10     表示下拉式菜单(POP),从1到10
           T1-T4      表示图形输入板菜单(TABLET),从1到4
           A1         表示辅助菜单(AUX 1)

           子菜单代表指定要激活的子菜单名.它可以是当前(已装入的)菜单文件中任一子菜
        单名(不带"* *"前缀)或是主菜单类名.

        详见AutoCAD参考手册的附录B.注意,这里不需要菜单文件中子菜单名所用的前缀符$.

        例如: (menucmd "S=OSNAP")
        使屏幕上出现OSNAP子菜单(假设在当前菜单文件中有这个子菜单).同样,
        (menucmd "B=MY-BUTTONS")
        将子菜单MY-BUTTONS赋给按钮菜单.

        对于图标菜单和下拉式菜单,"*"是一个有效的子菜单名,它使当前已具有指定菜单类
    别的子菜单在屏幕上显示.如序列:
    (menucmd "P1=NUMERIC")
    (menucmd "P1=*")
        先向下拉式菜单1指定子菜单NUMERIC,然后在屏幕上显示该子菜单.

    80   (min <数> <数>... )
       这个函数返回所有<数>中最小值的数.每一个<数>可以是实型或整型. 例如:
         (min 683 -10.0)      returns -10.0
         (min 73 2 48 5)      returns 2

    81   (minusp <项> )
       如果<项>为实数或整数,且为负值,那么此函数返回T;否则返回nil.对于其它类型的<项>
    没有定义. 例如:
         (minusp -1)      returns T
         (minusp -4.293) returns T
         (minusp 830.2)   returns nil

    82   (not <项> )
       如果<项>的计算值为nil时,此函数返回T;否则返回nil.特别地在和一些控制函数连用
    时,NULL函数常用于表,而NOT用于其它数据类型. 例如,对于下列赋值:
         (setq a 123)
         (setq b "string")
         (setq c nil)
    则有:
         (not a)      returns nil
         (not b)      returns nil
         (not c)      returns T
         (not '())    returns T

    83   (nth <n>   <表> )
       这个函数返回<表>中的第n个元素,其中<n>是返回的元素序号(零表示第一个元素).如
    果<n>大于<表>的最高元素序号,则返回nil.例如:
         (nth 3 '(a b c d e))        returns d
         (nth 0 '(a b c d e))        returns a
         (nth 5 '(a b c d e))        returns nil

    84   (null <项> )
       如果<项>的约束值是nil,此函数返回T;否则返回nil.例如,对于下列赋值:
         (setq a 123)
         (setq b "string")
         (setq c nil)
    则有:
         (null a)         returns nil
         (null b)         returns nil
         (null c)         returns T
         (null '())       returns T

    85   (numberp <项> )
       如果<项>是一个实数或整数,此函数返回T;否则返回nil.例如,对于下列赋值:
         (setq a 123)
         (setq b 'a)
    则有:
         (numberp 4)         returns T
         (numberp 3.8348)    returns T
         (numberp "Howdy")   returns nil
         (numberp 'a)        returns nil
         (numberp a)         returns T
         (numberp b)         returns nil
         (numberp (eval b))   returns T

    86   (open <文件名> <方式> )
       这个函数打开一个文件,以便AutoLISP的I/O函数进行存取.它返回文件描述符,这个描
    述符由其它的I/O函数所使用;因此,它必须要用SETQ赋给一个变量.例如:
         (setq a (open "file.ext" "r") )
       <文件名>是一个字符串,它指定了要打开的文件名和扩展名.<方式>为读/写标志,它必
    须是由单个小写字母组成的字符串.下表是对有效方式字符的说明:

           OPEN方式                         说明
    ---------------------------------------------------------------------------
           "r"(读)           为"读"打开文件.如果<文件名>不存在,则返回nil.
           "w"(写)           为"写打开文件.如果<文件名>不存在,则建立一个新文件,
        并打开该文件.如果<文件名>存在,则覆盖它的现存数据.
           "a"(添写)         为"添写"打开文件.如果<文件名>不存在,则建立一个新文件,
        并打开该文件.如果<文件名>存在,则打开该文件,并指向现存
        数据的尾部,这样,用户写入文件的所有新数据都将附加到现
        存数据的后面.在DOS中,某些程序的文本编辑在写入文本文件
        时会在文本尾部加上一个文件结束标记(CTRL-Z,十进制的ASC
        II码26).在读文本文件时,当碰到CTRL-Z标记,DOS便返回文件
        结束状态,即使在结束标记后面可能还有数据.如果您想用OPE
        N的"a"方式在由其他程序产生的文件后面附加数据,则必须保
        证这些程序没有在其文本文件尾部插入CTRL-Z标记.

           假设在下例中的文件名都不存在,那么:
    (setq f (open "new.tst" "w"))      returns <file #nnn>
    (setq f (open "nosuch.fil" "r"))   returns nil
    (setq f (open "logfile" "a"))      returns <file #nnn>

       <文件名>可包括目录名前缀,如"/test/func3".在MS-DOS/PC-DOS系统上允许使用驱动
    器字母,并可用反斜杠代替斜杠(但要记住,在字符串中必须要用"\\"才能得到一个反斜杠)
    . 例如:
    (setq f (open "/x/new.tst" "w"))    returns <file #nnn>
    (setq f (open "nosuch.fil" "r"))    returns nil

    87   (or <表达式>... )
       这个函数返回一系列表达式的逻辑或(OR).OR对表达式从左向右进行求值,寻找一个非
    nil的表达式.如果找到了一个非nil表达式,则停止继续求值,并返回T.如果所有的表达式
    的计算值都为nil,则OR返回nil.例如:
         (or nil 45 '())    returns T
         (or nil '() )       returns nil

    88   (osnap <点> <方式串> )
       这个函数返回一个点,这个点是对<点>施加了由<方式串>所描述的目标捕捉方式而得的
    结果.<方式串>是由一个或多个有效的目标标识符组成的字符串,如"midpoint","center"
    等等,它们之间用逗号隔开.例如:
         (setq pt2 (osnap pt1 "midp"))
         (setq pt2 (osnap pt1 "midp,endp,center"))
       如果<点>变元是一个二维点(由两个实数组成的表),则返回一个二维点.如果<点>变元
    是三维点(由三个实数组成的表),则返回一个三维点.如果对已知<点>找不到与指定<方式
    串>匹配的目标捕捉点,则返回nil.
       这个函数的操作取决于当前三维视图的FLATLAND系统变量的设置状况.详见AutoCAD参
    考手册第八章及附录D.

    89   pi
       这不是一个函数,而是常数π.它的值大约是3.1415926.

    90   (polar <点> <角> <距离> )
       这个函数返回一个UCS坐标系统的点,该点角度为<角>,与UCS坐标系统点<pt>相距<距离
    >.<角>以弧度表示,是以x轴开始逆时针方向计算的.<pt>有可能是三维点,但<角>总是相对
    于当前构造平面而言.若系统变量FLATLAND为零,就返回一个三维点;否则返回一个二维点.
    例如(假设FLATLAND为零):
         (polar '(1.0 1.035) 0.785398 1.414214) 返回 (2.0 2.0 3.5)

    91   (prin1 <表达式> [ <文件描述符> ] )
       这个函数在屏幕上打印<表达式>,并返回<表达式>.<表达式>可以是任何表达式,也可以
    不是字符串.如果指定了<文件描述符>,(并且是一个为写而打开的文件描述符),那么<表达
    式>按照它在屏幕上显示的格式写入那个文件.只有被指定的<表达式>才会打印;其中不包
    括换行符和空格.例如,对于下列赋值:
         (setq a 123)
         (setq b '(a))
    则有:
         (prin1 'a')       打印 a       并返回 a
         (prin1 a)         打印 123     并返回 123
         (prin1 b)         打印 (a)     并返回 (a)
         (prin1 "Hello")   打印 "Hello" 并返回 "Hello"

       以上每个例子都在屏幕上打印,因为没有指定<文件描述符>.假设f是一个为写而打开的
    有效文件描述符,则:
         (prin1 "Hello" f)
       将把"Hello"写到指定的文件中,并返回"Hello".
       如果<表达式>是一个含有控制字符的字符串,那么PRIN1将用"\"开头按下列方式编辑这
    些字符:
       \e      代表ESC
       \u      代表换行
       \r      代表回车
       \t      代表tab
       \nnn    代表八进制码为nnn的字符.
       这样:
    (prin1 (chr 2) )    打印 "\002"   返回 "\002"
    (prin1 (chr 10) )   打印 "\n"     返回 "\n"
       如果PRIN1没有变元,则返回名为空串的一个符号.如果把没有变元的PRIN1用在用户定
    义函数中最后的一个表达式,那么当函数结束只打印出一个空行,用这种方法可"悄悄"退出
    函数.例如,已知:
    (defun C:SETUP()
           (setvar "lunits" 4)
           (setvar "blipmode" 0)
           (prin1)
    )
       那么:
           Command:SETUP
       将执行用户定义的命令和要求的SETVAR函数,然后不打印信息而返回提示"Command:".

    92   (princ <表达式> [ <文件描述符> ] )
       这个函数和PRIN1基本相同,它和PRIN1的区别是它能实现<表达式>中控制字符的作用.
    一般来说,PRIN1打印的表达式的方法和LOAD相兼容,而PRINC打印的表达式可以由象READ-
    LINE这样的函数读出.

    93   (print <表达式> [ <文件描述符> ] )
       这个函数除了在打印<表达式>之前先换行和在打印<表达式>之后打印空格之外,其它和
    PRIN1相同.

    94   (progn <表达式>... )
       这个函数按顺序计算每一个<表达式>,返回最后表达式的求值结果.可以在只能用一个
    表达式的地方,用PROGN来完成多个表达式的计算.例如:
         (if (= a b) (progn
          (setq a (+ a 10))
          (setq b (- b 10))
        )
         )
    一般情况下,IF函数在测试表达式的计算值不为nil时,只计算前面一个表达式,在这个例
    子中,我们用PROGN可计算两个表达式.

    95   (prompt <信息> )
       这个函数将<信息>显示在用户的屏幕提示区,并返回nil.<信息>是一个字符串.在AutoC
    AD的双屏幕配置中,PROMPT在两个屏幕上都显示<信息>,因此它比PRINC更可取.例如:
         (prompt "New value: ")
       将在屏幕上显示"New value: ",并返回nil.

    96   (quote <表达式> )
       它返回没有计算的<表达式>.此函数还可以简写为:
       表达式
    例如:
         (quote a)            returns A
         (quote cat)          returns CAT
         (quote (a b))        returns (A B)
         'a                   returns A
         'cat                 returns CAT
         '(a b)               returns (A B)

       (对于后三个例子,如果在命令提示符下直接从键盘输入它们,那么将不会执行它们.记
    住,这样的输入必须以"("或"!"开头,以表明这是一个LISP表达式).

    97   (read <字符串> )
       这个函数返回从<字符串>中取得的第一个表或原子.<字符串>不能含有空格.例如:
         (read "hello")      returns HELLO
         (read "hi")         returns HI
         (read "(a)")        returns (A)

    98   (read-char [ <文件描述符> ] )
       这个函数从键盘输入缓冲区或从<文件描述符>表示的打开文件中读入一个字符.它返回
    一个整数,这个数是读入字符的ASCII码值.
       如果没有指定<文件描述符>,并且在键盘输入缓冲区中没有字符,那么READ-CHAR等待用
    户键入一些数据(最后打回车).例如,假设键盘的输入缓冲区是空的:
         (read-char)
       将等待用户输入.如果用户键入了"ABC"并打了RETURN,那么READ-CHAR将返回65(即为字
    母"A"的ASCII码).对READ-CHAR的以后三次调用将分别返回66,67和10(即为换行符).如果
    再一次调用READ-CHAR,它又将等待输入.
       AutoCAD与AutoLISP能在数种操作系统版本下运行.这些系统采用不同的约定来表示ASC
    II文本文件中的行结束符.例如,UNIX用单个换行符(LF,即ASCII码10),而MS-DOS,PC-DOS使
    用两个字符(CR/LF,即ASCII码13和10)来完成同一任务.为了便于开发AutoLISP程序,使它
    们能在所有支持的操作系统下以可移植方式工作,READ-CHAR接受全部上述约定,只要发现
    一个行结束符(或字符串),就返回单个换行符(ASCII代码10).

    99   (read-line [ <文件描述符> ] )
       这个函数从键盘或从由<文件描述符>表示的打开文件中读入一个字符串.如果遇到了文
    件结束符,READ-LINE将返回nil;否则它返回所读的字符串.例如,假设f是有效的打开文件
    指针,那么:
         (read-line f)
       将返回这个文件中的下一个输入行;若读到文件尾,则返回nil.

    100 (redraw [ <实体名> [<方式>] ] )
       本函数的作用取决于给出变元的个数.如果本函数的调用中没给出变元:
         (redraw)
    那么将重画当前视图,就如AutoCAD的REDRAW命令一样.如果在调用中给出一个实体名变元:
         (redraw <ename> )
    那么将重画选中的实体.在使用GRCLEAR清除屏幕后,使用本函数可在屏幕上标识出所需的
    实体,这是很有用的.有关实体名的说明参见本手册第五章.
       如果在REDRAW调用中给出两个变元,那么就完全控制了实体的重画效应.
         (redraw <ename> <mode> )
       这里<实体名>是要重画的实体名,<方式>是一个整数,具有下列值之一:

        重画方式                 作用
    ----------------------------------------------------------------
           1             在屏幕上重画实体
           2             不画实体(隐去)
           3             加亮实体(若显示器具有加亮显示的功能)
           4             不加亮实体(若显示器具有去除加亮显示的功能)

       若<实体名>代表一个复杂实体(多义线或具有属性的块)的头实体(即主实体)时,则当<
    方式>变元为正值,将处理主实体及其所有的子实体.当<方式>变元为负值,REDRAW将只对头
    实体进行操作.

    展开全文
  • 导读:Graph kernel可以直观地理解为测量相似度的函数。它们允许如支持向量机之类的内核化学习算法直接在上工作,而不需要进行特征提取即可将其转换为固定长度的实值特征向量。个简...
  • 函数调用过程中的栈帧结构及其变化

    千次阅读 多人点赞 2018-04-28 02:34:42
    描述了栈帧的通用结构。栈帧是段有界限的内存区间,由最顶端的两个指针界定,寄存器%ebp为帧指针,而寄存器%esp为栈指针(也就是说寄存器%ebp保存了所分配内存的最高地址,寄存器%esp保存了所分配...
  • 经验风险:个损失函数函数结构风险:可简单理解为经验风险(种损失函数函数)+λ正则化项。因此,模型的结构风险函数包括了经验风险项和正则项,通常可以表示成如下式子:θ∗=argminθ1N∑i=1NL(yi,f(xi;θ...
  • Win32 API∶绘图函数

    万次阅读 2010-12-11 12:53:00
    二、创建GDI绘图对象 <br /> 今天我们要讨论的是Win32 API中最有有趣的部分───用绘图函数完成图形输出。可以说,所有前面讲的内容都是本课程的前期准备。当时,我们在一些试例程序中偶尔用了一些绘图...
  • 知识点总结-数据结构

    千次阅读 2018-12-19 23:34:51
    的基本概念和术语 1.之间的关系可以是任意的,任意两个数据元素之间都可能相关。 2.顶点:数据元素。 3.边or弧:从个顶点到另个顶点的路径。&lt;V, W&gt;表示弧,(V,W)表示边,V是弧尾,W...
  • 做机器学习项目的时候总是遇到经验风险、结构风险、正则化项等这些概念,还有损失函数最小化问题,今天我们就来详细地总结下这些概念。
  • hash函数的基本知识

    千次阅读 2015-04-15 15:06:43
    Hash函数也称为散列表,是种常用的数据结构。哈希表优点:可以提供快速插入和查找操作,无论有多少数据项,插入与查找只需接近常量的实际:O(1)时间级。而且编程很容易实现。哈希表的缺点:它是基于数组的,数组...
  • 因此树其实也是种特殊的图结构,树的每个节点只能有个入度,而可以有多个,知识点在这里解不讲解了,例如弧,入度,出度等可以查阅书籍或者网上查阅。这里主要讲解的存储结构,遍历方法等。 的存储...
  • 数据结构无向图简单路径

    千次阅读 2019-07-06 00:25:46
    数据结构无向图简单路径 .课程设计目的和要求 目的:锻炼学生对软件界面设计并进行实现的实践能力。 要求:(1)完成课程设计所给的所有功能。 (2)根据课程设计的特点设计出相应的画面。 二.课程设计环境 ...
  • 编程小知识之 struct 构造函数(C#)

    千次阅读 2019-08-31 12:24:52
    本文简单介绍了 C# 中 struct 构造函数的一些知识~ struct(结构) 类型在 C# 中属于值类型(value type),其构造函数有一些限制: struct 有参构造函数中必须为所有成员(包括自动实现的属性,后面对于这点的说明从略)...
  • WIN32 API:绘图函数

    千次阅读 2014-01-26 01:42:19
    今天我们要讨论的是Win32 API中最有有趣的部分───用绘图函数完成图形输出。可以说,所有前面讲的内容都是本课程的前期准备。当时,我们在一些试例程序中偶尔用了一些绘图函数,可能当时您有些不太好理解。没有...
  • C++基础知识)—— C++程序结构

    千次阅读 多人点赞 2016-05-22 11:30:56
    下面我们从个最简单的程序入手看个C++程序的组成结构。 // my first program in C++ #include using namespace std; int main() {  cout  return 0; } Hello World!  上面左侧显示了我们的第个...
  • 以sigmoid函数作为神经元的激励函数为例,这个大家可能稍微熟悉一点,毕竟我们逻辑回归部分重点提到了这个非线性的函数,把输入值压缩成0-1之间的个概率值。而通过这个非线性映射和设定的阈值,我们可以把空间切...
  • 4.1 函数的基本知识 如果函数定义中省略了返回值类型,则默认为int类型。 练习4-1 编写函数strindex(s, t),它返回字符串t在s中最右边出现的位置。 如果s中不包含t,则返回-1。 答: #include int ...
  • 而且自己还没有特别去梳理自己对前端知识结构的理解,使得在分类的时候层级也有些模糊。所以在这里梳理一下自己理解中的知识结构。 这既是篇总结,也是篇指南,有些地方我自己亲身经历可能丰富一点,就说的多...
  • 数据结构与算法必知基础知识

    千次阅读 多人点赞 2021-01-06 22:58:12
    数据结构与算法是程序员内功体现的重要标准之,且数据结构也应用在各个方面,业界更有程序=数据结构+算法这个等式存在。各个中间件开发者,架构师他们都在努力的优化中间件、项目结构以及算法提高运行效率和降低...
  • 回调函数:Callback Function 什么是回调函数? 首先做个形象的比喻:  你有个任务,但是有部分你不会做,或者说不愿做,所以我来帮你做这部分,你做你其它的任务工作或者等着我的消息,但是当我完成的...
  • 数据结构知识点汇总

    万次阅读 多人点赞 2018-07-18 15:44:21
    4、栈通常采用的两种存储结构是(线性存储结构和链表存储结构) 5、队列具有(先进先出)的特征,栈具有(后进先出)的特征。 6、链表(插入和删除不需要移动元素,但是无法随机访问任一元素) 7、循环链表的主要...
  • 数据结构知识点总结(

    千次阅读 2018-11-06 15:22:30
    4、栈通常采用的两种存储结构是(线性存储结构和链表存储结构) 5、队列具有(先进先出)的特征,栈具有(后进先出)的特征。 6、链表(插入和删除不需要移动元素,但是无法随机访问任一元素) 7、循环链表的主要...
  • Python 里为什么函数可以返回函数内部定义的函数? Python 初学。 看@函数修饰符的例子。看到个这样的例子 def spamrun(fn): def sayspam(*args): print "spam,spam,spam" return sayspam 内部定义的...
  • 初识LISP(2)——结构、循环与函数

    千次阅读 2017-04-08 13:51:17
    、LISP—决策 Construct ...在最简单的形式,它后面跟着个测试条,测试操作和一些其它相应措施()。如果测试子句的值为true,那么测试的动作被执行,否则,由此产生的子句求值。 when
  • 2018山西专升本数据结构知识点总结

    万次阅读 多人点赞 2018-06-29 19:41:36
    2018山西专升本数据结构知识点总结
  • 数据结构知识

    千次阅读 多人点赞 2018-09-07 14:32:51
    1 基本概念 1.1 数据关系 数据项→→\to 数据元素→→\to 数据对象→→\to 数据 1.2 逻辑结构和物理结构
  • 学会参数传递机制,lambda表达式,函数式编程针不戳
  • 数据结构学习--绪论

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 223,419
精华内容 89,367
关键字:

一次函数的知识结构图简单