【数据结构】串 笔记整理

于 2022-07-30 19:11:53 发布
阅读量1.3k 收藏 7
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51630192/article/details/126076412
版权
本文详细介绍了串（字符串）的基本概念，包括串的定义、抽象数据类型及其操作，如生成、复制、清空、比较、连接、子串提取、查找、替换、插入和删除等。此外，还探讨了串的顺序存储结构和链式存储结构，并讲解了朴素的模式匹配算法和KMP模式匹配算法，展示了如何提高字符串匹配效率。
摘要由CSDN通过智能技术生成

目录：

串：

5.1 定义：

串(string) 是由零个或多个字符组成的有限序列，又名叫字符串。

  1. 串中的字符数目N称为串的长度
  2. 零个字符的串称为空串(null string)
  3. 空格串：只包含空格的串，内容是有长度的，可以不止一个空格。
  4. 子串与主串：串中任意个数的连续字符组成的子序列称为该串的子串，相应的，包含子串的串称为主串。
  5. 子串在主串中的位置就是子串的第一个字符在主串中的序号。

5.2 抽象数据类型：

ADT 串(string)
Data
	串中元素仅由一个字符组成，相邻元素具有前驱和后继的关系。
Operation
	StrAssign(T,*chars):生成一个值等于字符串常量chars的串T。
	StrCopy(T,S):串S存在，由串S复制得串T。
	ClearString(S):串S存在，将串清空。
	StringEmpty(S):若S为空，返回true，否则返回false
	StrLength(S):返回串S中的元素个数，即串的长度。
	StrCompare(S,T):若S>T，返回值>0，若S=T，返回0，若S<T，返回值<0。
    Concat(T,S1,S2):用T返回由S1和S2联接而成的新串。
    SubString(Sub,S,pos,len):串S存在，用Sub返回串S的第pos个字符起长度为len的子串
    Index(S,T,pos):串S和T存在，T为非空串，若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0。
    Replace(S,T,V):串S,T,V存在，T是非空串。用V替换主串S中出现的所有与T相等的不重叠的子串。
    StrInsert(S,pos,T):串S和T存在，在串S的第pos个字符之前插入串T。
    StrDelete(S,pos,len):串S存在，从串S中删除第pos个字符起长度为len的子串。
endADT

5.3 基本功能实现：

5.3.1 StrAssign(T,*chars):

生成一个值等于字符串常量chars的串T。

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 40 /* 存储空间初始分配量 */

typedef int Status;		/* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;	/* ElemType类型根据实际情况而定，这里假设为int */
typedef char String[MAXSIZE + 1]; /*  0号单元存放串的长度 */

/* 生成一个其值等于chars的串T */
Status StrAssign(String T, char* chars)
{
	int i;
	if (strlen(chars) > MAXSIZE) //若超过字符串的最大长度
		return ERROR;
	else
	{
		T[0] = strlen(chars); //用字符串的第一位存储字符串的长度
		for (i = 1; i <= T[0]; i++)
			T[i] = *(chars + i - 1);
		return OK;
	}
}

5.3.2 StrCopy(T,S):

串S存在，由串S复制得串T。

/* 由串S复制得串T */
Status StrCopy(String T, String S)
{
	int i;
	for (i = 0; i <= S[0]; i++)
		T[i] = S[i];
	return OK;
}

5.3.3 ClearString(S):

串S存在，将串清空。

/* 初始条件:串S存在。操作结果:将S清为空串 */
Status ClearString(String S)
{
	S[0] = 0;/*  令串长为零 */
	return OK;
}

5.3.4 StringEmpty(S):

若S为空，返回true，否则返回false。

/* 若S为空串,则返回TRUE,否则返回FALSE */
Status StrEmpty(String S)
{
	if (S[0] == 0)
		return TRUE;
	else
		return FALSE;
}

5.3.5 StrLength(S):

返回串S中的元素个数，即串的长度。

