数据结构专题（二）

最新推荐文章于 2023-12-08 18:02:14 发布

小成不秃头

最新推荐文章于 2023-12-08 18:02:14 发布

阅读量222

点赞数

分类专栏：数据结构笔记文章标签：蓝桥杯 c++ 算法数据结构

本文链接：https://blog.youkuaiyun.com/Xaiochengsmdbh/article/details/128687613

版权

数据结构笔记专栏收录该内容

2 篇文章

订阅专栏

栈和队列

1.顺序栈
2.链栈
3.顺序队列
4.链队列
5.栈和队列的应用
6.栈和队列学习秘籍

1.顺序栈

顺序栈的结构体定义（动态分配）

#define Maxsize 100 //预先分配空间，这个数值根据实际需要预估确定 
typedef struct SqStack{
ElemType data[Maxsize];
int top;
}SqStack;

顺序栈的结构体定义（静态分配）

typedef struct SqStack{
	ElemType data[Maxsize];
	int top;
}SqStack;

1.顺序栈的初始化

bool InitStack(SqStack &S)
{
	S.base=new int[Maxsize];
	if(!S.base)
		return false;
	S.top=S.base;
	return true;
}

2.入栈

bool Push(SqStack &S,int e)		//将新元素e压入栈顶
{
	if(S.top-S.base==Maxsize)	//栈满
		return false;
	*S.top++=e;					//将新元素e压入栈顶，然后栈顶指针加1，等价于*S.top=e;S.top++;
	return true;
}

3.出栈

bool Pop(SqStack &S,int &e)		//删除S的栈顶元素，暂存在变量e中
{
	if(S.base==S.top)			//栈空
		return false;
	e=*--S.top;					//栈顶指针减1后，将栈顶元素赋值给e
	return true;
}

4.取栈顶元素

int GetTop(SqStack S)			//返回S的栈顶元素，栈顶指针不变
{
	if(S.top != S.base)			//栈非空
		return *(S.top - 1);		//返回栈顶元素的值，栈顶指针不变
	else
		return -1;
}

5.判空

bool Empty(SqStack S)
{
	if(S.base==S.top)
		return true;
	else
		return false;
}

2.链栈

1.链栈的初始化

bool InitStack(LinkStack &S)		//构造一个空栈S
{
	S=NULL;
	return true;
}

2.入栈

bool Push(LinkStack &S, int e)		//在栈顶插入元素e
{
	LinkStack p;
	p = new Snode;					//生成新节点
	p->data = e;					//将e存入新节点数据域
	p->next = S;					//将新节点p的next指针指向S，将S的地址赋值给新节点的指针域
	S = p;							//修改新栈顶指针为p
	return true;
}

3.出栈

bool Pop(LinkStack &S, int &e)		//删除S的栈顶元素，用e保存其值
{
	LinkStack p;
	if(S==NULL)						//栈空
		return false;			
	e=S->data;						//用e暂存栈顶元素数据
	p=S;							//用p保存栈顶元素地址，以备释放
	S=S->next;						//修改栈顶元素指针，指向下一个节点
	delete p;						//释放原栈顶元素的空间
	return true;
}

4.取栈顶元素

int GetTop(LinkStack S)
{
	if(S != NULL)
		return S->data;
	else
		return -1;
}

3.顺序队列

3.1.顺序队列的定义
顺序队列的结构体定义（动态分配）

typedef struct SqQueue{
	ElemType *base;
	int front,reat;
}SqQueue;

顺序队列的结构体定义（静态分配）

typedef struct SqQueue{
	ElemType data[Maxsize]
	int front,reat;
}SqQueue;

3.2.循环队列的定义

//队空
Q.front==Q.rear;					//Q.rear和Q.front指向同一个位置
//队满
(Q.rear+1)%Maxsize==Q.front			//Q.rear向后移一位正好是Q.front
//入队
Q.base[Q.rear]=x;					//将元素x放入Q.rear所指空间
Q.rear=(Q.rear+1)%Maxsize;			//Q.rear向后移一位
//出队
e=Q.base[Q.front];					//用变量记录Q.front所指元素
Q.front=(Q.front+1)%Maxsize			//Q.front向后移一位
//队列元素个数
(Q.rear-Q.front+Maxsize)%Maxsize

