王道考研-数据结构算法

最新推荐文章于 2023-06-08 21:56:57 发布

Jiang。

最新推荐文章于 2023-06-08 21:56:57 发布

阅读量1.4k

点赞数 7

分类专栏：笔记文章标签：数据结构算法

本文链接：https://blog.csdn.net/qq_45620825/article/details/119742854

版权

第一章绪论

第二章线性表

第三章栈和队列

3.1栈

3.11栈的基本操作

InitStack(&S): 初始化栈。构造一个空栈S，分配内存空间。
DestroyStack(&L):销毁栈。销毁并释放栈S所占用的内存空间。

Push(&S,x): 进栈，若栈S未满，则将x加入使之成为新栈顶。
Pop(&S,x):出栈，若栈S非空，则弹出栈顶元素，并用x返回。

GetTop(S,&x): 读栈顶元素，若栈S非空，则用x返回栈顶元素。
StackEmpty(S): 判断一个栈S是否为空，若S为空，则返回true，否则返回false。

3.1.2栈的顺序存储结构

顺序栈

顺序栈的定义

#define MaxSize 10			 //定义栈中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];  //静态数组存放栈中元素
	int top;				//栈顶指针
}SqStack;     				//Sq:sequence:顺序

初始化操作

void InitStack(SqStack &S){
   
	S.top = -1;         //初始化栈顶指针
}

判断栈空

bool StackEmpty(SqStack S){
   
	if(S.top==-1)			//栈空
		return true;
	else					//不空
		return false;
}

进栈操作

#define MaxSize 10			 //定义栈中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];  //静态数组存放栈中元素
	int top;				//栈顶指针
}SqStack;     				//Sq:sequence:顺序
//新元素进栈
bool Push(SqStack &S,ElemType x){
   
	if(S.top==MaxSize-1)        //栈满，报错
		return false;
		
	S.top = S.top+1;            //指针先加1
	S.data[S,top]=x;   			//新元素入栈
	return true;
	//也可以写成 S.data[++S.top]=x;
}

出栈操作

#define MaxSize 10			 //定义栈中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];  //静态数组存放栈中元素
	int top;				//栈顶指针
}SqStack;     				//Sq:sequence:顺序

bool Pop(SqStack &S,ElemType &x){
   
	if(S.top==-1)		//栈空，报错
		return false;
	x=S.data[S.top];	//栈顶元素先出栈
	S.top=S.top-1;		//指针再减1
	return true;
	//也可以换成 x=S.data[S.top--];
}

读栈顶元素

#define MaxSize 10			 //定义栈中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];  //静态数组存放栈中元素
	int top;				//栈顶指针
}SqStack;     				//Sq:sequence:顺序

bool Pop(SqStack &S,ElemType &x){
   
	if(S.top==-1)		//栈空，报错
		return false;
	x=S.data[S.top];	//x记录栈顶元素
	return true; 
}

共享栈

#define MaxSize 10			 //定义栈中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];  //静态数组存放栈中元素
	int top0;				//0号栈顶指针
	int top1;				//1号栈顶指针
}SqStack;     				//Sq:sequence:顺序
//初始化栈
void InitStack(ShStack &S){
   
	S.top0=-1;			//初始化栈顶指针
	S.top1=MaxSize;
}
//栈满的条件:top0+1==top1;

链栈

栈的应用（括号匹配）

#define MaxSize 10
typedef struct{
   
	char data[MaxSize];
	int top;
}SqStack;
//初始化栈
void InitStack(SqStack &S)
//判断栈是否为空
bool StackEmpty(SqStack S)
//新元素入栈
bool Push(SqStack &S,char x)
//栈顶元素出栈，用x返回
bool Pop(SqStack &s,&x)

bool bracketCheck(char str[],int length){
   
	SaStack S;
	InitStack(S);				//初始化一个栈
	for(int i=0;i<length;i++){
   
		if(str[i]=='(' || str[i]=='[' ||str[i]=='{'){
   
			Push(S,str[i]);
		}else{
   
			if(StackEmpty(S))	//扫描到右括号，且当前栈为空
				return false;	//匹配失败
			char topElem;
			Pop(S,topElem);		//栈顶元素出栈
			if(str[i]==')' && topElem!='(')
				retuen false;
			if(str[i]==']' && topElem!='[')
				retuen false;
			if(str[i]=='}' && topElem!='{')
				retuen false;
		}
	}
		StackEmpty(S);		//检索完全部括号后，栈空说明匹配成功
}

