精华内容
下载资源
问答
  • 数据结构(上)——的基本概念与存储结构
    千次阅读
    2018-12-14 23:57:42

    数据结构之串(上)——串的基本概念与存储结构

    1.什么是串

    (1)我们先来看一下基本的关系:

    数据结构是指两个集合:a.有特定关系的元素的集合(元素集)
                        b.这些元素之间的关系的集合(关系集)
    元素之间的关系有: a.线性关系
                      b.非线性关系
    在各种各样的数据结构中,如果其中的元素是线性关系,我们就称呼这个数据结构为线性表;
    如果线性表中的元素集是字符集(即元素类型均为字符型),我们就称这种线性表为串。
    

    (2)必须知道的关于串的基本概念:

    串的长度:串中所包含的字符个数称为该串的长度。
    空串:长度为零,即不包含任何字符
    子串:串中任意个连续字符组成的子序列称为该串的子串,嘿嘿,主串是什么就不用我解释了吧
    空格串(空白串):顾名思义,所有字符都是空格
    

    2.串的存储方式

    (1)字符数组法(顺序存储结构):

    a.将串定义为字符数组,利用串名可以直接访问串值 b.呜呜呜,数组要先分配好存储空间啊,存储空间就固定了啊 c.代码:#define m=100//用户能在100以内定义最大串长 typedef char Sstring[m+1];//0号单元存放串的长度,字符从1号单元存放 Sstring S;//S的类型为Sstring

    (2)字符序列法(堆分配存储结构):

    a.用一组地址连续的存储单元依次存储串中的序列
    b.程序运行时根据串的实际长度动态分配存储空间
    c.代码:typedef struct { char *ch;//ch是地址,ch[i]或*ch是元素,我们可以用s.ch[i]来访问字符串s中第i个元素 int length;//s的长度L等于s.length }Hstring;

    (3)链式存储

    代码:#define m=10//一个地址可存10个字符 typedef struct snode { char ch[m]; struct node*next;//地址 }snode;

    更多相关内容
  • 各种数据结构的简单特点 1、列表 包括 (1)数组 【1】会在内存中开辟一个连续的内存空间 【2】随机访问的效率比链表高。数组只要给定下标,则可以直接定位到该下标所对应的元素,而链表每次都是从头节点开始...

                                              各种数据结构的简单特点

    1、列表

    包括

    (1)数组

    【1】会在内存中开辟一个连续的内存空间

    【2】随机访问的效率比链表高。数组只要给定下标,则可以直接定位到该下标所对应的元素,而链表每次都是从头节点开始遍历。

    【3】对元素的增删操作的效率比链表低。这里说的是从数组的中间插入或删除一个元素,并且数组中元素很多,实验证明,在数组头部或结尾增加或删除一个元素的效率和链表差不多。

    为什么?

    比如,每次对数组中间某一个元素进行删除的操作,则此元素后面的所有元素都得往前面移动,耗费大量的时间和性能。

    而对链表中间某一个元素进行删除的操作,只需将此节点的指针与前驱结点和后继节点断开即可,元素并没有发生移动。

    这个特点,可以解释ArrayList与LinkedList之间的区别

     

    (2)链表

    【1】通过一个个指针将节点串起来

    【2】对于元素的随机访问,需要使用计数器来访问指定的元素,并且只能从头节点开始访问,每访问一个节点,计数器加1,直到给定的“下标”,此操作很耗时,时间复杂度为O(N)

    【3】增加元素和删除元素的效率很高

     

    (3)队列

    【1】不支持随机访问

    【2】先进先出

    【3】线程池中的线程就是从任务队列中取出任务

     

    (4)栈

    【1】不支持随机访问

    【2】后进先出

     

     

    2、树

    (1)二叉树

    【1】每个节点最多只有两个子节点

    (2)搜索树

    【1】二分查找,数组对半分的路径就是一个搜索树

    【2】不一定是二叉树

    (3)堆/优先队列

    【1】按照顺序pop出元素

    【2】优先队列中,以最小堆为例,树或子树根结点都是所在树或子树中最小的元素

     

    3、栈、队列、优先队列中的元素弹出顺序

    例 push(1)   push(3)   push(2)  pop()    pop()   pop()

    (1)栈 

    弹出顺序为 2,3,1   【后进先出】

    (2)队列

    弹出顺序为 1,3,2   【先进先出】

    (2)优先队列

    弹出顺序为 1,2,3   【从小到大,具有顺序性】

     

    4、Map<K,V>和Set<K>接口

    (1) HashMap/HashSet

    【1】都基于哈希表的实现

    【2】每个Object都有一个哈希值,上面两者实现类都基于这个哈希值

    HashSet如何区分待插入元素重复?

    先得到这个元素的hashCode,若HashSet中不存在此hashCode对应的元素,则直接将此元素插入到HashSet中

    若HashSet中存在此hashCode对应的元素,将这些元素拿出来与待插入元素进行equals判断,若全相等,则不插入,否则插入

    (2)TreeMap/TreeSet 

    【1】K必须实现Comparable接口

    【2】K被放入树中

     

     

    5、图

    (1)无向图

    【1】每个节点都没有方向,边上可能有权重

    (2)有向图

    【1】每个节点是有方向的的

    (3)有向无环图

    【1】可以描述任务之间的关系

     

     

     

    展开全文
  • 数据结构学习之路——————

    千次阅读 2018-07-27 19:49:21
    1.类型的定义 (string)(或字符)是由零个或多个字符组成的有限序列,一般记为    n称为的长度。零个字符的称为空串,长度为0。中任意个连续字符组成的子序列称为该的子串。包含子串的相应地...

    1.串类型的定义

    串(string)(或字符串)是由零个或多个字符组成的有限序列,一般记为

                                            s='a1a2\cdot \cdot \cdot an'(n>=0)

     n称为串的长度。零个字符的串称为空串,长度为0。串中任意个连续字符组成的子序列称为该串的子串。包含子串的串相应地称为主串。通常称字符在序列中的序号为该字符在串中的位置。称两个串相等时,长度相同,对应位置字符相同。串值需由单引号括起来,但单引号不属于串。

    串的逻辑结构和线性表极为相似,区别在于串的数据对象约束为字符集。然而基本操作有很大区别。在线性表的基本操作中,大多以“单个元素”作为操作对象;而串中,通常以“串的整体”为操作对象。

    2.串的表示和实现

    2.1 定长顺序存储表示

    类似线性表的顺序存储结构,用一组连续的存储单元存储串值得字符串序列。按照预定义的大小,每个定义的串将被分配一个固定长度的存储区。

    //------------串的定长顺序存储表示-------------
    #define MAXSTRLEN 255         //用户可在255以内定义最大串长
    typedef unsigned char SString[MAXSTRLEN + 1];//0号单元存放串的长度  

    串的实际长度可在预定义长度的范围内随意,超过预定义长度的串值则被舍去,超过预定义长度的串值则被舍去,称之为“截断”。对串长有两种表示方法:一是如上述定义描述那样,以下标为0的数组分量存放串的实际长度;二是在串值后面加一个不记入串长的结束标记字符,如“\0”作为结束标记字符。

    2.2 堆分配存储表示

    这种存储方式的特点是,仍以一组地址连续的储存单元存放串值字符序列,但他们的空间是在程序执行过程中动态分配而得的。在C语言中,存在一个称之为“堆”的自由储存区,并由C语言的malloc()和free()来管理(C++中新增new)。

    //--------------串的堆分配存储表示------------------
    typedef struct {
    	char *ch;   //若为非空串,则按串长分配储存区,否则ch为NULL
    	int length;
    }HString;
    #include<string>
    #include<iostream>
    #include <cstdlib>
    #include <cstdio>
    #include<memory>
    //------------串的定长顺序存储表示-------------
    #define MAXSTRLEN 255         //用户可在255以内定义最大串长
    typedef unsigned char SString[MAXSTRLEN + 1];//0号单元存放串的长度  
    //--------------串的堆分配存储表示------------------
    typedef struct {
    	char *ch;   //若为非空串,则按串长分配储存区,否则ch为NULL
    	int length;
    }HString;
    
    //--------------------------基本操作的算法描述--------
    bool StrAssign(HString &T,char *chars){
    	int n;
    	//生成一个其值等于串常量chars的串T
    	if (T.ch)free(T.ch);//释放T原有空间
    	for (int i = 0, char *c = chars; *c; c++, i++) { n = i; }//求chars的长度i
    	if (!n) { T.ch = NULL; T.length = 0; }
    	else {
    		if (T.ch = (char*)malloc(n * sizeof(char)))
    			exit(OVERFLOW);
    		for (int i = 0; i < n; i++) {
    			T.ch[i] = chars[i];
    		}
    		T.length = n;
    	}
    	return 1;
    }
    
    int StrLength(HString S)
    {
    	return S.length;
    }
    
    bool ClearString(HString &S) {
    	//将S清为空串
    	if (S.ch) { free(S.ch); S.ch = NULL; }
    	return 1;
    }
    
    bool Concat(HString &T, HString S1, HString S2) {
    	//用T返回由S1和S2联接而成新串
    	if (T.ch)free(T.ch);
    	if (!(T.ch = (char*)malloc((S1.length + S2.length) * sizeof(char))))
    		exit(OVERFLOW);
    	for (int i = 0; i < S1.length; i++) {
    		T.ch[i] = S1.ch[i];
    		T.length = S1.length + S2.length;
    		for (int i = S1.length,int j=0; i < T.length,j<S2.length; j++,i++) {
    			T.ch[i] = S2.ch[j];
    		}
    	}
    	return 1;
    }
    
    bool Subtring(HString &Sub, HString S, int pos, int len) {
    	//用sub返回串S的第pos个字符起长度为len的子串
        //其中1<=pos<=StrLength(S)且0<=len<=StrLength(S)-pos+1
    	if (pos<1 || pos>S.length || len<0 || len>S.length - pos + 1)
    		return 0;
    	if (Sub.ch)free(Sub.ch);
    	if (!len) {
    		Sub.ch = NULL; Sub.length = 0;
    	}
    	else {
    		Sub.ch = (char*)malloc(len * sizeof(char));
    		for (int i = 0, int j = pos - 1; i < len, j < pos+len - 1; i++, j++)
    		{
    			Sub.ch[i] = S.ch[j];
    			Sub.length = len;
    		}
    	}
    	return 1;
    }

    2.3 串的块链显示

    和线性表的链式存储结构相类似,结构中的每个数据元素是一个字符,则用链表储存的结点可放一个或多个字符。当结点大小大于1,由于串长不一定是结点的整数倍,则链表中的最后一个结点不一定被串值占满,此时通常不上“#”或其他非串值字符。

    为了便于进行串的操作,当以链表储存串值时,除头指针外还可附设一个尾指针指示链表中的最后一个结点,并给出当前串的长度。称如此定义的串储存结构为块链结构。

    #define CHUNKSIZE 80   //可由用户定义的块的大小
    typedef struct Chunk {
    	char ch[CHUNKSIZE];
    	struct Chunk *next;
    	}Chunk;
    typedef struct {
    	Chunk *head, *tail; //串的头指针和尾指针
    	int curlen; //串的当前长度
    }LString;
    

    一般情况下,对串进行操作时,只需从头向尾顺序扫描即可,则对串值不必建立双向链表。设尾指针是为了便于进行联结操作,但应注意联结时需处理第一个串尾的无效字符。

    存储密度=串值所占的存储位/实际分配的存储位

    2.4 串的模式匹配算法

    子串的定位操作通常被称为串的模式匹配(其中T称为模式串)。

    int Index(SString &S, SString T, int pos) {
    	//返回子串T在主串S中第pos个字符之后的位置。
    	int i = pos; int j = 1;
    	if (i <= S[0] && j <= T[0]) {
    		if (S[i] == T[j]) { i++; j++; }
    		else {
    			i = i - j + 2; j = 1;
    		}//如不等指针后退重新开始匹配,是退到下一个字符上
    	}
    	if (j > T[0]) return i - T[0]; //i为匹配的子串在主串的最后位置,减去T长度即为位置
    	else return 0;
    }

    模式匹配的一种算法:如上述代码所示。其最坏复杂度为O(n*m),n,m分别为主串和模式串的长度。

    模式匹配的一种改进算法:KMP算法

    此算法可以在O(n+m)的时间数量级上完成串的模式匹配操作。其改进在于:每当一趟匹配过程中出现的字符比较不等时,不需回溯i指针,而是利用所得的“部分匹配”的结果将模式串尽可能远地向右滑动一段距离后,再进行比较。

    改进算法解决下述问题:当匹配过程中产生失配,模式串“向右滑动”的距离有多远,即当主串中第i个字符与模式中第j个字符失配时,主串中第i个字符(i指针不回溯)应与模式中的哪个字符比较。

    现在讨论一般情况:假设此时与模式中第K个字符继续比较,则前k-1个字符要相匹配,即满足下列关系式

    '{p_{1}}{p_{2}}\cdot \cdot \cdot {p_{k-1}}'='{s_{i-k+1}}{s_{i-k+2}}\cdot \cdot \cdot {s_{i-1}}'

    而已得到的匹配结果是:'{p_{j-k+1}}{p_{j-k+2}}\cdot \cdot \cdot {p_{j-1}}'='{s_{i-k+1}}{s_{i-k+2}}\cdot \cdot \cdot {s_{i-1}}'(?先比完整段模式串?)

    由上式推得:'{p_{1}}{p_{2}}\cdot \cdot \cdot {p_{k-1}}'='{p_{j-k+1}}{p_{j-k+2}}\cdot \cdot \cdot {p_{j-1}}'

    反之,若模式串存在满足上式的两个子串,则当匹配过程中,主串中的第i个字符与模式串中的第j个字符比较不等时,仅需将模式向右滑行到模式中第k个字符和主串中第i个字符对齐,此时,模式中头k-1个字符的子串必定与主串中第i个字符之前长度为k-1的子串相等,由此仅需从模式第k个字符与主串第i个字符比较起继续进行。(翻译一下,在失配字符前即模式串中包含两端相同的子串且与主串匹配,下次移动时就可直接把前一段串移动到后面相等的串的位置上)。

      若令next[j]=k,则next[j]=k表明当模式中第j个字符与主串“失配”时,在模式中需要重新和主串中该字符进行比较的字符的位置。

                 0      当j=1 

    next[j]=MAX{k|1<k<j且'{p_{1}}{p_{2}}\cdot \cdot \cdot {p_{k-1}}'='{p_{j-k+1}}{p_{j-k+2}}\cdot \cdot \cdot {p_{j-1}}'}

                1     其他情况

    上式可求出next[j] 数组的值。求得该函数之后,匹配可如下进行:假设以指针 i 和 j 分别指示主串和模式中正待比较的字符,令i的初值为pos,j 的初值为1。若在匹配过程s_{_{i}}=p_{_{j}},则 i 和 j 分别增1,否则 i 不变,j 再退到下一个next值的位置,以此类推,直至下列两种可能:一种是 j 退到某个next值时字符比较相等,则指针各自增1,继续进行匹配;另一种是 j 退到0,则此时需将模式继续向右滑动一个位置。

    int Index_KMP(SString S, SString T, int pos,int next[]) {
    	int i = pos;int j = 1;
    	while (i <= S[0] && j <= T[0]) {
    		if (j == 0 || S[i] == T[i]) { i++; j++; }
    		else j = next[j];
    	}
    	if (j > T[0])return i - T[0];
    	else return 0;
    }
    int get_next(SString T, int next[]) {
    	//求模式串T的next函数值并存入
    	int i = 1; next[1] = 0;
    	int j = 0;
    	while (i < T[0]) {
    		if (j == 0 || T[i] == T[j]) { ++i; ++j; next[i] = j; }
    		else j = next[j];
    	}
    }
    void get_nextval(SString T, int nextval[]) {
    	//求模式串T的next函数修正值并存入nextval中
    	int i = 1; nextval[1] = 0;; int j = 0;
    	while (i < T[0]) {
    		if (j == 0 || T[i] == T[j]) {
    			++j; ++i;
    			if (T[i] != T[j])nextval[i] = j;//增加了一个判别条件,相等时nextval为前值
    			else nextval[i] = nextval[j];
    		}
    		else j = nextval[j];
    	}
    }

     

    展开全文
  • C++数据结构——字符

    千次阅读 2018-06-28 22:18:18
    C++数据结构——字符   参考博客或网址: (1)菜鸟教程——C++字符 (2)https://blog.csdn.net/ylh1234/article/details/64929992 (3)https://blog.csdn.net/fenxinzi557/article/details/5145782...

                                         C++数据结构——字符串

     

    参考博客或网址:

    (1)菜鸟教程——C++字符串

    (2)https://blog.csdn.net/ylh1234/article/details/64929992

    (3)https://blog.csdn.net/fenxinzi557/article/details/51457829

    (4)官网教程:http://www.cplusplus.com/reference/string/string/

    (5)教程中的注释:https://www.jb51.net/article/37410.htm

    (6)详细的串定义与模式匹配算法:https://blog.csdn.net/smile_from_2015/article/details/61619658

    1、串的定义

           串(字符串的简称)是由零个或多个字符组成的有限序列,一般记为s='a1a2a3…an',其中ai可以是字母,数字或者其他字符,零个字符的串称为空串

           串中任意个连续的字符组成的子序列称为该串的子串,包含子串的串相应的被称为主串,通常称字符在序列中的序号为该字符在串中的位置。子串在主串中的位置则以子串的第一个字符在主串中的位置来表示。两个串相等,当且仅当这两个串的值相等,即两串的长度相等,且各个对应位置的字符也相等。

           注意,空格串‘ ’与空串‘’不一样!!!为了清楚起见,书上用符号空集表示。

     

    2、串的表示与实现

       2.1 定长顺序存储表示

           类似于线性表的顺序存储结构, 串的顺序存储结构是用一组地址连续的存储单元来存储串中的字符序列的。按照预定义的大小,为每个定义的串变量分配一个固定长度的存储区。

           一般是用定长数组来定义。既然是定长数组,就存在一个预定义的最大串长度, 一般可以将实际的串长度值保存在数组的 0下标位置,有的书中也会定义存储在数组的最后一个下标位置。但也有些编程语言不想这么干,觉得存个数字占个空间麻烦。它规定在串值后面加一个不计入串长度的结束标记字符,比如"\0"来表示串值的终结,这个时候,你要想知道此时的串长度,就需要遍历计算一下才知道了,其实这还是需要占用一个空间,确实没必要。

           串的顺序存储方式其实是有问题的,因为字符串的操作,比如两串的连接Concat、新串的插入如Insert,以及字符串的替换 Replace,都有可能使得串序列的长度超过了数组的长度 MaxSize。因此为克服这个弊病,唯有不限定串长的最大长度,即动态分配串值的存储空间。

       2.2 堆分配存储表示

           这种存储表示的特点是,仍以一组地址连续的存储单元存放串值字符序列,但它们的存储空间是在程序执行过程中动态分配而得。

       2.3 串的块链存储表示

           和线性表的链式存储结构类似,也可以采用链表方式存储串值。由于串结构的特殊性——结构中每个数据元素是一个字符,则采用链表存储串值,存在一个“结点大小”的问题,即每个结点可以存放一个字符,也可以存放多个字符。因此,一个结点可以存放一个字符,也可以考虑存放多个字符,最后一个结点若是未被占满时,可以用"#"或其他非串值字符补全。

     

    3、串的模式匹配算法

      3.1 求子串位置的定位函数 Index(S,T,pos)

          子串的定位操作通常称做串的模式匹配(T称为模式串,S称为主串)。

          其基本思想为:从主串S的第pos个字符起和模式串T中的第一个字符比较,若相等,则继续逐个比较后续字符;否则从主串的下一个字符起再重新和模式串T中的字符比较。依次类推,直至模式串T中的每个字符依次和主串S中的一个连续的字符序列相等,则称为匹配成功函数值为和模式串T中第一个字符相等的字符在主串S中的序号,否则称匹配不成功,函数值为0。该方法的时间复杂度为:O(n*m),但在实际情况下,其执行时间约为O(n+m),因此至今仍被采用。其具体函数为:

    int Index(string S, string T, int pos){
    	//返回子串T在主串S中第pos个字符之后的位置,若不存在,则函数值为0
    	//其中,T为空,1<=pos<=S.length()
    	int i = pos;
    	int j = 1;
    	while (i <= S[0] && j <= T[0]){
    		if (S[i] == T[j]){
    			++i;++j;//继续比较后续字符
    		}
    		else{
    			i = i - j + 2;//指针后退重新开始匹配
    			j = 1;
    		}
    	}
    	if (j > T[0])
    		return i - T[0];
    	else
    		return 0;
    }//Index

      3.2 KMP算法

           KMP算法是一种改进的字符串匹配算法,由D.E.Knuth,J.H.Morris和V.R.Pratt同时发现,因此人们称它为克努特——莫里斯——普拉特操作(简称KMP算法)。KMP算法的关键是利用匹配失败后的信息(已经匹配的部分中的对称信息),尽量减少模式串(待搜索词)与文本串的匹配次数以达到快速匹配的目的。具体实现就是实现一个next()函数,该函数本身包含了模式串的局部匹配信息。其时间复杂度为O(n+m)。详细关于KMP算法的介绍见:https://blog.csdn.net/v_july_v/article/details/7041827

          为了便于理解这个next函数,举个简单的例子(牛客网字符串必考题)说明一下:

          题目:在KMP算法中,已知模式串为ADABCADADA,请写出模式串的next数组值?(A)

           A. 0,1,1,2,1,1,2,3,4,3

           B. 0,1,1,1,2,1,2,3,4,3

           C. 2,1,1,2,1,1,2,3,3,4

           D. 1,2,3,2,1,1,2,4,4,3

            next数组值的解法

              (1)求模式串中,前缀后缀最大的相同长度

                            A  D  A  B  C  A  D  A  D  A

                             0   0  1  0  0  1   2   3  2  3

              (2)将前缀数组后移一位,并将第一位,置-1

                             -1  0  0  1  0  0  1   2  3  2

              (3)将移位后的数组整体+1

                              0  1  1  2  1  1   2  3  4  3

          nextval数组值的解法(或者参考网址:解法):

              (1)在计算出next值得同时,如果a位字符与它next值指向的b位字符相等,则该a位的nextval就是指向b位的nextval值;

              (2)如果不等,则该a位的nextval值就是它自己a位的next的值。

                上面的nextval数组值为:

                              序号:                1    2   3   4   5   6   7   8   9  10

                              字符串:            A   D   A  B  C   A  D   A  D   A

                              next数组值:     0   1    1   2   1   1   2   3   4   3

                              nextval数组值:0   1    0   2    1   0  1   0   4    0

     

        C++代码为:

    #include <iostream>
    #include <vector>
    
    using namespace std;
    
    inline void NEXT(const string &T, vector<int> &next)
    {
    	//按模式串生成vector,next(T.size())
    	next[0] = -1;
    	for (int i = 1; i<T.size(); i++) {
    		int j = next[i - 1];
    		while (T[i] != T[j + 1] && j >= 0)
    			j = next[j];//递推计算
    		if (T[i] == T[j + 1])
    			next[i] = j + 1;
    		else
    			next[i] = 0;
    	}
    }
    
    inline string::size_type COUNT_KMP(const string &S, const string &T)
    {
    	//利用模式串T的next函数求T在主串S中的个数count的KMP算法
    	//其中T非空,
    	vector<int> next(T.size());
    	NEXT(T, next);
    	string::size_type index, count = 0;
    	for (index = 0; index<S.size(); ++index){
    		int pos = 0;
    		string::size_type iter = index;
    		while (pos<T.size() && iter<S.size()){
    			if (S[iter] == T[pos]){
    				++iter;
    				++pos;
    			}
    			else {
    				if (pos == 0)
    					++iter;
    				else
    					pos = next[pos - 1] + 1;
    			}
    		}//whileend
    		if (pos == T.size() && (iter - index) == T.size())
    			++count;
    	}//forend
    	return count;
    }
    
    int main(void)
    {
    	string S = "abaabcacabaabcacabaabcacabaabcacabaabcac";
    	string T = "ab";
    	string::size_type count = COUNT_KMP(S, T);
    	cout << "模式串T在主串S中出现的次数为:"<< count << endl;
    	system("pause");
    	return 0;
    }// 模式串T在主串S中出现的次数为:10

    4、实例分析

    若使用C++标准库,则添加#include <string>,其主要的函数见文章:C、C++字符串的函数汇总

    # include <iostream>
    # include <string>
    using namespace std;
    
    int main()
    {
    	string str = "when i was young, i listen to radio.";
    	string::size_type position;
    
    	position = str.find("listen");
    
    	if (position != str.npos) //npos是个很大的数,如果没找到就会返回npos的值给position
    	{
    		cout << "第一次出现的下标是:" << position << endl;
    	}
    
    	//反向查找子串在str中最后出现的位置
    	string flag = "to";
    	position = str.rfind(flag);
    	cout << "str.rfind(flag):" << position << endl;
    	getchar();
    	return 0;
    }

    运行结果:

    展开全文
  • 数据结构与算法:实验报告(及其应用)

    千次阅读 多人点赞 2020-12-06 15:37:19
    文章目录前言一、实验目的二、实验内容三、实验环境1)使用的操作系统及版本2)使用的编译系统及版本四、实验步骤及说明1、用c语言,设计出的存储结构总结 前言 计算机上非数值处理的对象大部分是字符串数据,...
  • 数据结构中的字符

    千次阅读 2018-12-05 19:20:06
    1.数据结构中提到的,即字符,由 n 个字符组成的一个整体( n &gt;= 0 )。这 n 个字符可以由字母、数字或者其他字符组成。 例如,S = ”BEIJING” ,S 代表这个名,BEIJING 是的值。双引号不是的...
  • 数据结构(12.1)结构的定义

    千次阅读 2019-12-23 14:36:47
    与线性表很相似,却又有很大不同
  • 数据结构——

    千次阅读 2022-01-19 10:19:25
    串串的定义的类型定义的存储结构串的模式匹配算法BF(Brute-Force)算法KMP(Knuth Morris Pratt)算法 的定义   (String) —— 零个或多个任意字符组成的有限序列 几个术语: 子串:中任意个连续字符...
  • golang数据结构初探之字符string

    千次阅读 2021-08-23 15:39:33
    string 是Go语言中的基础数据类型。 特性速览 声明 声明string变量非常简单,常见的方式有以下两种: 声明一个空字符后再赋值 var s string s = "hello world" 需要注意的是空字符只是长度为0,但不是nil。不...
  • 数据结构的定义

    千次阅读 2020-06-08 12:36:33
    (String)是由零个或者多个字符组成的有限序列,又名叫字符。 一般记为s=“a1a2……an”(n>=0) 其中s是的名称,用双引号括起来括起来的字符序列是的值,引号不属于的内容。ai(1=< i <=i)...
  • 数据结构-线性表-

    千次阅读 2019-09-21 11:12:59
    的定义 (string)是由零个或多个字符组成的有限序列,又名叫字符。 一般记为 s = “”(n≥0),其中,s 是的名称,用双引号括起来的字符序列是的值。 中的字符数目n称为的长度。零个字符的称为...
  • 数据结构复习(

    千次阅读 2021-06-01 23:31:00
    数据结构复习题(4)选择题填空题判断题 选择题 是一种特殊的线性表,其特殊性体现在( ) A 可以顺序存储 B 数据元素是一个字符 C 可以链式存储 D 数据元素可以是多个字符 的模式匹配是指( )。 A 判断两个...
  • 数据结构 - 线性表、栈、队列、

    千次阅读 多人点赞 2018-09-24 18:01:47
    最近把之前学过的数据结构和算法部分都重新研究看完了,整理分享一下。 前言感想:之前遇到有人说不要说重复的东西,网上都有了,书里都有这些概念了。我听到之后很诧异,很感叹这个人或者这些人可能没有真正的去...
  • #笔记整理 (string)(或字符) 是由零个或多个字符组成的有限序列,一般记为 s=′a1a2…an′s=&...与前面所讲的线性表的顺序存储结构类似, 用一组地址连续的存储单元存储的字符序列。 #define MAXSTRLEN ...
  • 《算法和数据结构》学习路线指引

    万次阅读 多人点赞 2021-07-01 11:16:15
    本文已收录于专栏 《画解数据结构》 饭不食,水不饮,题必须刷 C语言免费动漫教程,和我一起打卡! 《光天化日学C语言》 LeetCode 太难?先看简单题! 《C语言入门100例》 数据结构难?不存在的! 《画解数据结构》 ...
  • 数据结构是计算机存储、组织数据的方式。一种好的数据结构可以带来更高的运行或者存储效率。数据在内存中是呈线性排列的,但是我们可以使用指针等道具,构造出类似“树形”的复杂结构。下面介绍八个常见的数据结构
  • 字符是由多个字符组成的有限序列。记为s=‘a1 a2 a3 … an’,s为的名,单引号引起来的是的值。 在中取出一段连续的字符构成一个新的序列,这个子序列称为的子串。 找出子串在主中的位置,称为模式匹配...
  • 数据结构与算法学习笔记

    万次阅读 多人点赞 2018-09-25 13:55:49
    本文是王争老师的《算法与数据结构之美》的学习笔记,详细内容请看王争的专栏。有不懂的地方指出来,我做修改。 数据结构与算法思维导图 数据结构指的是“一组数据的存储结构”,算法指的是“操作数据的一组...
  • 数据结构简答题汇总

    万次阅读 多人点赞 2020-05-12 23:56:08
    面对即将要参加的考研复试,数据结构是必考科目,希望以下能派上用场 1.算法的时间复杂度: 答:在程序中反复执行的语句的执行次数被称为语句的频度,时间复杂度就是所有语句频度之和的数量级,而所有语句的频度之和...
  • 数据结构线性表,栈和队列以及和数组章节的知识概括的思维导图,主要有线性表的定义,特点;顺序表、链表的初始化,查找,插入,删除操作的执行与算法。栈和队列的定义,特点,以及插入,删除操作,以及和数组的...
  • 数据结构知识整理

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

    万次阅读 多人点赞 2021-04-15 22:43:48
    王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点: 线性表的基本操作——创销、增删、改查 传入参数时,何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———...
  • 及其基本运算 的定长顺序存储及操作 的堆存储结构
  • 原 Java常用数据结构特点

    千次阅读 2018-11-19 10:20:40
    这篇文章主要是自我回归并和大家分享一下Java常用的数据结构,以及各自数据结构所具有的特点。废话不多说,我们直接开始。 Java中有几种常用的数据结构,主要分为Collection和map两个主要接口,我们从源码中探索...
  • 数据结构分类及八种常见数据结构

    千次阅读 2020-05-09 11:04:00
    数据结构分类 数据的逻辑结构 1.集合:数据结构中的元素之间除了“同属一个集合” 的相互关系外,别无其他关系; 2.线性结构:数据结构中的元素存在一对一的相互关系; 3.树形结构:数据结构中的元素存在一对多的...
  • 专升本数据结构复习

    千次阅读 多人点赞 2021-03-03 13:48:51
    数据结构知识点总汇 主要参考书目: 程海英老师的《数据结构(C语言版)》教材 严蔚敏,李冬梅,吴伟民.《数据结构(C语言版)》 说明:这是本人专升本上岸一年后写的,本篇包含知识点和例题总结。因为是当时自己...
  • Python最常用的数据结构6种

    千次阅读 2020-12-13 12:55:56
    Python最常用的数据结构6种:数字、字符、列表、元组、字典和集合。其中最为常用的是数字、字符、列表和字典。可以用type()查看数据类型;1、数字(number)用于存储数值。python3支持4种类型的数字:int(整数类型...
  • Python3数据结构

    千次阅读 多人点赞 2022-01-31 14:43:11
    Python3数据结构数字 Number数字类型转换数字运算字符 str字符的查询字符大小写转换字符对齐字符拆分、切片字符判断相关字符其他操作格式化字符输出字符编码列表 list列表的特点列表的创建列表...
  • 常见的数据结构 单链表结构和顺序存储结构的区别 线性链表 数组和链表的区别 判断疫个链表是否有环,如何找到这个环 单链表和双链表的区别 头指针和头结点的区别 简述KMP算法 栈和队列的区别 栈和队列的相同之处和...
  • 根据此书所做随笔笔记。 一、绪论 1.1、数据机构的研究内容 ...由于数据必须在计算机中处理,因此不能局限于数据本身的数学问题的研究,还必须考虑数据的物理结构,即数据在计算机中的存储结构。 1.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 286,783
精华内容 114,713
关键字:

串的特点数据结构

数据结构 订阅