/* 返回串的元素个数 */
int StrLength(String S)
{
	return S[0];
}

5.3.6 StrCompare(S,T):

若S>T，返回值>0，若S=T，返回0，若S<T，返回值<0。

/*  初始条件: 串S和T存在 */
/*  操作结果: 若S>T,则返回值>0;若S=T,则返回值=0;若S<T,则返回值<0 */
int StrCompare(String S, String T)
{
	int i;
	for (i = 1; i <= S[0] && i <= T[0]; ++i)
		if (S[i] != T[i])
			return S[i] - T[i];
	return S[0] - T[0];
}

5.3.7 Concat(T,S1,S2):

用T返回由S1和S2联接而成的新串。

/* 用T返回S1和S2联接而成的新串。若未截断，则返回TRUE，否则FALSE */
Status Concat(String T, String S1, String S2)
{
	int i;
	if (S1[0] + S2[0] <= MAXSIZE)
	{ /*  未截断 */
		for (i = 1; i <= S1[0]; i++)
			T[i] = S1[i];
		for (i = 1; i <= S2[0]; i++)
			T[S1[0] + i] = S2[i];
		T[0] = S1[0] + S2[0];
		return TRUE;
	}
	else
	{ /*  截断S2 */
		for (i = 1; i <= S1[0]; i++)
			T[i] = S1[i];
		for (i = 1; i <= MAXSIZE - S1[0]; i++)
			T[S1[0] + i] = S2[i];
		T[0] = MAXSIZE;
		return FALSE;
	}
}

5.3.8 SubString(Sub,S,pos,len):

串S存在，用Sub返回串S的第pos个字符起长度为len的子串。

/* 用Sub返回串S的第pos个字符起长度为len的子串。 */
Status SubString(String Sub, String S, int pos, int len)
{
	int i;
	if (pos<1 || pos>S[0] || len<0 || len>S[0] - pos + 1)
		return ERROR;
	for (i = 1; i <= len; i++)
		Sub[i] = S[pos + i - 1];
	Sub[0] = len;
	return OK;
}

5.3.9 Index(S,T,pos):

串S和T存在，T为非空串，若主串S中存在和串T值相同的子串，则返回它在主串S中第pos个字符之后第一次出现的位置，否则返回0。

/* 返回子串T在主串S中第pos个字符之后的位置。若不存在,则函数返回值为0。 */
/* 其中,T非空,1≤pos≤StrLength(S)。 */
int Index(String S, String T, int pos)
{
	int i = pos;	/* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
	int j = 1;				/* j用于子串T中当前位置下标值 */
	while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
	{
		if (S[i] == T[j]) 	/* 两字母相等则继续 */
		{
			++i;
			++j;
		}
		else 				/* 指针后退重新开始匹配 */
		{
			i = i - j + 2;		/* i退回到上次匹配首位的下一位 */
			j = 1; 			/* j退回到子串T的首位 */
		}
	}
	if (j > T[0])
		return i - T[0];
	else
		return 0;
}


/*  T为非空串。若主串S中第pos个字符之后存在与T相等的子串， */
/*  则返回第一个这样的子串在S中的位置，否则返回0 */
int Index2(String S, String T, int pos)
{
	int n, m, i;
	String sub;
	if (pos > 0)
	{
		n = StrLength(S);	/* 得到主串S的长度 */
		m = StrLength(T);	/* 得到子串T的长度 */
		i = pos;
		while (i <= n - m + 1)
		{
			SubString(sub, S, i, m);	/* 取主串中第i个位置长度与T相等的子串给sub */
			if (StrCompare(sub, T) != 0)    /* 如果两串不相等 */
				++i;
			else 				/* 如果两串相等 */
				return i;		/* 则返回i值 */
		}
	}
	return 0;	/* 若无子串与T相等，返回0 */
}

5.3.10 Replace(S,T,V):

串S,T,V存在，T是非空串。用V替换主串S中出现的所有与T相等的不重叠的子串。