3.3.循环队列的基本操作
1.初始化

bool InitQueue(SqQueue &Q)			//注意使用引用参数，否则出了函数，其改变无效
{
	Q.base=new int[Maxsize];		//分配Maxsize大小的空间
	if(!Q.base) return false;		//分配空间失败
	Q.front=Q.rear=0;				//队头和队尾置0，队列为空
	return true;
}

2.入队

bool EnQueue(SqQueue &Q,int e)			//将元素e放入Q的队尾
{
	if((Q.rear+1)%Maxsize==Q.front)		//队尾后移一位等于对头，表明队满
		return false;
	Q.base[Q.rear]=e;					//新元素插入队尾
	Q.rear=(Q.rear+1)%Maxsize;			//队尾后移一位
	return true;
}

3.出队

bool DeQueue(SqQueue &Q,int &e)			//删除Q的对头元素，用e返回其值
{
	if(Q.front==Q.rear)
		return false;					//队空
	e=Q.base[Q.front];					//保存队头元素
	Q.front=(Q.front+1)%Maxsize;		//队头后移一位
	return true;
}

4.取队头元素

bool GetHead(SqQueue Q)					//返回Q的队头元素，不修改队头
{
	if(Q.front!=Q.rear)					//队列非空
		return Q.base[Q.front];
	return -1;
}

5.求队列的长度

int	QueueLength(SqQueue Q)
{
	return (Q.rear-Q.front+Maxsize)%Maxsize;
}

4.链队列

节点的结构体定义

typedef struct Qnode{
	ElemType data;
	struct Qnode *next;
}Qnode,Qptr;

链队列的结构体定义

typedef struct{
	Qnode *front;
	Qnode *rear;
}LinkQueue;

1.初始化

void InitQueue(LinkQueue &Q)		//注意使用引用参数，否则出了函数，改变无效
{
	Q.front=Q.rear=new Qnode;		//创建头节点，头指针和尾指针指向头节点
	Q.front->next=NULL;
}

2.入队

p = new Snode;		//生成新节点
p->data = e;		//将e放在新节点数据域

void EnQueue(LinkQueue &Q,int e)	//将元素e放入队尾
{
	Qptr s;
	s=new Qnode;
	s->data=e;
	s->next=NULL;
	Q.rear->data=s;		//新节点插入队尾
	Q.rear=s;			//尾指针后移
}

3.出队

bool DeQueue(LinkQueue &Q,int &e)	//删除Q的队头元素，用e返回其值
{
	Qptr p;
	if(Q.front==Q.rear)				//队空
		return false;
	p=Q.front->next;
	e=p->data;						//保存队头元素
	Q.front->next=p->next;
	if(Q.rear==p)					//若队列中只有一个元素，删除后需要修改队尾指针
		Q.rear=Q.front;
	delete p;
	return true;
}

4.取队头元素

int GetHead(LinkQueue Q)				//返回Q的队头元素，不修改队头指针
{
	if(Q.front!=Q.rear)					//队列非空
		return Q.front->next->data;	
	return -1;
}

5.栈和队列的应用

1.数值的转换
题目：将一个十进制数n转换为二进制数。
算法步骤
1)初始化一个栈S
2)如果n！=0，将n%2入栈S，更新n=n/2
3)重复第2步，直到n为0为止
4)如果栈不空，弹出栈顶元素e，输出e，直到栈空

void binaryconersion(int n)
{
	SqStack S;					//定义一个栈
	int e;
	InitStack(S);				//初始化一个空栈
	while(n)					//n不为0时，一直循环
	{
		Push(S,n%2);			//入栈
		n=n/2;					//更新
	}
	while(!Empty(S))			//如果栈不空
	{
		Pop(S,e);				//出栈
		cout<<e<<"\t";			//输出栈顶元素
	}
}

完整代码