备注：首先定义一个栈并且初始化这个栈，接下来用一个循环从左往右扫描这些字符，如果此次扫描到的字符它是莫一种左括号的话，那么我们就把这个字符给他Push压入栈中；
如果只是扫描到的是右括号，那么就首先需要检查栈是否为空，栈空的话，就说明右括号单身，匹配失败；
如果栈不空我们就用Pop出栈的操作，把这样的元素弹出去，然后用topElem变量来存储。
然后就检查扫描到的右括号和当前栈顶的左括号是否匹配，如果只是扫描到的右小括号，而栈顶的不是左小括号，匹配失败。以此类推，处理完所有括号。
最后判断栈是否为空，空，匹配成功。

栈的应用(表达式求值)

中缀转后缀的手算方法

1.确定中缀表达式中各个运算符的运算顺序
2.选择下一个运算符，按照『左操作数右操作数运算符』的方式组合成一个新的操作数
3.如果还有运算符没有被处理，就继续步骤2
左优先原则：只要左边的运算符能计算，就优先算左边的

中缀转后缀（机算）

初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。
从左到右处理各个元素，知道末尾。
可能遇到三种情况：
1、遇到操作数。直接加入后缀表达式。
2、遇到界限符。遇到"(“直接入栈，遇到”)“则依次弹出栈内运算符并加入后缀表达式，知道弹出”(“为止。注意：”(“不加入后缀表达式。
3、遇到运算符。依次弹出栈中优先级高于或等于当前运算符的所有运算符，并加入后缀表达式，若碰到”("或栈空则停止。之后再把当前运算符入栈。
按照上述方法处理完所有字符后，将栈中剩余运算依次弹出，并加入后缀表达式。

中缀转后缀（用栈实现）

初始化两个栈，操作数栈和运算符栈
若扫描到操作数，压入操作数栈
若扫描到运算符或界限符，则按照”中缀转后缀“相同的逻辑压入运算符栈（期间也会弹出运算符，每当弹出一个运算符时，就需要再弹出两个操作数栈的栈顶元素并执行相应运算，运算结果在再回操作数栈）

栈的应用（递归）

函数调用背后的过程
函数调用的特点：最后被调用的函数最想执行结束（LIFO）。
函数调用时，需要用一个栈存储：
1、调用返回地址
2、实参
3、局部变量

3.2队列

3.2.1队列的基本概念

队列常见的基本操作

InitQueue(&Q): 初始化队列。构造一个空队列Q。
DestroyQueue(&Q):销毁队列。销毁并释放队列Q所占用的内存空间。

EnQueue(&Q,x): 入队，若队列Q未满，将x加入，使之成为新的队尾。
DeQueue(&Q,&x): 出队，若队列Q非空，删除队头元素，并用x返回。

GetHead(Q,&x): 读队头元素，若队列Q非空，则将队头元素赋值给x。

3.2.2 队列的顺序存储

定义声明

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
ElemType data[MaxSize];		//用静态数组存放队列元素
int front,rear;				//对头指针和队尾指针
} SqQueue;
void testQueue(){
   
SqQueue Q;					//声明一个队列
//.......
}

初始化

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];		//用静态数组存放队列元素
	int front,rear;				//对头指针和队尾指针
} SqQueue;
//初始化队列
void InitQueue(SqQueue &Q){
   
	//初始时  队头和队尾指针指向0
	Q.rear=Q.front=0;
}

void testQueue(){
   
	SqQueue Q;					//声明一个队列
	InitQueue(Q);
	//....
}

队列判空

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];		//用静态数组存放队列元素
	int front,rear;				//对头指针和队尾指针
} SqQueue;
//判空
bool QueueEmpty(SqQueue Q){
   
	if(Q.rear==Q.front){
   		//判空条件
		return true;
	else
		return false;
}

入队

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];		//用静态数组存放队列元素
	int front,rear;				//对头指针和队尾指针
} SqQueue;
//入队
bool EnQueue(SqQueue &Q,ElemType x){
   
	if(队列已满)
		return false;
	Q.data[Q.rear]=x;			//新元素插入队尾
	Q.rear=(Q.rear+1)%MaxSize;  //队尾指针加一  取余
	return true;
}

备注：Q.rear=(Q.rear+1)%MaxSize 就是相当于用模运算将储存空间在逻辑上变成了“环状”。
MaxSize=10,当队列时，从队头出去了3个元素，那么rear还表示满队列，取余之后（9+1）%10 = 0，rear就会返回到起点。

出队

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];		//用静态数组存放队列元素
	int front,rear;				//对头指针和队尾指针
} SqQueue;
//出队（删除一个队头元素，并用x返回）
bool DeQueue(SqQueue &Q,ElemType &x){
   
	if(Q.rear==Q.front)
		return false;
	x=Q.data[Q.front];
	Q.front=(Q.front+1)%MaxSize; //队头指针后移
	return true;
}

队列元素个数：(rear+MaxSize-front)%MaxSize

判断队满(方法一)