/*  初始条件: 串S,T和V存在,T是非空串（此函数与串的存储结构无关） */
/*  操作结果: 用V替换主串S中出现的所有与T相等的不重叠的子串 */
Status Replace(String S, String T, String V)
{
	int i = 1; /*  从串S的第一个字符起查找串T */
	if (StrEmpty(T)) /*  T是空串 */
		return ERROR;
	do
	{
		i = Index(S, T, i); /*  结果i为从上一个i之后找到的子串T的位置 */
		if (i) /*  串S中存在串T */
		{
			StrDelete(S, i, StrLength(T)); /*  删除该串T */
			StrInsert(S, i, V); /*  在原串T的位置插入串V */
			i += StrLength(V); /*  在插入的串V后面继续查找串T */
		}
	} while (i);
	return OK;
}

5.3.11 StrInsert(S,pos,T):

串S和T存在，在串S的第pos个字符之前插入串T。

/*  初始条件: 串S和T存在,1≤pos≤StrLength(S)+1 */
/*  操作结果: 在串S的第pos个字符之前插入串T。完全插入返回TRUE,部分插入返回FALSE */
Status StrInsert(String S, int pos, String T)
{
	int i;
	if (pos<1 || pos>S[0] + 1)
		return ERROR;
	if (S[0] + T[0] <= MAXSIZE)
	{ /*  完全插入 */
		for (i = S[0]; i >= pos; i--)
			S[i + T[0]] = S[i];
		for (i = pos; i < pos + T[0]; i++)
			S[i] = T[i - pos + 1];
		S[0] = S[0] + T[0];
		return TRUE;
	}
	else
	{ /*  部分插入 */
		for (i = MAXSIZE; i <= pos; i--)
			S[i] = S[i - T[0]];
		for (i = pos; i < pos + T[0]; i++)
			S[i] = T[i - pos + 1];
		S[0] = MAXSIZE;
		return FALSE;
	}
}

5.3.12 StrDelete(S,pos,len):

串S存在，从串S中删除第pos个字符起长度为len的子串。

/*  初始条件: 串S存在,1≤pos≤StrLength(S)-len+1 */
/*  操作结果: 从串S中删除第pos个字符起长度为len的子串 */
Status StrDelete(String S, int pos, int len)
{
	int i;
	if (pos<1 || pos>S[0] - len + 1 || len < 0)
		return ERROR;
	for (i = pos + len; i <= S[0]; i++)
		S[i - len] = S[i];
	S[0] -= len;
	return OK;
}

5.3.13 StrPrint(String T):

输出字符串T。

/*  输出字符串T */
void StrPrint(String T)
{
	int i;
	for (i = 1; i <= T[0]; i++)
		printf("%c", T[i]);
	printf("\n");
}

5.4 串的存储结构：

串的存储结构与线性表相同，分为顺序存储和链式存储两种。

5.4.1 串的顺序存储结构：

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

一般可以将串的长度值保存在数组的0下标位置处。但也可以在串值后面加一个不计入串长度的结束标记字符，比如\0表示串的终结。通过遍历计算获得串的长度。

结构体：

#define MAXLEN 255   //预定义最大串长为255

typedef struct{
    char ch[MAXLEN];   //静态数组实现（定长顺序存储）
                       //每个分量存储一个字符
                       //每个char字符占1B
    int length;        //串的实际长度
}SString;

基本操作：

#define MAXLEN 255

typedef struct{
    char ch[MAXLEN];   
    int length;       
}SString;

// 1. 求子串
bool SubString(SString &Sub, SString S, int pos, int len){
    //子串范围越界
    if (pos+len-1 > S.length)
        return false;
    
    for (int i=pos; i<pos+len; i++)
        Sub.cn[i-pos+1] = S.ch[i];
    
    Sub.length = len;

    return true;
}

