王道考研-数据结构算法

最新推荐文章于 2024-04-29 20:11:44 发布

Jiang。

最新推荐文章于 2024-04-29 20:11:44 发布

阅读量3.1k

点赞数 7

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

本文链接：https://blog.youkuaiyun.com/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] =