精华内容
下载资源
问答
  • 一.数据结构分类 数据的逻辑结构 ...链式存储结构:使用若干地址分散存储单元存储数据元素,逻辑上相邻数据元素在物理位置上不一定相邻,数据元素之间的关系需要采用附加信息特别指定。c语言采

    一.数据结构分类
    数据的逻辑结构
    1.集合:数据结构中的元素之间除了“同属一个集合” 的相互关系外,别无其他关系;
    2.线性结构:数据结构中的元素存在一对一的相互关系;
    3.树形结构:数据结构中的元素存在一对多的相互关系;
    4.图形结构:数据结构中的元素存在多对多的相互关系。

    数据的存储结构:
    顺序存储结构:数据元素在内存中的物理存储顺序与他们的逻辑顺序相同
    链式存储结构:使用若干地址分散的存储单元存储数据元素,逻辑上相邻的数据元素在物理位置上不一定相邻,数据元素之间的关系需要采用附加信息特别指定。c语言采用指针,Java采用引用指定。

    线性结构和非线性结构两类
    线性结构:最多只有一个直接前趋结点(第一个没有)和一个直接后继结点。栈、队列和串等都属于线性结构
    非线性结构:可能有多个直接前趋结点和多个直接后继结点,数组、广义表、树结构和图

    数据结构分类
    数据结构是指相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成 。
    常用的数据结构有:数组,栈,链表,队列,树,图,堆,散列表等,如图所示:
    在这里插入图片描述
    每一种数据结构都有着独特的数据存储方式,下面为大家介绍它们的结构和优缺点。

    二.八种常见数据结构
    1、数组
    数组是可以再内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问,数组下标从0开始。例如下面这段代码就是将数组的第一个元素赋值为 1。

    int[] data = new int[100];data[0] = 1;
    1
    2
    优点:
    1、按照索引查询元素速度快
    2、按照索引遍历数组方便

    缺点:
    1、数组的大小固定后就无法扩容了
    2、数组只能存储一种类型的数据
    3、添加,删除的操作慢,因为要移动其他的元素。

    适用场景:
    频繁查询,对存储空间要求不大,很少增加和删除的情况。

    2、栈
    栈是一种特殊的线性表,仅能在线性表的一端操作,栈顶允许操作,栈底不允许操作。 栈的特点是:先进后出,或者说是后进先出,从栈顶放入元素的操作叫入栈,取出元素叫出栈。
    在这里插入图片描述
    栈的结构就像一个集装箱,越先放进去的东西越晚才能拿出来,所以,栈常应用于实现递归功能方面的场景,例如斐波那契数列。

    3、队列
    队列与栈一样,也是一种线性表,不同的是,队列可以在一端添加元素,在另一端取出元素,也就是:先进先出。从一端放入元素的操作称为入队,取出元素为出队,示例图如下:
    在这里插入图片描述
    使用场景:因为队列先进先出的特点,在多线程阻塞队列管理中非常适用。

    4、链表
    链表是物理存储单元上非连续的、非顺序的存储结构,数据元素的逻辑顺序是通过链表的指针地址实现,每个元素包含两个结点,一个是存储元素的数据域 (内存空间),另一个是指向下一个结点地址的指针域。根据指针的指向,链表能形成不同的结构,例如单链表,双向链表,循环链表等。
    在这里插入图片描述
    链表的优点:
    链表是很常用的一种数据结构,不需要初始化容量,可以任意加减元素;
    添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可,所以添加,删除很快;

    缺点:
    因为含有大量的指针域,占用空间较大;
    查找元素需要遍历链表来查找,非常耗时。

    适用场景:
    数据量较小,需要频繁增加,删除操作的场景

    5、树
    树是一种数据结构,它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。它具有以下的特点:

    每个节点有零个或多个子节点;
    没有父节点的节点称为根节点;
    每一个非根节点有且只有一个父节点;
    除了根节点外,每个子节点可以分为多个不相交的子树;
    在日常的应用中,我们讨论和用的更多的是树的其中一种结构,就是二叉树。
    在这里插入图片描述
    二叉树是树的特殊一种,具有如下特点:

    1、每个结点最多有两颗子树,结点的度最大为2。
    2、左子树和右子树是有顺序的,次序不能颠倒。
    3、即使某结点只有一个子树,也要区分左右子树。

    二叉树是一种比较有用的折中方案,它添加,删除元素都很快,并且在查找方面也有很多的算法优化,所以,二叉树既有链表的好处,也有数组的好处,是两者的优化方案,在处理大批量的动态数据方面非常有用。

    红黑树,是在JDK1.8之后在HashMap中数据结构的升级
    一种树结构如 98(节点:存贮着key,value)
    78 125
    51 89 118 169

    右边值大于中间值,中间值大于左边值,当条件查询查询key为125的值时,如果不加索引那么将进行6次磁盘I/O,如果添加索引将只要进行2次磁盘I/O.
    查询流程: 直接从key为98的值根元素开始查询(1次磁盘I/O),发现125大于98向右边查询找到125(2次磁盘I/O).
    不足:但如果数据量太大树的高度还是很高

    BTree(mysql)
    与红黑树一样但是在其每个节点中存储着多个key,value,当查询某条数据时会将这个节点所有的key,value都读取到内存中RAM,在RAM在找出对应的key(RAM中处理的非常快,时间可以忽略不计)
    78 118
    51 89 98 125 169
    78和118为一个节点,51为一个节点,89和98为一个节点,125和169为一个节点.
    当查询169时只有2次磁盘I/O,第一次磁盘I/O找到78个118,第二次磁盘I/O找到125和169这个节点,然后将这个节点读取到内存中处理.

    B+Tree
    B+Tree是BTree的改进版在节点与节点之间多了一个指针,只在树叶(树末梢)有value但这个value将不再是地址指针而是直接存放数据,上一个节点的key将遗留到下一个节点中.目的为了便于范围查询,如查询>98的记录,没有这个指针,需要重新从根节点找,没有这个遗留的节点,因为一次磁盘I/O不能读取太多数据
    78 118 (只有key)
    51 ->78 89 98 ->118 125 169 (都有key,data)

    存储引擎针对与表,一个数据库可以有两个不同存储引擎的表
    MyISAM (BTree)
    数据库文件下,data下的表文件夹中
    frm文件:存储的是建表结构,即查看表对象中的内容,create… 主外键
    MYD(MyISAM Data)文件:存储的是表中的数据
    MYI(MyISAM Index)文件:存储的是表中的key和数据地址指针(即BTree)
    当在数据库中查询时,如果发现有磁盘中有MYI文件(即添加了索引),会在索引中找到对应的节点,根据value的值(地址指针),去MYD文件中找到对应的地址

    InnoDB (B+Tree)
    数据库文件下,data下的表文件夹中
    frm文件:存储的是建表结构,即查看表对象中的内容,create… 主外键
    idb文件(index data):存储的是key和数据(B+Tree)

    非聚集索引,将索引与数据分开,即用MYI和MYD分开(MyISAM)
    聚集索引,将索引与数据结合在一起,即使用idb文件把索引与数据结合(InnoDB)

    mysql读取数据流程:cpu->RAM>磁盘
    页/4K(4*1024B(字节)) 一次磁盘I/O只能读取正数页,一次性不能读取太多数据,所以一个节点不能存放太多数据
    查看mysql文件页大小:show global status like ‘Innodb_page_size’ (官方默认16K)

    6、散列表
    散列表,也叫哈希表,是根据关键码和值 (key和value) 直接进行访问的数据结构,通过key和value来映射到集合中的一个位置,这样就可以很快找到集合中的对应元素。

    记录的存储位置=f(key)

    这里的对应关系 f 成为散列函数,又称为哈希 (hash函数),而散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字,然后就将该数字对数组长度进行取余,取余结果就当作数组的下标,将value存储在以该数字为下标的数组空间里,这种存储空间可以充分利用数组的查找优势来查找元素,所以查找的速度很快。

    哈希表在应用中也是比较常见的,就如Java中有些集合类就是借鉴了哈希原理构造的,例如HashMap,HashTable等,利用hash表的优势,对于集合的查找元素时非常方便的,然而,因为哈希表是基于数组衍生的数据结构,在添加删除元素方面是比较慢的,所以很多时候需要用到一种数组链表来做,也就是拉链法。拉链法是数组结合链表的一种结构,较早前的hashMap底层的存储就是采用这种结构,直到jdk1.8之后才换成了数组加红黑树的结构,其示例图如下:
    在这里插入图片描述
    从图中可以看出,左边很明显是个数组,数组的每个成员包括一个指针,指向一个链表的头,当然这个链表可能为空,也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去,也是根据这些特征,找到正确的链表,再从链表中找出这个元素。

    哈希表的应用场景很多,当然也有很多问题要考虑,比如哈希冲突的问题,如果处理的不好会浪费大量的时间,导致应用崩溃。

    7、堆
    堆是一种比较特殊的数据结构,可以被看做一棵树的数组对象,具有以下的性质:

    堆中某个节点的值总是不大于或不小于其父节点的值;

    堆总是一棵完全二叉树。

    将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。常见的堆有二叉堆、斐波那契堆等。

    堆的定义如下:n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时,称之为堆。
    (ki <= k2i,ki <= k2i+1)或者(ki >= k2i,ki >= k2i+1), (i = 1,2,3,4…n/2),满足前者的表达式的成为小顶堆,满足后者表达式的为大顶堆,这两者的结构图可以用完全二叉树排列出来,示例图如下:
    在这里插入图片描述
    因为堆有序的特点,一般用来做数组中的排序,称为堆排序。

    8、图
    图是由结点的有穷集合V和边的集合E组成。其中,为了与树形结构加以区别,在图结构中常常将结点称为顶点,边是顶点的有序偶对,若两个顶点之间存在一条边,就表示这两个顶点具有相邻关系。

    按照顶点指向的方向可分为无向图和有向图:
    在这里插入图片描述
    在这里插入图片描述
    图是一种比较复杂的数据结构,在存储数据上有着比较复杂和高效的算法,分别有邻接矩阵 、邻接表、十字链表、邻接多重表、边集数组等存储结构,这里不做展开,读者有兴趣可以自己学习深入。

    原文链接:https://blog.csdn.net/yeyazhishang/article/details/82353846

    展开全文
  • 数据结构是指,相互之间存在着一或多种关系的数据元素集合和该集合中数据元素之间的关系组成。常用数据结构有:数组、栈、队列、链表、树、散列表、堆、图。 一、结构分类: 数据结构大多是以三分类...

    数据结构目录:

    一、结构分类
    二、区别联系
    1. 数组
    2. 栈
    3. 队列
    4. 链表
    5. 树
    6. 散列表
    7. 堆
    8. 图

    数据结构是指,相互之间存在着一种或多种关系的数据元素的集合和该集合中数据元素之间的关系组成。常用的数据结构有:数组、栈、队列、链表、树、散列表、堆、图。
    在这里插入图片描述

    一、结构分类:

    数据结构大多是以三种分类方式分类,分别是逻辑结构,物理结构,存储结构,一般来讲大多是以逻辑结构进行分类

    (1)线性结构:
    线性结构就是表中哥哥节点具体有线性关系,如果从数据结构的语言来描述,则线性结构:
    (1.1)、线性结构是非空集
    (1.2)、线性结构有且仅有一个开始点和一个终端节点
    (1.3)、线性结构所有节点最多只有哦一个直接前趋节点和一个直接后继节点
    数组(Array)、栈(Stack)、队列(Queue)、链表(Linked List)等数据的逻辑结构的属于线性表

    (2)非线性结构:
    非线性结构就是表中的各个节点之间具有多个对应关系。如果从数据结构语言来描述,有以下特点:
    (2.1)、非线性结构是非空集。
    (2.2)、非线性结构的一个结点可能有多个直接前趋结点和多个直接后继结点。
    树( Tree)、散列表(Hash)、堆(Heap)、图(Graph)等数据的逻辑结构都属于非线性结构。

    二、区别和联系:

    每一种数据结构都有独特的数据存储方式,下边就是区别和联系
    1、数组
    数组是可以再内存中连续存储多个元素的结构,在内存中的分配也是连续的,数组中的元素通过数组下标进行访问,数组下标从0开始。 例如下面这段代码就是将数组的第一个元素赋值为 1
    int [] arrs = new int[100];  arrs[0]=1; 
    

    优点:
    1、按照索引查询元素速度快
    2、按照索引遍历数组方便
    缺点:
    1、数组的大小固定后就无法扩容了
    2、数组只能存储一种类型的数据
    3、添加,删除的操作慢,因为要移动其他的元素。
    适用场景:
    频繁查询,对存储空间要求不大,很少增加和删除的情况。

    2、栈
    栈是一种特殊的线性表,仅能在线性表的一端操作,栈顶允许操作,栈底不允许操作。 栈的特点是:先进后出,或者说是后进先出,从栈顶放入元素的操作叫入栈,取出元素叫出栈。 栈的结构就像一个集装箱,越先放进去的东西越晚才能拿出来,所以,栈常应用于实现递归功能方面的场景,例如斐波那契数列。

    栈参考案例:https://blog.csdn.net/weixin_43062845/article/details/100007546

    3、队列
    队列与栈一样,也是一种线性表,不同的是,队列可以在一端添加元素,在另一端取出元素,也就是:先进先出。从一端放入元素的操作称为入队,取出元素为出队。 使用场景:因为队列先进先出的特点,在多线程阻塞队列管理中非常适用。

    队列参考案例:
    https://blog.csdn.net/weixin_43062845/article/details/100135200

    4、链表
    链表是物理存储单元上非连续的、非顺序的存储结构,数据元素的逻辑顺序是通过链表的指针地址实现,每个元素包含两个结点,一个是存储元素的数据域 (内存空间),另一个是指向下一个结点地址的指针域。根据指针的指向,链表能形成不同的结构,例如单链表,双向链表,循环链表等。

    链表的优点:
    链表是很常用的一种数据结构,不需要初始化容量,可以任意加减元素;
    添加或者删除元素时只需要改变前后两个元素结点的指针域指向地址即可,所以添加,删除很快;

    缺点:
    因为含有大量的指针域,占用空间较大;
    查找元素需要遍历链表来查找,非常耗时。

    适用场景:
    数据量较小,需要频繁增加,删除操作的场景

    单链表参考案例:https://blog.csdn.net/weixin_43062845/article/details/100768147
    循环链表参考:更新ing…
    双向链表参考:更新ing…

    5、树
    树是一种数据结构,它是由n(n>=1)个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。它具有以下的特点: 1.每个节点有零个或多个子节点 2.没有父节点的节点称为根节点 3.每一个非根节点有且只有一个父节点 4.除了根节点,每个子节点可以分为多个不想交的子树

    在这里插入图片描述
    在日常的应用中,我们讨论和用的更多的是树的其中一种结构,就是二叉树。
    二叉树是树的特殊一种,具有如下特点:
    1、每个结点最多有两颗子树,结点的度最大为2。
    2、左子树和右子树是有顺序的,次序不能颠倒。
    3、即使某结点只有一个子树,也要区分左右子树。

    二叉树是一种比较有用的折中方案,它添加,删除元素都很快,并且在查找方面也有很多的算法优化,所以,二叉树既有链表的好处,也有数组的好处,是两者的优化方案,在处理大批量的动态数据方面非常有用。

    扩展:
    二叉树有很多扩展的数据结构,包括平衡二叉树、红黑树、B+树等,这些数据结构二叉树的基础上衍生了很多的功能,在实际应用中广泛用到,例如mysql的数据库索引结构用的就是B+树,还有HashMap的底层源码中用到了红黑树。这些二叉树的功能强大,但算法上比较复杂,还需要深入研究。

    树代码实现参考:更新ing…

    6、散列表

    散列表,也叫哈希表,是根据关键码和值 (key和value) 直接进行访问的数据结构,通过key和value来映射到集合中的一个位置,这样就可以很快找到集合中的对应元素。
    记录的存储位置=f(key)
    这里的对应关系 f 成为散列函数,又称为哈希 (hash函数),而散列表就是把Key通过一个固定的算法函数既所谓的哈希函数转换成一个整型数字,然后就将该数字对数组长度进行取余,取余结果就当作数组的下标,将value存储在以该数字为下标的数组空间里,这种存储空间可以充分利用数组的查找优势来查找元素,所以查找的速度很快。

    哈希表在应用中也是比较常见的,例如HashMap,HashTable等,利用hash表的优势,对于集合的查找元素时非常方便的,然而,因为哈希表是基于数组衍生的数据结构,在添加删除元素方面是比较慢的,所以很多时候需要用到一种数组链表来做,也就是拉链法。拉链法是数组结合链表的一种结构,较早前的hashMap底层的存储就是采用这种结构,直到jdk1.8之后才换成了数组加红黑树的结构,其示例图如下:
    在这里插入图片描述
    图左边是个数组,数组的每个成员包括一个指针,指向一个链表的头,当然这个链表可能为空,也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去,也是根据这些特征,找到正确的链表,再从链表中找出这个元素。

    哈希表的应用场景很多,当然也有很多问题要考虑,比如哈希冲突的问题,如果处理的不好会浪费大量的时间,导致应用崩溃。

    散列表代码实现参考:更新ing…

    7、堆
    堆是一种比较特殊的数据结构,可以被看做一棵树的数组对象,具有以下的性质: 1.堆中某个节点的值总是不大于或不小于其父节点的值: 2.堆总是一颗完全二叉树

    根节点值最大的堆叫大顶堆或最大堆,根节点值最小的堆叫做最小堆或小顶堆。常见的堆有二叉堆、斐波那契堆等。
    堆的定义如下:n个元素的序列{k1,k2,ki,…,kn}当且仅当满足下关系时,称之为堆。
    满足(ki >= k2i,ki >= k2i+1):为大顶堆
    满足:(ki <= k2i,ki <= k2i+1):为小丁堆
    这两者的结构图可以用完全二叉树排列出来,示例图如下:
    在这里插入图片描述
    因为堆有序的特点,一般用来做数组中的排序,称为堆排序。

    堆的代码实现参考:更新ing…

    8、图
    图是由结点的有穷集合V和边的集合E组成。其中,为了与树形结构加以区别,在图结构中常常将结点称为顶点,边是顶点的有序偶对,若两个顶点之间存在一条边,就表示这两个顶点具有相邻关系。 按照顶点指向的方向可分为无向图和有向图:

    在这里插入图片描述
    图是一种比较复杂的数据结构,在存储数据上有着比较复杂和高效的算法,分别有邻接矩阵 、邻接表、十字链表、邻接多重表、边集数组等存储结构,这里不做展开,读者有兴趣可以自己学习深入。

    图的代码实现参考:更新ing…

    展开全文
  • 1、用户模块电路 主要完成BORSCHT七功能,它由下列电路组成: A、 用户线接口电路 B、 二\四线变换器 C、 PCM编译码电路 用户线接口电路 二/ 四线变换器 二/四线变换器 用户线接口电路 用户1 PCM CODEC电路 ...
  • 【学习】概念模式

    2019-09-01 18:29:26
    常见的概念模式有八种: 框图:描述程序执行的逻辑过程。基本步骤有:处理、判断、输入输出、起始和终结。 结构图:用来表示软件的层次结构,表示模块的调用关系,有顺序调用、选择调用、循环调用。但是细节之处...

    概念模式是人们在认识事物的过程中,对于某一类事物或一系统形成的框架,也可以称之为“认识”。

     

    常见的概念模式有八种:

    框图:描述程序执行的逻辑过程。基本步骤有:处理、判断、输入输出、起始和终结。

    结构图:用来表示软件的层次结构,表示模块的调用关系,有顺序调用、选择调用、循环调用。但是细节之处需要用到框图来补充。

    数据流程图:描述业务处理信息的来源、存储、处理和去向的全局状态。

    实体关系图:也就是E-R图,是描述静态数据结构的概念模式。

    数据字典:描述数据内容,以表格形式列出数据的基本属性和相互关系。

    时序网络:描述系统状态和转换方式。

    数学与逻辑模型:使用数学公式和逻辑表达式来描述客观系统的状态和运动规律,常用决策树和决策表。

    计算机模拟模型:利用计算机大量、高速处理信息的能力。

     

    关于这八种概念模式,可以把它分为两大类。

    展开全文
  •  C++是在C语言基础上开发集面向对象编程、通用编程和传统过程化编程于一体编程语言, 是C语言超集。本书是根据2003年ISO/ANSI C++标准编写,通过大量短小精悍程序详细而全面地阐 述了C++基本...
  •  C++是在C语言基础上开发集面向对象编程、通用编程和传统过程化编程于一体编程语言, 是C语言超集。本书是根据2003年ISO/ANSI C++标准编写,通过大量短小精悍程序详细而全面地阐 述了C++基本...
  •  C++是在C语言基础上开发集面向对象编程、通用编程和传统过程化编程于一体编程语言, 是C语言超集。本书是根据2003年ISO/ANSI C++标准编写,通过大量短小精悍程序详细而全面地阐 述了C++基本...
  • FAQ(常见问题解答)、 BBS、聊天室等各种即时信息服务,在线收听、收视、订购、付款等选择性服务,无假日服务和信息跟踪、信息定制到智能化信息转移,网上选购,送货到家上门服务等等,将极大提高顾客满意度...
  • 本文目录 一、算术运算符 二、赋值运算符 三、自增运算符和自减运算符 四、sizeof ...六、关系运算符 ...七、逻辑运算符 ...、三目运算符 ...C语言一共有34运算符,包括了常见的加减乘除运算。这讲就对...

    计算机的基本能力就是计算,所以一门程序设计语言的计算能力是非常重要的。C语言之所以无所不能,是因为它不仅有丰富的数据类型,还有强大的计算能力。C语言一共有34种运算符,包括了常见的加减乘除运算。这讲就对C语言中的运算符做一个详细介绍。

    一、算术运算符

    算术运算符非常地简单,就是小学数学里面的一些加减乘除操作。不过呢,还是有一些语法细节需要注意的。

    1.加法运算符 + 

    1 int a = 10;
    2 
    3 int b = a + 5;

    在第3行利用加法运算符 + 进行了加法运算,再将和赋值给了变量b,最终变量b的值是15

     

    2.减法运算符 或 负值运算符 - 

    1 int b = 10 - 5;
    2 
    3 int a = -10;

    1> 在第1行利用减法运算符 - 进行了减法运算,再将差赋值给了变量b,最终变量b的值是5

    2> 在第3行中,这个 - 并不是什么减法运算符,而算是一个负值运算符,-10代表的是负十

     

    3.乘法运算符 * 

    1 int b = 10 * 5;

    注意:乘法运算符并不是x或者X,而是星号*。变量b最终的值是50。

     

    4.除法运算符 / 

    1 double a = 10.0 / 4;
    2 double b = 10 / 4;
    3  
    4 printf("a=%f, b=%f \n", a, b);

    注意:除法运算符并不是÷,而是一个正斜杠 /

    1> 第1行中的10.0是浮点型,4是整型,因此会将4自动类型提升为浮点型后再进行运算,最后变量b的值是2.5

    2> 第2行中的10和4都是整型,计算机中的运算有个原则:相同数据类型的值才能进行运算,而且运算结果依然是同一种数据类型。因此,整数除于整数,求出来的结果依然是整数,会损失小数部分。最后变量b的值是2。查看输出结果:

    3> 如果想让 整数除于整数 不损失精度的话,可以将某个整数强制转换为浮点型数据

    复制代码
    1 double a = (double)10 / 4;
    2 
    3 double b = 10 / (double)4;
    4 
    5 double c = (double)10 / (double)4;
    6 
    7 double d = (double) (10 / 4);
    复制代码
    • 10和4之间只要有1个强转为浮点型数据即可,另外1个整数会自动类型提升为浮点型数据。因此,变量a、b、c的值都是2.5。
    • 变量d的情况就不一样了,第7行代码的意思是先计算(10/4)的值,再将(10/4)的值强转为浮点型数据。(10/4)的值是2,将2强转为浮点型数据,那不也就是2么?所以,变量d的值是2

     

    5.模运算符 或称 取余运算符 % 

    注意:这个%并不是除号÷,它是一个取余运算符,或者叫做模运算符。取余的意思是,取得两个整数相除之后的余数。比如,5除于2的余数是1,5除于3的余数是2。因此使用这个%有个原则:%两侧必须都为整数。下面的写法是错误的:

    1 int a = 5.0 % 2;

    编译器会直接报错,因为5.0并非整数。

    1> 正数取余

    1 int a = 5 % 2;
    2 int b = 2 % 5;

    简单计算可得:变量a的值为1,变量b的值为2

     2> 负数取余

    1 int a = -5 % 2;
    2 int b = 5 % -2;
    3 int c = -5 % -2; 

    利用%求出来的余数是正数还是负数,由%左边的被除数决定,被除数是正数,余数就是正数,反之则反。因此变量a、b、c的值分别是-1、1、-1

     

    6.运算顺序

    1> 算术表达式

    用算术运算符将数据连接起来的式子,称为“算术表达式”。比如a + b、10 * 5等。如果表达式比较复杂的话,那么就要注意一下它的运算顺序。表达式的运算顺序是按照运算符的结合方向和优先级进行的。

    2> 结合方向

    算术运算符的结合方向是从左到右。例如表达式2+3+4,先计算2+3。

    3> 优先级

    优先级越高,就越先进行运算,当优先级相同时,参照结合方向。下面是算术运算符的优先级排序:

    负值运算符(-) > 乘(*)、除(/)、模(%)运算符 > 加(+)、减(-)运算符

    例如表达式4+5*8/-2的计算顺序为:-、*、/、+,最后的结果是-16

    4> 小括号

    如果需要先计算优先级低的可以使用小括号()括住,小括号的优先级是最高的!

    • 例如4+5*8-2默认的计算顺序是:*、+、-
    • 如果想先执行加法运算,就可以这样写:(4+5)*8-2,最后的结果都是不一样的

     

    二、赋值运算符

    赋值运算符又分两种:简单赋值运算符 和 复合赋值运算符。

    1.简单赋值运算符 =

    1> 简单用法

    其实这个等号 = 从讲变量开始就见过它了,它的作用是将右边的值赋值给左边。

    1 int a = 10 + 5;

    赋值运算符的结合方向是:从右到左,而且优先级比算术运算符低。因此先进行等号=右边的加法运算,运算完毕后再将结果赋值给等号右边的变量。最后变量a的值是15。

     

    2> 连续赋值

    1 int a, b;
    2 
    3 a = b = 10;
    • 在第1行分别定义了int类型的变量a、b
    • 第3行代码的意思:将10赋值给变量b,再把变量b的值赋值给a。所以最后变量a、b的值都是10

     

    3> 使用注意

    等号=左边只能是变量,不能是常量!常量都是不可变的,怎么可以再次赋值呢?下面的写法是错误的:

    1 10 = 10 + 5;

     

    2.复合赋值运算符

    • +=  加赋值运算符。如a += 3+2,等价于 a = a +(3+2)
    • -=  减赋值运算符。如a -= 3+2,等价于 a = a -(3+2)
    • *=  乘赋值运算符。如a *= 3+2,等价于 a = a *(3+2)
    • /=  除赋值运算符。如a /= 3+2,等价于 a = a /(3+2)
    • %=  取余赋值运算符。如a %= 3+2,等价于 a = a %(3+2)

     

    三、自增运算符和自减运算符

    1.简介

    • ++  自增运算符。如a++,++a,都等价于a = a+1
    • --  自减运算符。如a--,--a,都等价于a = a-1

    注意:你写个5++是错误的,因为5是常量。

     

    2.++a和a++的区别

    1> 单独使用++a和a++时,它们是没区别的

    1 int a = 10;
    2 a++;
    1 int a = 10;
    2 ++a;

    上面两段代码的效果都是让a的值+1,最后a的值都为11

     

    2> 下面这种情况,++a和a++就有区别了

    1 int a = 10;
    2 
    3 int b = ++a;
    1 int a = 10;
    2 
    3 int b = a++;

     上面两段代码的执行结果是有区别的。

    • 第1段代码:++a的意思是先对a执行+1操作,再将a的值赋值给b。因此最后a、b的值都是11
    • 第2段代码:a++的意思是先将a的值拷贝出来一份,然后对a执行+1操作,于是a变成了11,但是拷贝出来的值还是10,a++运算完毕后,再将拷贝出来的值10赋值给了b,所以最后变量b的值是10,变量a的值是11

    --a和a--的区别也是一样的。

     

    3> 再来看一个比较刁钻的例子

    1 int a = 10;
    2 
    3 a = a++;

    很多人一眼看上去,觉得最后a的值应该是11,其实最后a的值是10。前面已经说过a++的作用了,这里也是一样的。先将a的值拷贝出来一份,然后对a执行+1操作,于是a变成了11,但是拷贝出来的值还是10,a++运算完毕后,再将拷贝出来的值10赋值给了a,所以最后变量a的值是10

     

    四、sizeof

    * sizeof可以用来计算一个变量或者一个常量、一种数据类型所占的内存字节数。

    int size = sizeof(10);
    printf("10所占的字节数:%d", size);

    输出结果:,10是int类型的数据,在64bit编译器环境下,int类型需要占用4个字节

    * sizeof一共有3种形式

    • sizeof( 变量\常量 )
    sizeof(10);
    
    char c = 'a';
    sizeof(c);
    • sizeof  变量\常量
    sizeof 10;
    
    char c = 'a';
    sizeof c;
    • sizeof( 数据类型 )
    sizeof(float);

    注意,不可以写成sizeof float;

     

    五、逗号运算符

    * 逗号运算符主要用于连接表达式,例如:

    1 int a = 9;
    2 int b = 10;
    3 
    4 a = a+1 , b = 3*4;

    * 用逗号运算符连接起来的表达式称为逗号表达式,它的一般形式为:

    表达式1, 表达式2, … …, 表达式n

    逗号表达式的运算过程是:从左到右的顺序,先计算表达式1,接着计算表达式2,...,最后计算表达式n

    * 逗号运算符也是一种运算符,因此它也有运算结果。整个逗号表达式的值是最后一个表达式的值

    复制代码
    1 int a = 2;
    2 int b = 0;
    3 int c;
    4 
    5 c = (++a, a *= 2, b = a * 5);
    6 
    7 printf("c = %d", c);
    复制代码

     ++a的结果为3,a *= 2的结果为6,b = a * 5的结果为30。因此,输出结果为:

    这里要注意的是,右边的表达式是有用括号()包住的,如果不用括号包住,也就是:

    1 c = ++a, a *= 2, b = a * 5;
    2 printf("c = %d", c);

    输出结果将为:,因为c = ++a也属于逗号表达式的一部分,跟后面的a *= 2以及b = a * 5是相互独立的

     

    六、关系运算符

    1.“真”与“假”

    1> 默认情况下,我们在程序中写的每一句正确代码都会被执行。但很多时候,我们想在某个条件成立的情况下才执行某一段代码。比如微信的这个界面:

    如果用户点击了注册按钮,我们就执行“跳转到注册界面”的代码;如果用户点击了登录按钮,我们就执行“跳转到登录界面”的代码。如果用户没做出任何操作,就不执行前面所说的两段代码。像这种情况的话可以使用条件语句来完成,但是我们暂时不学习条件语句,先来看一些更基础的知识:如何判断一个条件成不成立。如果这个都不会判断,还执行什么代码。

    2> 在C语言中,条件成立称为“真”,条件不成立称为“假”,因此,判断条件是否成立,就是判断条件的“真假”。那怎么判断真假呢?C语言规定,任何非0值都为“真”,只有0才为“假”。也就是说,108、-18、4.5、-10.5等都是“真”,0则是“假”。

     

    2.关系运算符的简单使用

    C语言中还提供了一些关系运算符,可以用来比较两个数值的大小。

    • <   小于。比如a<5
    • <=  小于等于。比如a<=5
    • >   大于。比如a>5
    • >=  大于等于。比如a>=5
    • ==  等于。比如a==5
    • !=  不等于。比如a!=5

    关系运算符的运算结果只有2种:如果条件成立,结果就为1,也就是“真”;如果条件不成立,结果就为0,也就是“假”。

    1 int a1 = 5 > 4; // 1
    2 
    3 int a2 = 5 < 4; // 0

     

    3.关系运算符的使用注意

    1> 关系运算符中==、!=的优先级相等,<、<=、>、>=的优先级相等,且前者的优先级低于后者

    例如2==3>1 :先算3>1,条件成立,结果为1。再计算2==1,条件不成立,结果为0。因此2==3>1的结果为0。

    2> 关系运算符的结合方向为“从左往右”

    例如4>3>2 :先算4>3,条件成立,结果为1。再与2比较,即1>2,条件不成立,结果为0。因此4>3>2的结果为0。

    3> 关系运算符的优先级小于算术运算符

    例如3+4>8-2 :先计算3+4,结果为7。再计算8-2,结果为6。最后计算7>6,条件成立,结果为1。因此3+4>8-2的结果为1。

     

    七、逻辑运算符

     有时候,我们需要在多个条件同时成立的时候才能执行某段代码,比如:用户只有同时输入了QQ和密码,才能执行登录代码,如果只输入了QQ或者只输入了密码,就不能执行登录代码。这种情况下,我们就要借助于C语言提供的逻辑运算符。

    C语言提供了3个逻辑运算符:&&(逻辑与)、||(逻辑或)、!(逻辑非)。注意:这些都是英文字符,不要写成中文字符。跟关系运算符一样,逻辑运算的结果只有2个:“真”为1,“假”为0

    1.&& 逻辑与

    1> 使用格式

    “条件A && 条件B”

    2> 运算结果

    只有当条件A和条件B都成立时,结果才为1,也就是“真”;其余情况的结果都为0,也就是“假”。因此,条件A或条件B只要有一个不成立,结果都为0,也就是“假”

    3> 运算过程

    • 总是先判断条件A是否成立
    • 如果条件A成立,接着再判断条件B是否成立:如果条件B成立,“条件A && 条件B”的结果就为1,即“真”,如果条件B不成立,结果就为0,即“假”
    • 如果条件A不成立,就不会再去判断条件B是否成立:因为条件A已经不成立了,不管条件B如何,“条件A && 条件B”的结果肯定是0,也就是“假”

    4> 举例

    逻辑与的结合方向是“自左至右”。比如表达式 (a>3) && (a<5)

    • 若a的值是4:先判断a>3,成立;再判断a<5,也成立。因此结果为1
    • 若a的值是2:先判断a>3,不成立,停止判断。因此结果为0
    • 因此,如果a的值在(3, 5)这个范围内,结果就为1;否则,结果就为0

    5> 注意

    • 若想判断a的值是否在(3, 5)范围内,千万不能写成3<a<5,因为关系运算符的结合方向为“从左往右”。比如a为2,它会先算3<a,也就是3<2,条件不成立,结果为0。再与5比较,即0<5,条件成立,结果为1。因此3<a<5的结果为1,条件成立,也就是说当a的值为2时,a的值是在(3, 5)范围内的。这明显是不对的。正确的判断方法是:(a>3) && (a<5)
    • C语言规定:任何非0值都为“真”,只有0才为“假”。因此逻辑与也适用于数值。比如 5 && 4的结果是1,为“真”;-6 && 0的结果是0,为“假”

     

    2.||  逻辑或

    1> 使用格式

    “条件A || 条件B”

    2> 运算结果

    当条件A或条件B只要有一个成立时(也包括条件A和条件B都成立),结果就为1,也就是“真”;只有当条件A和条件B都不成立时,结果才为0,也就是“假”。

    3> 运算过程

    • 总是先判断条件A是否成立
    • 如果条件A成立,就不会再去判断条件B是否成立:因为条件A已经成立了,不管条件B如何,“条件A || 条件B”的结果肯定是1,也就是“真”
    • 如果条件A不成立,接着再判断条件B是否成立:如果条件B成立,“条件A || 条件B”的结果就为1,即“真”,如果条件B不成立,结果就为0,即“假”

    4> 举例

    逻辑或的结合方向是“自左至右”。比如表达式 (a<3) || (a>5)

    • 若a的值是4:先判断a<3,不成立;再判断a>5,也不成立。因此结果为0
    • 若a的值是2:先判断a<3,成立,停止判断。因此结果为1
    • 因此,如果a的值在(-∞, 3)或者(5, +∞)范围内,结果就为1;否则,结果就为0

     

    5> 注意

     C语言规定:任何非0值都为“真”,只有0才为“假”。因此逻辑或也适用于数值。比如 5 || 4的结果是1,为“真”;-6 || 0的结果是1,为“真”;0 || 0的结果是0,为“假”

     

    3.!   逻辑非

    1> 使用格式

    “! 条件A”

    2> 运算结果

    其实就是对条件A进行取反:若条件A成立,结果就为0,即“假”;若条件A不成立,结果就为1,即“真”。也就是说:真的变假,假的变真。

    3> 举例

    逻辑非的结合方向是“自右至左”。比如表达式 ! (a>5)

    • 若a的值是6:先判断a>5,成立,再取反之后的结果为0
    • 若a的值是2:先判断a>3,不成立,再取反之后的结果为1
    • 因此,如果a的值大于5,结果就为0;否则,结果就为1

    4> 注意

    • 可以多次连续使用逻辑非运算符:!(4>2)结果为0,是“假”,!!(4>2)结果为1,是“真”,!!!(4>2)结果为0,是“假”
    • C语言规定:任何非0值都为“真”,只有0才为“假”。因此,对非0值进行逻辑非!运算的结果都是0,对0值进行逻辑非!运算的结果为1。!5、!6.7、!-9的结果都为0,!0的结果为1

     

    4.优先级

    逻辑运算符的优先级顺序为: 小括号() > 负号 - > ! > 算术运算符 > 关系运算符 > && > ||

    • 表达式!(3>5) || (2<4) && (6<1) :先计算 !(3>5)、(2<4)、(6<1),结果为1,式子变为1 || 1 && 0,再计算1 && 0,式子变为1 || 0,最后的结果为1
    • 表达式3+2<5||6>3 等价于 ((3+2) < 5) || (6>3),结果为1
    • 表达式4>3 && !-5>2 等价于 (4>3) &&  ((!(-5)) > 2) ,结果为0

     

    八、三目运算符

    1.N目运算符

    • 像逻辑非(!)、负号(-)这种只连接一个数据的符号,称为“单目运算符”,比如!5、-5。
    • 像算术运算符、关系运算符、逻辑运算符这种连接二个数据的负号,称为“双目运算符”,比如6+7、8*5、5>6、4 && 0、
    • 以此类推,连接3个数据的运算符,应该称为“三目运算符”

     

    2.三目运算符

    C语言提供了唯一一个三目运算符:条件运算符。

    1> 使用格式

    表达式A ? 表达式B : 表达式C

    2> 运算结果

    如果表达式A成立,也就是为“真”,条件运算符的结果就是表达式B的值,否则,就为表达式C的值

    3> 结合方向和优先级

    • 优先级顺序为:算术运算符 > 关系运算符 > 条件运算符 > 赋值运算符
    • 条件运算符的结合方向是“从右至左”
    1 int a = 3>4 ? 4+5 : 5>4 ? 5+6 : 6>7+1;

    上面的代码等价于

    1 int a = (3>4) ? (4+5) : ( (5>4) ? (5+6) : (6>(7+1)) );

    简化一下就是

    1 int a = 0 ? 9 : ( 1 ? 11 : 0 );

    继续简化为

    1 int a = 0 ? 9 : 11;

    所以a的值是11

     

    九、位运算符

    所谓位运算就是对每一个二进制位进行运算。C语言一共提供了6种位运算符,只能对整数进行操作,分别是:&按位与、|按位或、^按位异或、<<左移、>>右移、~取反。

    1.& 按位与

    1> 使用形式:整数a & 整数b

    2> 功能:整数a和b各对应的二进位相与。只有对应的两个二进位均为1时,结果位才为1,否则为0。参与运算的数以补码方式出现。

    3> 举例:比如9&5,其实就是1001&101=1,因此9&5=1

    4> 规律:

    • 相同整数相&的结果是整数本身。比如5&5=5
    • 多个整数相&的结果跟顺序无关。比如5&6&7=5&7&6

     

    2.| 按位或

    1> 使用形式:整数a | 整数b

    2> 功能:整数a和b各对应的二进位相或。只要对应的二个二进位有一个为1时,结果位就为1,否则为0。参与运算的数以补码方式出现。

    3> 举例:比如9|5,其实就是1001|101=1101,因此9|5=13

    4> 规律:

    • 相同整数相|的结果是整数本身。比如5|5=5
    • 多个整数相|的结果跟顺序无关。比如5|6|7=5|7|6

     

    3.^ 按位异或

    1> 使用形式:整数a ^ 整数b

    2> 功能:整数a和b各对应的二进位相异或。当对应的二进位相异(不相同)时,结果为1,否则为0。参与运算的数以补码方式出现。

    3> 举例:比如9^5,其实就是1001^101=1100,因此9^5=12

    4> 规律:

    • 二进制中,与1相^就会取反,与0相^保持原位
    • 相同整数相^的结果是0。比如5^5=0
    • 多个整数相^的结果跟顺序无关。比如5^6^7=5^7^6
    • 因此得出结论:a^b^a = b

     

    4.~ 取反

    1> ~为单目运算符,具有右结合性,使用形式:~整数a

    2> 功能:对整数a的各二进位进行取反(0变1,1变0)

    3> 举例:比如~9,其实就是~(0000 0000 0000 0000 0000 0000 0000 1001)=(1111 1111 1111 1111 1111 1111 1111 0110),因此~9=-10

     

    5.<< 左移

    1> <<是双目运算符,使用形式:整数a<<正数n

    2> 功能:把整数a的各二进位全部左移n位,高位丢弃,低位补0。左移n位其实就是乘以2的n次方。

    3> 举例:3<<4,3本来是0000 0011,左移4位后变成了0011 0000,因此3<<4 = 48 = 3 * 24

    4> 需要注意的是:由于左移是丢弃最高位,0补最低位,所以符号位也会被丢弃,左移出来的结果值可能会改变正负性

     

    6.>> 右移

    1> >>是双目运算符,使用形式:整数a>>正数n

    2> 功能:把整数a的各二进位全部右移n位,保持符号位不变。右移n位其实就是除以2的n次方。

    3> 举例:32>>3,32本来是0010 0000,右移3位后变成了0000 0100,因此32>>3 = 4 = 32 / 23

     

    转载于:https://www.cnblogs.com/fgcs/p/4744561.html

    展开全文
  • c语言章节4

    2015-02-12 23:04:00
    本文目录 一、算术运算符 二、赋值运算符 三、自增运算符和自减运算符 四、sizeof ...六、关系运算符 ...七、逻辑运算符 ...、三目运算符 ...C语言一共有34运算符,包括了常见的加减乘除运算。这讲就对C语...
  • Sqlite 一款轻型数据库,是遵守ACID的关系型数据库管理系统,它包含在一个相对小C库中 W3C 万维网联盟,创建于1994年,是Web技术领域最具权威和影响力国际中立性技术标准机构。主要工作是发展 Web 规范,...
  • 培训第五天

    2021-01-22 23:00:46
    运算符优先级一定要记住,括号第一单目第二,乘除余三加减四,五位移六关系,等于不等排第七,与异或位或九十,逻辑与十一,逻辑或十二,条件运算是十三,赋值十四,逗号运算最低。类型转换前加要求转换类型,强制...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    统一建模语言是一通用可视化建模语言,用于对软件系统制品进行规范化、可视化处理,然后构造它们并建立它们文档。 UML发展过程 图 与 语言 谁一级棒? UML优势 过去数十面向对象建模语言各自为战...
  • asp.net知识库

    2015-06-18 08:45:45
    常见的 ASP.NET 2.0 转换问题和解决方案 Asp.Net2.0无刷新客户端回调 体验.net 2.0 的优雅(1) -- 异步WebService调用 ASP.NET 2.0页面框架的几点新功能 ASP.NET 2.0 中收集的小功能点 asp.net2.0中的webpart使用...
  • 常见的数据模型 1. 层次结构模型: 层次结构模型实质上是一有根结点的定向有序树,IMS(Information Manage-mentSystem)是其典型代表。 2. 网状结构模型:按照网状数据结构建立的数据库系统称为网状数据库系统,其...
  • 52、 常见的Caching技术有://ASP.NET Cache //数据库缓存 //通过静态变量缓存//Memory-Mapped Files 53、 授权包括://用户的权限//代码的执行权限 54、 在构思阶段,各种角色的职责是://根据质量目标提供反馈//...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题43 逻辑操作与其他操作的关系 45 面试题44 自增自减前操作与后操作区别 46 面试题45 指针自增自减有什么不同 47 4.3 变量 47 面试题46 什么是左值和右值 48 面试题47 什么是变量 48 面试题48 变量有哪几...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    7.5 逻辑操作符和逻辑表达式.68 7.6 位 运 算 .69 7.7 其它特殊操作符 .72 7.8 小 结 .77 第章 流 程 控 制 .79 8.1 条 件 语 句 .79 8.2 循 环 语 句 .86 8.3 条 件 编 译.90 8.4 异常处理语句 ....
  • 2.10常见的时间复杂度 35 有些时候,告诉你某些东西不可以去尝试,也是一知识的传递。总不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大...
  • 2.10常见的时间复杂度 35 有些时候,告诉你某些东西不可以去尝试,也是一知识的传递。总不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大...
  • 大话数据结构

    2019-01-10 16:35:22
    2.10常见的时间复杂度 35 有些时候,告诉你某些东西不可以去尝试,也是一知识的传递。总不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大...
  • 2.40.24 常见的类别不平衡问题解决方法 62 2.41 决策树 64 2.41.1 决策树的基本原理 64 2.41.2 决策树的三要素? 64 2.41.3 决策树学习基本算法 65 2.41.4 决策树算法优缺点 65 2.40.5 熵的概念以及理解 66 2.40.6 ...
  • 大话数据结构 程杰

    2018-09-01 10:06:43
    2.10常见的时间复杂度 35 有些时候,告诉你某些东西不可以去尝试,也是一知识的传递。总不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11最坏情况与平均情况 35 2.12算法空间复杂度 36 事先建立一个有2050大...
  • C#微软培训资料

    2014-01-22 14:10:17
    7.4 关系操作符和关系表达式.65 <<page 2>> page begin==================== 7.5 逻辑操作符和逻辑表达式.68 7.6 位 运 算 .69 7.7 其它特殊操作符 .72 7.8 小 结 .77 第章 流 程 控 制 .79 8.1 ...
  • 2.9.1 算法时间复杂度定义 29 2.9.2 推导大O阶方法 30 2.9.3 常数阶 30 2.9.4 线性阶 31 2.9.5 对数阶 32 2.9.6 平方阶 32 2.10 常见的时间复杂度 35 有些时候,告诉你某些东西不可以去尝试,也是一知识的传递。...
  • 经历了一个多世纪漫长发展道路,电路理论已经发展成为一门体系完整、逻辑严密、具有强大生命力学科。 在工程技术领域和实际生活中,电路理论都有非常广阔应用。从简单照明电路,到复杂电力系统;从单个...
  • 大话数据结构-程杰

    2014-07-13 23:45:52
    2.10 常见的时间复杂度 35 有些时候,告诉你某些东西不可以去尝试,也是一知识的传递。总不能非要去被毒蛇咬一口才知道蛇不可以去招惹吧。 2.11 最坏情况与平均情况 35 2.12 算法空间复杂度 36 事先建立一个有...
  • 3.1.2 涉及关系运算符表达式 80 3.1.3 基本if语句 81 3.1.4 扩展if语句:if-else 84 3.1.5 在if语句中使用代码块 86 3.1.6 嵌套if语句 87 3.1.7 更多的关系运算符 90 3.1.8 逻辑运算符 93 3.1.9 条件...
  • JAVA基础课程讲义

    2017-08-30 23:39:14
    目 录 第一章 JAVA入门 10 计算机语言发展史 10 机器语言 10 汇编语言 10 高级语言 10 其他高级语言 11 ...事件监听器常见的定义形式 233 AWT其他组件 233 菜单的实现 233 特点 233 代码示例和效果 233

空空如也

空空如也

1 2 3
收藏数 56
精华内容 22
关键字:

常见的八种逻辑关系