《数据结构（严蔚敏版）》学习笔记（一）——常用数据结构定义:

最新推荐文章于 2024-07-06 19:23:57 发布

星影starshadow

最新推荐文章于 2024-07-06 19:23:57 发布

阅读量1.8k

点赞数 1

分类专栏：数据结构文章标签：数据结构 c语言

本文链接：https://blog.csdn.net/u010542738/article/details/49470567

版权

数据结构专栏收录该内容

5 篇文章 0 订阅

订阅专栏

《数据结构（严蔚敏版）》学习笔记（一）——常用数据结构定义:

线性表 {顺序表，单链表，静态单链表，双向链表}；

栈 { 顺序栈 }；

队列 {单链队列，循环队列}；

串 {定长顺序串，动态顺序串，块链串}；

数组 {顺序数组}；

稀疏矩阵 {三元组顺序表，行逻辑链接顺序表，十字链表}；

广义表 {头尾链表，扩展线性链表}；

二叉树 {顺序，链式，线索}；

树 {双亲表示，孩子表示，孩子兄弟表示}；

图 {邻接矩阵，邻接表，十字链表，邻接多重表}；

*********************************************************************************************************

线性表（顺序，动态分配）：

<span style="font-size:14px;">typedef struct {
	ElemType	*elem;			//基址
	int		length;			//当前长度
	int		listsize;		//分配空间
}SqList;</span>

<span style="font-size:14px;">SqList L.elem = (ElemType *)malloc(LIST_SIZE * sizeof(ElemType));</span>

线性表（单链表）：

<span style="font-size:14px;">typedef struct	LNode{
	ElemType	data;
	struct LNode	*next;
}LNode,*Link;				//用Link就可以定义链表了
typedef struct{
	Link	<span style="white-space:pre">	</span>head,tail;
	int	<span style="white-space:pre">	</span>len;
}LinkList;</span>

线性表（静态单链表）：

<span style="font-size:14px;">typedef struct{
	ElemType	data;
	int		cur;		//cur为数组下标，亦为元素“指针”
}component,SLinkList[MAXSIZE];</span>

线性表（双向链表）：

<span style="font-size:14px;">typedef struct DuLNode{
	ElemType	data;
	struct DuLNode	*prior;
	struct DuLNode	*next;
}DuLNode,*DuLinkList;</span>

栈（顺序）：

<span style="font-size:14px;">typedef struct{
	ElemType	*base;
	ElemType	*top;
	int		stacksize;
}SqStack;
SqStack S.base = (ElemType *)malloc(STACK_SIZE * sizeof(ElemType));
S.top = S.base;</span>

队列（单链）：

<span style="font-size:14px;">typedef struct QNode{		//和单链表的定义相同
	ElemType	data;
	struct QNode	*next;
}QNode,*QueuePtr;
typedef struct{
	QueuePtr	front;		//要有队头队尾指针
	QueuePtr	rear;
}LinkQueue;</span>

队列（循环，顺序）：

<span style="font-size:14px;">typedef struct{
	ElemType	*base;
	int		front;		//类似静态链表用数字表示“指针”
	int		rear;
}SqQueue;
SqQueue Q.base = (ElemType *)malloc(QUEUE_SIZE * sizeof(ElemType));</span>

串（顺序，定长）：

<span style="font-size:14px;">typedef unsigned char SString[MAXSTRLEN + 1];		//a.str[0]存串长 ; b.str[STRLEN]存'\0'</span>

串（堆分配）：

<span style="font-size:14px;">typedef struct{
	char	<span style="white-space:pre">	</span>*ch;
	int		length;
}HString;
HString T.ch = (char *)malloc(i * sizeof(char));</span>

串（块链）：

由多个顺序表构成的链表...

<span style="font-size:14px;">typedef struct Chunk{
	char		ch[CHUNKSIZE];
	struct Chunk	*next;
}Chunk;
typedef	struct{
	Chunk	<span style="white-space:pre">	</span>*head,*tail;
	int		curlen;			//当前长度
}LString;</span>

数组（顺序）：

<span style="font-size:14px;">typedef struct{
	ElemType	*base;
	int		dim;			//维数
	int		*bounds;		//维界基址?
	int		*constants;		//函数常量机制?
}Array;
Array A.bounds = (int *)malloc(dim * sizeof(int));
A.base = (ElemType *)malloc(eletotal * sizeof(ElemType));
A.constants = (int *)malloc(dim * sizeof(int));</span>

稀疏矩阵（三元组顺序表）：

只记录非0元...

<span style="font-size:14px;">typedef struct{
	int		i,j;
	ElemType	e;
}Triple;			<span style="white-space:pre">		</span>//单个元素
typedef struct{
	Triple		data[MAXSIZE + 1];		//非0元三元组表
	int		mu,nu,tu;				//行数，列数，非0元数
}TSMatrix;</span>

稀疏矩阵（行逻辑链接顺序表）：

<span style="font-size:14px;">typedef struct{
	Triple		data[MAXSIZE + 1];
	int		rpos[MAXRC + 1];		//各行第一个非0元位置表
	int		mu,nu,tu;
}RLSMatrix;</span>

稀疏矩阵(十字链表)：

<span style="font-size:14px;">typedef struct OLNode{
	int		i,j;
	ElemType	e;
	struct OLNode	*right,*down;		//行/列链表的下一元素
}OLNode,*OLink;
typedef struct{
	OLink		*rhead,*chead;		//行/列链头指针
	int		mu,nu,tu;
}CrossList;</span>

广义表（头尾链表）：