#include<bits/stdc++.h>
using namespace std;

#define Maxsize 100
#define ElemType int

typedef struct SqStack{
	ElemType *base;
	ElemType *top;
}SqStack;

bool InitStack(SqStack &S)
{
	S.base=new int[Maxsize];
	if(!S.base)
		return false;
	S.top=S.base;
	return true;
}

bool Push(SqStack &S,int e)
{
	if(S.top-S.base==Maxsize)
		return false;
	*S.top++=e;
	return true;
}

bool Pop(SqStack &S,int &e)
{
	if(S.base==S.top)
		return false;
	e=*--S.top;
	return true;
}

bool Empty(SqStack S)
{
	if(S.base==S.top)
		return true;
	else 
		return false;
}

void binaryconversion(int n)
{
	SqStack S;
	int e;
	InitStack(S);
	while(n)
	{
		Push(S,n%2);
		n=n/2;
	}
	while(!Empty(S))
	{
		Pop(S,e);
		cout<<e;
	}
}

int main()
{
	int n;
	cin>>n;
	binaryconversion(n);
	return 0;
}

2.回文判定
题目：回文是指正读反读均相同的字符序列，如“abba”和“abcscba”均是回文，也就是说字符串沿中心线对称
算法步骤
1）初始化一个栈S
2）求字符串长度，将前面一半的字符一次入栈S
3）如果栈不空，弹出栈顶元素e，与字符串后一半元素比较。若n为奇数，则跳过中心点，比较中心点后面的元素。如果元素相等，则继续比较直到栈空，返回true，如果元素不等，返回false

bool palindrome(char *str)		//判断字符串是否为回文
{
	SqStack S;					//定义一个栈S
	int len,i;
	char e;
	len=strlen(str);			//返回字符串长度
	InitStack(S);				//初始化栈
	for(i=0;i<len/2;i++)		//将字符串前一半依次入栈
		Push(S,str[i]);
	if(len/2==1)				//字符串长度为奇数，跳过中心点
		i++;
	while(!Empty(S))			//如果栈不空
	{
		Pop(S,e);				//出栈
		if(e!=str[i])			//比较元素是否相等
			return false;
		else
			i++;
	}
	return true;
}

完整代码

#include<bits/stdc++.h>
using namespace std;

#define Maxsize 100
#define ElemType int

typedef struct SqStack{
	ElemType *base;
	ElemType *top;
}SqStack;

bool InitStack(SqStack &S)
{
	S.base=new int[Maxsize];
	if(!S.base)
		return false;
	S.top=S.base;
	return true;
}

bool Push(SqStack &S,int e)
{
	if(S.top-S.base==Maxsize)
		return false;
	*S.top++=e;
	return true;
}

bool Pop(SqStack &S,int &e)
{
	if(S.base==S.top)
		return false;
	e=*--S.top;
	return true;
}

bool Empty(SqStack S)
{
	if(S.base==S.top)
		return true;
	else 
		return false;
}

void binaryconversion(int n)
{
	SqStack S;
	int e;
	InitStack(S);
	while(n)
	{
		Push(S,n%2);
		n=n/2;
	}
	while(!Empty(S))
	{
		Pop(S,e);
		cout<<e;
	}
}

bool palindrome(char *str)		//判断字符串是否为回文
{
	SqStack S;					//定义一个栈S
	int len,i;
	int e;
	len=strlen(str);			//返回字符串长度
	InitStack(S);				//初始化栈
	for(i=0;i<len/2;i++)		//将字符串前一半依次入栈
		Push(S,str[i]);
	if(len/2==1)				//字符串长度为奇数，跳过中心点
		i++;
	while(!Empty(S))			//如果栈不空
	{
		Pop(S,e);				//出栈
		if(e!=str[i])			//比较元素是否相等
			return false;
		else
			i++;
	}
	return true;
}

int main()
{
	char str[Maxsize];
	cin>>str;
	if(palindrome(str))
		cout<<1<<endl;
	else
		cout<<2<<endl;
	
	
	
	return 0;
}