//入队
bool EnQueue(SqQueue &Q,ElemType x){
   
	if((Q.rear+1)%MaxSise==Q.front)
		return false;
	Q.data[Q.rear]=x;			//新元素插入队尾
	Q.rear=(Q.rear+1)%MaxSize;  //队尾指针加一  取余
	return true;
}

备注：必须牺牲一个单位，否则Q.rear==Q.front 是队空条件。

判断队列已满/已空(方法二)

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];		//用静态数组存放队列元素
	int front,rear;				//对头指针和队尾指针
	int size;					//队列当前长度
} SqQueue;
//插入成功size++;  删除成功size--;  队满条件size==MaxSize;

备注：size：队列当前长度。队满条件size==MaxSize; 插入成功size++; 删除成功size–;

判断队列已满/已空(方法三)

#define MaxSize 10          //定义队列中元素的最大个数
typedef struct{
   
	ElemType data[MaxSize];		//用静态数组存放队列元素
	int front,rear;				//对头指针和队尾指针
	int tag;					//最近进行的是删除/插入
} SqQueue;
//队满条件：(front==rear && tag==1);
//队空条件：(front==rear && tag==0);

每次删除操作成功时，都令tag=0；只有删除操作，才可能导致队空。
每次插入操作成功时，都令tag=1；只有插入操作，才可能导致队满。

队列的链式实现

定义

typedef struct LinkNode{
   
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
   					//链式队列
	LinkNode *front,*rear;		//队列的队头和队尾指针
}LinkQueue;

初始化

typedef struct LinkNode{
   
	ElemType data;
	struct LinkNode *next;
}LinkNode;
typedef struct{
   					//链式队列
	LinkNode *front,*rear;		//队列的队头和队尾指针
}LinkQueue;
//初始化队列(带头结点)
void InitQueue(LinkQueue &Q){
   
	//初始时， front、rear 都指向头节点
	Q.front=Q.rear=(LinkNode*)malloc(sizeof(LinkQueue));
	Q.front->next=NULL;
}
void testLinkQueue(){
   
	LinkQueue();	//声明一个队列
	InitQueue();	//初始化队列
}

判空

bool IsEmpty(LinkQueue Q){
   
	if(Q.front==Q.rear)
		return true;
	else
		return false;

入队(带头节点)

//新元素入队(带头节点)
void EnQueue(LingkQueue &Q,ElemType x){
   
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));//申请新节点
	s->data=x;			//x放到新节点当中
	s-next=NULL;		//
	Q.rear->next=s;		//新节点插入到rear之后
	Q.rear=s;			//修改表尾指针
}

备注：入队或者说队列的插入操作其实是在表尾的位置进行的，因此新插入的节点肯定是队列当中的最后一个节点，所以我们需要把新节点中的next指针域设置为NULL;
rear指针指向的是当前的表尾节点，而我们新插入的新节点应该连到当前表尾结点之后，所以我们需要把rear指向的节点，他的next指针域让他指向新节点s，最后还要让表尾指针指向新节点

入队（不带头结点）

void EnQueue(LingkQueue &Q,ElemType x){
   
	LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));//申请新节点
	s->data=x;			//x放到新节点当中
	s-next=NULL;	
	if(Q.front==NULL){
   	//在空队列中插入第一个元素
	Q.front =s;			//不修改队头队尾指针
	Q.rear=s;			
	}else{
   
		Q.rear->next=s;	//新节点插入到 rear 结点之后
		Q.rear=s;		//修改rear指针
	}

备注：不带头结点的话，在第一个元素入队时，需要进行特殊处理，需要对rear，front指针都进行修改。
需要一个判断，来判断如果队列为空的话，就意味着新插入的节点是队列中的第一个节点，此时需要修改rear，front的指向，让他们都指向第一个节点。
继续插入的话，rear指针指向的节点进行后插操作，同时修改rear指针的指向，每一次插入的新节点之后，都让rear指针指向新的表尾节点。

出队（带头节点）

bool DeQueue(LinkQueue &Q,ElemType &x){
   
	if(Q.front==Q.rear)
		return false;			//空队
	LinkNode *p=Q.front->next;
	x=p->data;					//用变量x返回队头元素
	Q.front->next=p->next;		//修改头节点的next指针
	if(Q.rear==p)				//此次修改是最后一个节点出队
		Q.rear=Q.front;			//修改rear指针
	free(p);					//释放节点空间
	return true;
}

备注：对于带头节点的队列，就是要删除这个头节点的后面一个节点。
先用变量x把此次要删除的数据元素带回去，所以用了&x，再往后就是修改这个头节点的next指针，指向被删除的next元素。
如果被删除的节点不是最后一个节点，直接释放就行了，如果是表尾节点，我们还需要修改表尾指针，让他指向头节点，rear和front指向同一位置，就代表着又变成了空队列。

出队（不带头节点）