<span style="font-size:14px;">typedef enum	{ATOM,LIST}ElemTag;
typedef struct GLNode{
	ElemTag		tag;
	union{
		AtomType	<span style="white-space:pre">	</span>atom;
		struct{struct GLNode	*hp,*tp;}ptr;		//ptr是表节点指针域，ptr.hp/ptr.tp分别指向表头表尾
	};
}*GList;</span><span style="font-size:18px;">								</span><span style="font-size:14px;">//每个原子节点都有对应的表节点</span>

广义表（扩展线性链表）：

<span style="font-size:14px;">typedef enum	{ATOM,LIST}ElemTag;
typedef struct GLNode{
	ElemTag		tag;
	union{
		AtomType	atom;
		struct GLNode	*hp;
	};
	struct GLNode	*tp;			//指向下一个节点
}*GList;</span><span style="font-size:18px;">						</span><span style="font-size:14px;">		//原子节点和表节点等价</span>

二叉树（顺序）：

<span style="font-size:14px;">typedef ElemType	SqBiTree[MAX_SIZE];		//层次遍历建立</span>

二叉树（链式）：

<span style="font-size:14px;">typedef struct BiTNode{
	ElemType	<span style="white-space:pre">	</span>data;
	struct BiTNode	<span style="white-space:pre">	</span>*lchild,*rchild;
}BiTNode,*BiTree;</span>

二叉树（线索）：

将叶子节点不用的指针用来指后继...

<span style="font-size:14px;">typedef	enum	PointerTag{Link,Thread};
typedef struct BiThrNode{
	ElemType		data;
	struct BiThrNode	*lchild,*rchild;
	PointerTag		LTag,RTag;
}BiThrNode,*BiThrTree;</span>

树（双亲,顺序）：

<span style="font-size:14px;">typedef struct PTNode{
	ElemType	data;
	int		parent;
}PTNode;
typedef struct{
	PTNode	<span style="white-space:pre">	</span>nodes[MAX_SIZE];
	int		r,n;		//根的位置，节点数
}PTree;</span>

树（孩子链表）：

<span style="font-size:14px;">typedef struct CTNode{
	int		child;
	struct CTNode	*next;
}*ChildPtr;
typedef struct{
	ElemType	data;
	ChildPtr	firstchild;
}CTBox;
typedef struct{
	CTBox	<span style="white-space:pre">	</span>nodes[MAX_SIZE];
	int		n,r;
}CTree;</span>

树（二叉链表）：

<span style="font-size:14px;">typedef struct CSNode{
	ElemType		data;
	struct CSNode	<span style="white-space:pre">	</span>*firstchild,*nextsibling;
}CSNode,*CSTree;</span>

Huffman树：

<span style="font-size:14px;">typedef struct{
	unsigned int	weight;
	unsigned int	parent,lchild,rchild;
}HTNode,*HuffmanTree;			//动态分配数组
typedef char ** HuffmanCode;	//动态分配数组</span>

图（邻接矩阵）：

<span style="font-size:14px;">typedef enum	{DG,DN,UDG,UDN}GraphKind;		//有向图，有向网，无向图，无向网
typedef struct ArcCeil{
	VRType		adj;		//顶点关系或权值
	InfoType	*info;
}ArcCeil,AdjMatrix[MAX_VERTEX_NUM][MAX_VERTEX_NUM];	//使用二维矩阵存关系
typedef struct{
	VertexType	vexs[MAX_VERTEX_SIZE];			//点集
	AdjMatrix	arcs;
	int		vexnum,arcnum;					//点数，边数
	GraphKind	kind;
}MGraph;</span>

图（邻接表）：

<span style="font-size:14px;">typedef struct ArcNode{
	int			adjvex;				//保存的是头节点的序号
	struct ArcNode	<span style="white-space:pre">	</span>*nextarc;
	InfoType		*info
}ArcNode;
typedef struct VNode{
	VertexType	<span style="white-space:pre">	</span>data;
	ArcNode		<span style="white-space:pre">	</span>*firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];			//将节点作成一个顺序数组
typedef struct{
	AdjList		<span style="white-space:pre">	</span>vertices;
	int			vexnum,arcnum;
	int			kind;
}ALGraph;</span>

有向图（十字链表）：

<span style="font-size:14px;">typedef struct ArcBox{
	int			tailvex,headvex;			//弧的尾头节点
	struct ArcBox	<span style="white-space:pre">	</span>*hlink,*tlink;				//同头/尾弧链
	InfoType		*info;
}ArcBox;
typedef struct VexNode{
	VertexType		data;
	ArcBox			*firstin,*firstout;			//入弧链头，出弧链头
}VexNode;
typedef struct{
	VerNode	<span style="white-space:pre">		</span>xlist[MAX_VERTEX_SIZE];
	int		<span style="white-space:pre">	</span>vexnum.arcnum;
}OLGraph;</span>

图（邻接多重表）：

和十字链表基本相同...

<span style="font-size:14px;">typedef enum	{unvisited,visited}VisitIf;
typedef struct EBox{
	VisitIf		<span style="white-space:pre">	</span>mark;
	int			ivex,jvex;
	struct EBox	<span style="white-space:pre">	</span>*ilink,*jlink;
	Infotype	<span style="white-space:pre">	</span>*info;
}EBox;
typedef struct VexBox{
	VertexType	<span style="white-space:pre">	</span>data;
	EBox		<span style="white-space:pre">	</span>*firstedge;
}VexBox;
typedef struct{
	VexBox		<span style="white-space:pre">	</span>adjmulist[MAX_VERTEX_SIZE];
	int			vexnum,arcnum;
}AMLGraph;</span>