// 2. 比较两个串的大小
int StrCompare(SString S, SString T){
    for (int i; i<S.length && i<T.length; i++){
        if(S.ch[i] != T.ch[i])
            return S.ch[i] - T.ch[i];
    }
    //扫描过的所有字符都相同，则长度长的串更大
    return S.length - T.length;
}

// 3. 定位操作
int Index(SString S, SString T){
    int i=1;
    n = StrLength(S);
    m = StrLength(T);
    SString sub;        //用于暂存子串

    while(i<=n-m+1){
        SubString(Sub,S,i,m);
        if(StrCompare(Sub,T)!=0)
            ++i;
        else 
            return i;    // 返回子串在主串中的位置
    }
    return 0;            //S中不存在与T相等的子串
}

5.4.2 串的链式存储结构：

相比于线性表，一个结点可以存放一个字符，也可以存放多个字符，最后一个结点若是未被占满时，可以用#或其他字符补全。

结构体：

typedef struct StringNode{
    char ch;           //每个结点存1个字符
    struct StringNode *next;
}StringNode, * String;

5.5 串的模式匹配：

5.5.1 朴素的模式匹配算法：

从一个主串中寻找到子串的位置，这种子串的定位操作通常被称为串的模式匹配。

我们对主串的每一个字符作为子串开头，与要匹配的字符串进行匹配。对主串做大循环，每个字符开头做小循环，指导匹配成功或全部遍历完成为止。

我们设置串的长度位于数组的0下标位置处。

/* 朴素的模式匹配法 */
int Index(String S, String T, int pos)
{
	int i = pos;	/* i用于主串S中当前位置下标值，若pos不为1，则从pos位置开始匹配 */
	int j = 1;				/* j用于子串T中当前位置下标值 */
	while (i <= S[0] && j <= T[0]) /* 若i小于S的长度并且j小于T的长度时，循环继续 */
	{
		if (S[i] == T[j]) 	/* 两字母相等则继续 */
		{
			++i;
			++j;
		}
		else 				/* 指针后退重新开始匹配 */
		{
			i = i - j + 2;		/* i退回到上次匹配首位的下一位 */
			j = 1; 			/* j退回到子串T的首位 */
		}
	}
	if (j > T[0])
		return i - T[0];
	else
		return 0;
}

这种方法我们称为朴素的模式匹配算法，比较繁琐低效。

5.5.2 KMP模式匹配算法：

KMP模式匹配算法可以大大避免重复遍历的情况。

KMP的主要思想是：当出现字符串不匹配时，可以知道一部分之前已经匹配的文本内容，可以利用这些信息避免从头再去做匹配了。这里就会运用到一个前缀表next数组。

前缀表是用来回退的，它记录了模式串与主串(文本串)不匹配的时候，模式串应该从哪里开始重新匹配。

前缀表：记录下标i之前（包括i）的字符串中，有多大长度的相同前缀后缀。

构造next数组：

5.5.2.1 前缀统一减一：
void getNext(int* next, const string& s){
    int j = -1;
    next[0] = j;
    for(int i = 1; i < s.size(); i++) { // 注意i从1开始
        while (j >= 0 && s[i] != s[j + 1]) { // 前后缀不相同了
            j = next[j]; // 向前回退
        }
        if (s[i] == s[j + 1]) { // 找到相同的前后缀
            j++;
        }
        next[i] = j; // 将j（前缀的长度）赋给next[i]
    }
}

此时如果输入的模式串为aabaaf，对应的next为-1 0 -1 0 1 -1。

进行匹配：