bool DeQueue(LinkQueue &Q,ElemType &x){
   
	if(Q.front==NULL)
		return false;			//空队
	LinkNode *p=Q.front;		//p指向此次出队的节点
	x=p->data;					//用变量x返回队头元素
	Q.front=p->next;			//修改front指针
	if(Q.rear==p){
   				//此次是最后一个节点出队
		Q.front=NULL;			//修改front指针
		Q.rear=NULL;			//修改rear指针
	}
	free(p);					//释放节点空间
	return true;
}

备注：由于没有头节点，因此每一个队头元素出队之后都与要修改front指针的指向。在最后一个节点出队之后也需要把front和rear都指向NULL,即恢复成空队列。

3.4特殊矩阵的压缩矩阵

数组

ElemType a[10]; //ElemType型一维数组
一维数组元素a[i]的存放地址：LOC+i*sizeof(ElemType)
一维数组的大小：(1+n)*n/2

ElemType b[2] [4]; //2行4列的二维数组
行优先储存：b[i] [j]的存放地址：LOC+(i * N+j) * sizeof(ElemType) (M行N列)
列优先储存：b[i] [j]的存放地址：LOC+(j * M+i) * sizeof(ElemType) (M行N列)

3.43矩阵的压缩矩阵

对称矩阵

若n阶方阵中任意一个元素ai j都有ai j = aj i 则该矩阵称为对称矩阵

第四章串

4.1串的定义和实现

4.1.2串的储存结构

定长顺序储存

#define MAXLEN 255			//预定义最大串长255
typedef struct{
   
	char ch[MAXLEN];		//每个分量储存一个字符
	int length;				//串的实际长度
}SString;

堆分配储存表示

typedef struct{
   
	char *ch;				//按串长分配存储地址，ch指向串的基地址
	int length;				//串的长度
}HString;
HString S;
S.ch = (char *)malloc(MAXLEN * sizeof(char)):
S.length = 0;

4.1.3串的基本操作

StrAssign(&T,chars): 赋值操作。把串T赋值为chars。
StrCopy(&T,S): 复制操作。由串S复制得到串T。
StrEmpty(S): 判空操作。若S为空串，则返回true，否则返回false。
StrLength(S): 求串长。返回串S的元素个数。
ClearString(&S): 清空操作。将S清为空串。
DestroyString(&S): 销毁串。将串S销毁（回收存储空间）。
Concat(&T,S1,S2): 串连接。用T返回由S1和S2连接而成的新串。
SubString(&Sub,S,pos,len):求子串。用Sub返回串S的第pos个字符起长度为len的子串。
Index(S,T): 定位操作。若主串S中存在与串T值相同的子串，则返回他的主串S中第一次出现的位置，否则函数值为0.
StrCompare(S,T): 比较操作。若S>T,则返回>0;若S=T,则返回值=0；若S<T，则返回值<0;

求子串

SubString(&Sub,S,pos,len):求子串。用Sub返回串S的第pos个字符起长度为len的子串

#define MAXLEN 255			//预定义最大串长255
typedef struct{
   
	char ch[MAXLEN];		//每个分量储存一个字符
	int length;				//串的实际长度
}SString;
//求子串
bool SubString(SString &Sub,SString S, int pos,int len){
   
	//子串范围越界
	if(pos + len -1 > S.length)
		retuen false;
	for (int i = pos;i<pos+len;i++)
		Sub.ch[i-pos+1] = S.ch[i];
	Sub.length = len;
	return true;
}

备注：先传入一个叫Sub的串，用串返回我们想要找到的子串的内容，然后for循环把特定范围内的各个字符把他依次都赋值到Sub的char数组里，并且还需要把Sub的length设置为len。
if是判断子串范围是否越界。

比较字符串

StrCompare(S,T): 比较操作。若S>T,则返回>0;若S=T,则返回值=0；若S<T，则返回值<0;

#define MAXLEN 255			//预定义最大串长255
typedef struct{
   
	char ch[MAXLEN];		//每个分量储存一个字符
	int length;				//串的实际长度
}</

最低0.47元/天解锁文章

Jiang。

关注

7
点赞
踩
31

收藏

觉得还不错? 一键收藏
0
评论
王道考研-数据结构算法

目录第一章绪论第二章线性表第三章栈和队列3.1栈3.11栈的基本操作3.1.2栈的顺序存储结构顺序栈链栈3.2队列3.2.1队列的基本概念第四章串第五章树与二叉树第六章图第七章查找第八章排序第一章绪论第二章线性表第三章栈和队列3.1栈3.11栈的基本操作InitStack(&S): 初始化栈。构造一个空栈S，分配内存空间。DestroyStack(&L): 销毁栈。销毁并释放栈S所占用的内存空间。Push(&S,x): 进栈，若栈S未满，则将x加
复制链接

扫一扫