int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, needle);
        int j = -1; // // 因为next数组里记录的起始位置为-1
        for (int i = 0; i < haystack.size(); i++) { // 注意i就从0开始
            while(j >= 0 && haystack[i] != needle[j + 1]) { // 不匹配
                j = next[j]; // j 寻找之前匹配的位置
            }
            if (haystack[i] == needle[j + 1]) { // 匹配，j和i同时向后移动
                j++; // i的增加在for循环里
            }
            if (j == (needle.size() - 1) ) { // 文本串s里出现了模式串t
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};
5.5.2.2前缀表不减一：
    void getNext(int* next, const string& s) {
        int j = 0;
        next[0] = 0;
        for(int i = 1; i < s.size(); i++) {
            while (j > 0 && s[i] != s[j]) { // j要保证大于0，因为下面有取j-1作为数组下标的操作
                j = next[j - 1]; // 注意这里，是要找前一位的对应的回退位置了
            }
            if (s[i] == s[j]) {
                j++;
            }
            next[i] = j;
        }
    }

此时如果输入的模式串为aabaaf，对应的next为 0 1 0 1 2 0

int strStr(string haystack, string needle) {
        if (needle.size() == 0) {
            return 0;
        }
        int next[needle.size()];
        getNext(next, needle);
        int j = 0;
        for (int i = 0; i < haystack.size(); i++) {
            while(j > 0 && haystack[i] != needle[j]) {
                j = next[j - 1];
            }
            if (haystack[i] == needle[j]) {
                j++;
            }
            if (j == needle.size() ) {
                return (i - needle.size() + 1);
            }
        }
        return -1;
    }
};

该部分KMP算法相关内容参考了代码随想录的b站视频：

帮你把KMP算法学个通透！（求next数组代码篇）_哔哩哔哩_bilibili

利用KMP算法，可以大幅减少时间复杂度，避免重复匹配。

本文为自己在学习数据结构过程中所记录整理的一些笔记，后续将持续更新后面的内容。
如果这篇文章对你有帮助，可以给我点一个小小的赞。
如果你对我的栏目有兴趣，也欢迎关注我，一同学习。
主要参考：《大话数据结构》——程杰

往期回顾：
【数据结构】队列 学习笔记
【数据结构】栈 学习笔记
【数据结构】线性表 学习笔记

木瓜星灵TT
关注
专栏目录
【专栏必读】王道考研408数据结构+计算机算法设计与分析万字笔记、题目题型总结、注意事项、目录导航和思维导图
快乐江湖的博客
11-23 4万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
数据结构笔记整理第4章：字符串和矩阵
SYSU_LBY的博客
05-09 2980
第4章 字符串和矩阵本章内容本章主要介绍字符串以及数据结构中矩阵的相关内容。
数据结构之串笔记
Y先森0.0
11-21 322
//顺序队列的类型定义如下： #define maxsize 1024 typedef struct {     int data[maxsize];     int rear,front; }sequeue; //定义一个指向队列的指针变量 sequeue *q //申请顺序队列的存储空间 q=(sequeue*)malloc(sizeof(sequeue)); //空队时
数据结构笔记6 串
每天都有新发现
07-14 701
在应用程序中使用最频繁的类型是字符串。字符串简称串，是一种特殊的线 性表，其特殊性在于串中的数据元素是一个个的字符。字符串在计算机的许多方面应用很广。如在汇编和高级语言的编译程序中，源程序和目标程序都是字符串 数据。在事务处理程序中，顾客的信息如姓名、地址等及货物的名称、产地和规 格等，都被作为字符串来处理。另外，字符串还具有自身的一些特性。因此，把字符串作为一种数据结构来研究。   串的基本
数据结构学习笔记（串）
weixin_33735077的博客
05-13 112
　　　　　　　　　　　　　　　　　　　　　　　　　串的定义 1.串：串是由零个或多个字符组成的有限序列，又名叫字符串。 2.串的比较：串的长度以及它们各个对应位置的字符都相等时，才算相等。给定两个串：s=“a1a2......an”, t=“b1b2……bm”, 当满足以下条件之一时，s<t。a.n<m, 且ai=bi(i=1,2,........
数据结构笔记
m0_65933695的博客
04-18 670
数构 概述 数据结构研究数据的存储问题（个体的存储 + 个体和个体之间关系的存储） 算法研究数据的操作问题 算法依附于存储数据的方式（不同的存储方式对它执行的操作也不一样） 衡量算法的标准 ​ 时间复杂度：核心代码执行的次数 数据存储就分两种结构 ​ 线性存储 ​ 非线性存储 线性结构 线性存储 概述 把所有节点（类似于数组元素，单独的事物、个体）用一根直线穿起来 结构体变量不可以加减乘除 但可以相互赋值 无论一个变量有多大，它的地址只用第一个字节的地址表示（占4个字节） 数组 pArr -> pBa
王道考研数据结构笔记
热门推荐
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
尚硅谷Java数据结构与java算法 全194章笔记整理
Foools的博客
08-11 2262
前言 视频地址：https://www.bilibili.com/video/BV1E4411H73v?from=search&seid=13120683720695451628 评价：整个教程的数据结构部分讲的挺好的，知识点全都覆盖了，而且每个数据结构都有代码解释，但是最后20节算法部分讲的有点乱，算法部分我决定直接刷leetcode了 数组 稀疏数组： 二维数组的省内存的保存方法，一般是n行3列，三列分别为行，列，值。 二维数组转稀疏数组： 遍历整个二维数组，查看有多少个有效数字 根据有效数字
数据结构基础学习笔记.pdf
08-30
总结而言，这些笔记整理了C语言编程中最基础的概念，为初学者提供了一套系统的学习资料。通过掌握这些基本知识点，可以为进一步学习更高级的数据结构和算法打下坚实的基础。同时，对于数据结构和算法分析的介绍，有...
数据结构笔记——串
Robod的博客
04-03 1483
数据结构笔记——串
数据结构学习笔记：串
banbanlin的专栏
08-14 899
串（string）是由零个或者多个字符组成的有限序列，也称为字符串。 空串（null string）直接用两双引号表示。 空格串，只包含空格的串。空格串是有内容有长度的，而且不止一个空格。 子串与主串，串中任意个数的连续字符组成的子序列称为该串的子串，相应地，包含子串的串，称为主串。 串的比较是通过组成串的字符之间的编码来进行的，而字符的编码指的是字符在对应字符集中的序号。 定长
数据结构-笔记
qq_37952161的博客
04-23 202
结构简单列子：#include &lt;stdio.h&gt; int main(int argc, char *argv[]) { struct data{ int year; int month; int day; }; 注意这里的分号别漏了 struct data a; a.year=2018; a.month=4; a.day=23; printf("data...
数据结构（笔记）
Xiongchao99的博客
07-10 1万+
数据结构 数据结构三要素 分别是：逻辑结构、存储结构、数据的运算   1、线性表 （1）定义：就是一个表，一个记录就是线性表的一个数据元素，表的长度就是数据元素的个数。 （2）、 线性链表：   如上图，线性链表由一个个结点组成，每个节点有数据域和指针域两部分组成，数据域：本结点存储的数据信息；指针域：下一个结点的存储位置  线性链表不要求书写格式上连续，
数据结构笔记--
Johnny_1992的博客
10-25 173
结构体 定义：定义： struct 结构类型名 { 成员类型标示符 成员名列表； 成员类型标示符 成员名列表； … … 成员类型标示符 成员名列表； }； 说明：struct 结构类型名 变量名； 注意：结构体定义时注意最后大括号外要加 “；”； 注意结构体类型与结构体变量的不同； 结构体可以嵌套。 ...
c语言树形编程,C语言——数据结构（线性，树形，图形结构等）
weixin_30767323的博客
05-18 985
数据结构在学习数据结构之前我想先有一个大体的概念，所以在网上查了一些资料记录如下常见的数据结构1.线性结构2.树形结构3.图形结构4.集合一、线性结构(线性结构是一个有序数据元素的集合)常用的线性结构有：线性表，栈，队列，双队列，串。关于广义表、数组，是一种非线性的数据结构。常见的非线性结构有：二维数组，多维数组，广义表，树(二叉树等)，图特征：1．集合中必存在唯一的一个"第一个元素"；2．集合中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值