#05 栈

最新推荐文章于 2022-05-16 19:27:38 发布
最新推荐文章于 2022-05-16 19:27:38 发布
阅读量584 收藏 1
点赞数 2
分类专栏： 数据结构（C语言版） 文章标签： 算法 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014419722/article/details/120572034
版权

参考答案看底部

  1. 链栈出栈
    题目描述
    编写函数实现链栈出栈操作
    前置代码：
    #$#链栈的实现**/
    #include
    #include
    using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef char SElemType;

typedef struct StackNode {
SElemType data;
struct StackNode *next;
} StackNode, *LinkStack;
Status Push(LinkStack &S, SElemType e) ;
Status Pop(LinkStack &S, SElemType &e);

//算法　链栈的初始化
Status InitStack(LinkStack &S) { // 构造一个空栈 S，栈顶指针置空
S = NULL;
return OK;
}

int main() {
LinkStack s,p;
int n,i;
SElemType x,t;
InitStack(s);
cin>>n;
for(i=0;i<n;i++)
{
cin>>x;
Push(s,x);
}

while(Pop(s,t))
{
cout<<t<<endl;
}
return 0;
}
//算法　链栈的入栈
Status Push(LinkStack &S, SElemType e) {//在栈顶插入元素e
LinkStack p;
p = new StackNode; //生成新结点
p->data = e; //将新结点数据域置为e
p->next = S; //将新结点插入栈顶
S = p; //修改栈顶指针为p
return OK;
}

输入描述
整数n
n个元素
输出描述
n个元素按出栈顺序输出
样例输入
3
A
B
C
样例输出
C
B
A
提示
D
C
B
A

2. 链栈入栈
题目描述
编写函数实现链栈入栈操作
前置代码：
#$#链栈的实现**/
#include
#include
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef char SElemType;

typedef struct StackNode {
SElemType data;
struct StackNode *next;
} StackNode, *LinkStack;
Status Push(LinkStack &S, SElemType e) ;

//算法3.5　链栈的初始化
Status InitStack(LinkStack &S) { // 构造一个空栈 S，栈顶指针置空
S = NULL;
return OK;
}

int main() {
LinkStack s,p;
int n,i;
SElemType x,t;
InitStack(s);
cin>>n;
for(i=0;i<n;i++)
{
cin>>x;
Push(s,x);
}
p=s;
while§
{
cout<data<<endl;
p=p->next;
}
return 0;
}

输入描述
整数n表示有n个元素
n个元素
输出描述
按照出栈顺序输出n个元素
样例输入
3
A
B
C
样例输出
C
B
A

3. 顺序栈出栈
题目描述
编写函数实现顺序栈的出栈
前置代码：
#$#顺序栈的实现**/

#include
#include
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 100//顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;

typedef struct {
SElemType *base;//栈底指针
SElemType *top;//栈顶指针
int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
if (!S.base)
exit(OVERFLOW); //存储分配失败
S.top = S.base; //top初始为base，空栈
S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
return OK;
}

int main() {
SqStack s;
int n,i;
SElemType x,t;
InitStack(s);
cin>>n;
for(i=0;i<n;i++)
{
cin>>x;
Push(s,x);
}
while (Pop(s, t)){
cout << t <<endl;
}
return 0;
}

//算法　顺序栈的入栈
Status Push(SqStack &S, SElemType e) {
// 插入元素e为新的栈顶元素
if (S.top - S.base == S.stacksize)
return ERROR; //栈满
*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
return OK;
}

提交时请使用C++语言
输入描述
整数n代表元素个数
n个元素
输出描述
按出栈顺序输出站内元素
样例输入
4
A
B
C
D
样例输出
D
C
B
A

4. 顺序栈入栈
题目描述
编写函数实现顺序栈入栈操作
前置代码：
#$#顺序栈的实现**/

#include
#include
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE 100//顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;

typedef struct {
SElemType *base;//栈底指针
SElemType *top;//栈顶指针
int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
if (!S.base)
exit(OVERFLOW); //存储分配失败
S.top = S.base; //top初始为base，空栈
S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
return OK;
}

int main() {
SqStack s;
int n,i;
SElemType x,t;
InitStack(s);
cin>>n;
for(i=0;i<n;i++)
{
cin>>x;
Push(s,x);
}
for(i=n-1;i>=0;i–)
{
cout<<s.base[i]<<endl;
}
return 0;
}

提交时请选择C++语言
输入描述
整数n代表入栈元素个数
n个元素
输出描述
按出栈顺序输出n个元素
样例输入
3
A
B
C
样例输出
C
B
A

5. 顺序栈实现回文串
题目描述
请你使用顺序栈编写symmetry函数实现判断一个字符串是否为回文
bool symmetry(ElemType str[])
编写主函数调用子函数symmetry
同时对其中用到的功能段尽量用子函数来实现
输入描述
输入一串字符串，遇回车结束
输出描述
是回文或者不是回文
样例输入
asdffdsa
样例输出
是回文
提示
使用顺序栈实现

6. 栈的应用–数制转换
题目描述
编写函数实现将一个十进制数转换成对应的数值。
要求用栈实现存储转换结果，需要编写栈的初始化函数、栈的入栈、出栈、判断栈空
输入描述
第一行：输入一个十进制整数
第二行：输要求转换的数制
输出描述
输出对应的数值
样例输入
10
2
样例输出
1010

7. 判断括号匹配
题目描述
给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。
函数接口：bool isValid(char* s)

输入描述
只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串
输出描述
有效或无效
样例输入
{(()[])}
样例输出
有效
提示

8. Hanoi递归的实现
题目描述
有A,B,C三个塔座，A上套有n个直径不同的圆盘，按直径从小到大叠放，形如宝塔,由小到大的编号为1,2,3……n。要求将n个圆盘从A移到C，叠放顺序不变，移动过程中遵循下列原则：
•每次只能移一个圆盘
•圆盘可在三个塔座上任意移动
•任何时刻，每个塔座上不能将大盘压到小盘上
输入描述
输入圆盘个数
输出描述
输出移动的步数，盘号，起始盘号，目标盘号
样例输入
4
样例输出
1,1,a,b
2,2,a,c
3,1,b,c
4,3,a,b
5,1,c,a
6,2,c,b
7,1,a,b
8,4,a,c
9,1,b,c
10,2,b,a
11,1,c,a
12,3,b,c
13,1,a,b
14,2,a,c
15,1,b,c

参考答案

  1. 链栈出栈
#include<iostream>
#include<fstream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef char SElemType;

typedef struct StackNode {
SElemType data;
struct StackNode *next;
} StackNode, *LinkStack;
Status Push(LinkStack &S, SElemType e) ;
Status Pop(LinkStack &S, SElemType &e);

//算法　链栈的初始化
Status InitStack(LinkStack &S) { // 构造一个空栈 S，栈顶指针置空
S = NULL;
return OK;
}

int main() {
LinkStack s,p;
int n,i;
SElemType x,t;
    InitStack(s); 
    cin>>n;
    for(i=0;i<n;i++)
    {
    cin>>x;
    Push(s,x);
}
    
while(Pop(s,t))
    {
    cout<<t<<endl;    
}
return 0;
}
//算法　链栈的入栈
Status Push(LinkStack &S, SElemType e) {//在栈顶插入元素e
LinkStack p;
p = new StackNode; //生成新结点
p->data = e; //将新结点数据域置为e
p->next = S; //将新结点插入栈顶
S = p; //修改栈顶指针为p
return OK;
}
Status Pop(LinkStack &S, SElemType &e){
	if(S!=NULL){
	e=S->data;
	S=S->next;
	return e;
	}else{
		return ERROR;
	}
}
  1. 链栈入栈
#include<iostream>
#include<fstream>
using namespace std;

#define OK 1
#define ERROR 0
#define OVERFLOW -2
typedef int Status;
typedef char SElemType;

typedef struct StackNode {
SElemType data;
struct StackNode *next;
} StackNode, *LinkStack;
Status Push(LinkStack &S, SElemType e) ;

//算法3.5　链栈的初始化
Status InitStack(LinkStack &S) { // 构造一个空栈 S，栈顶指针置空
S = NULL;
return OK;
}

int main() {
LinkStack s,p;
int n,i;
SElemType x,t;
    InitStack(s); 
    cin>>n;
    for(i=0;i<n;i++)
    {
    cin>>x;
    Push(s,x);
}
    p=s;
while(p)
    {
    cout<<p->data<<endl;
    p=p->next;
}
return 0;
}
Status Push(LinkStack &S, SElemType e) {//在栈顶插入元素e
LinkStack p;
p = new StackNode; //生成新结点
p->data = e; //将新结点数据域置为e
p->next = S; //将新结点插入栈顶
S = p; //修改栈顶指针为p
return OK;
}
  1. 顺序栈出栈
#include<iostream>
#include<fstream>
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100//顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;

typedef struct {
SElemType *base;//栈底指针
SElemType *top;//栈顶指针
int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
if (!S.base)
exit(OVERFLOW); //存储分配失败
S.top = S.base; //top初始为base，空栈
S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
return OK;
}

int main() {
SqStack s;
int n,i;
SElemType x,t;
    InitStack(s); 
    cin>>n;
    for(i=0;i<n;i++)
    {
    cin>>x;
    Push(s,x);
}
    while (Pop(s, t)){
cout << t <<endl;
}
return 0;
}

//算法　顺序栈的入栈
Status Push(SqStack &S, SElemType e) {
// 插入元素e为新的栈顶元素
if (S.top - S.base == S.stacksize)
return ERROR; //栈满
*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
return OK;
}
Status Pop(SqStack &S, SElemType &e){
	if(S.top==S.base) return ERROR;
	e=*--S.top;
	return OK;
}
  1. 顺序栈入栈
#include<iostream>
#include<fstream>
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100//顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;

typedef struct {
SElemType *base;//栈底指针
SElemType *top;//栈顶指针
int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
if (!S.base)
exit(OVERFLOW); //存储分配失败
S.top = S.base; //top初始为base，空栈
S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
return OK;
}

int main() {
SqStack s;
int n,i;
SElemType x,t;
    InitStack(s); 
    cin>>n;
    for(i=0;i<n;i++)
    {
    cin>>x;
    Push(s,x);
}
    for(i=n-1;i>=0;i--)
    {
    cout<<s.base[i]<<endl;
}
return 0;
} 
Status Push(SqStack &S, SElemType e) {
// 插入元素e为新的栈顶元素
if (S.top - S.base == S.stacksize)
return ERROR; //栈满
*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
return OK;
}
  1. 顺序栈实现回文串
#include<iostream>
#include<fstream>
#include<string.h> 
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100//顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;

typedef struct {
	SElemType *base;//栈底指针
	SElemType *top;//栈顶指针
	int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
bool symmetry(SElemType str[]); 
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
	if (!S.base)
		exit(OVERFLOW); //存储分配失败
		S.top = S.base; //top初始为base，空栈
		S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
		return OK;
}

int main() {
	SqStack s;
	SElemType str[20];
    InitStack(s); 
    cin>>str;
    bool a= symmetry(str); 
	if(a)
	    cout<<"是回文"<<endl;
	else
	    cout<<"不是回文"<<endl; 
    
	return 0;
}

//算法　顺序栈的入栈
Status Push(SqStack &S, SElemType e) {
// 插入元素e为新的栈顶元素
	if (S.top - S.base == S.stacksize)
		return ERROR; //栈满
		*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
		return OK;
}
Status Pop(SqStack &S,SElemType &e){
	if(S.top!=S.base){
		e=*--S.top;
		return OK;
	}else{
		return ERROR;
	}
}
bool symmetry(SElemType str[]){
	bool b=false;
	int n;
	SElemType t; 
	int a=strlen(str);
	SqStack s;
    InitStack(s);  
	if(a%2==1){
		n=a/2+1; 
	}else{
		n=a/2; 
	}
	for(int i=0;i<a/2;i++){
		Push(s,str[i]); 
	}
	for(int j=n;j<a;j++){
		Pop(s,t); 
		if(str[j]!=t) {
			b=false;
			return b;
		} else{
			b=true;
                 }
	} 
	return b; 
}
  1. 栈的应用–数制转换
#include<iostream>
#include<fstream>
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100//顺序栈存储空间的初始分配量
typedef int Status;
typedef int SElemType;

typedef struct {
	SElemType *base;//栈底指针
	SElemType *top;//栈顶指针
	int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
	if (!S.base)
		exit(OVERFLOW); //存储分配失败
		S.top = S.base; //top初始为base，空栈
		S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
		return OK;
}

int main() {
	SqStack s;
	int num,n,m;
	SElemType t;
    InitStack(s); 
    cin>>num;
    cin>>n;
    while(num>=n){
    	m=num%n;
    	num=num/n;
    	Push(s,m);
	}
	if(num<n&&num>0){
		Push(s,num);
	} 
		 
    while (Pop(s, t)){
		printf("%d",t); 
	}
	return 0;
}

//算法　顺序栈的入栈
Status Push(SqStack &S, SElemType e) {
// 插入元素e为新的栈顶元素
	if (S.top - S.base == S.stacksize)
		return ERROR; //栈满
		*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
		return OK;
}
Status Pop(SqStack &S,SElemType &e){
	if(S.top!=S.base){
		e=*--S.top;
		return OK;
	}else{
		return ERROR;
	}
}
  1. 判断括号匹配
#include<iostream>
#include<fstream>
#include<string.h>
using namespace std;

//顺序栈定义
#define OK 1
#define ERROR 0
#define OVERFLOW -2
#define MAXSIZE  100//顺序栈存储空间的初始分配量
typedef int Status;
typedef char SElemType;

typedef struct {
	SElemType *base;//栈底指针
	SElemType *top;//栈顶指针
	int stacksize;//栈可用的最大容量
} SqStack;
Status InitStack(SqStack &S);
Status Push(SqStack &S, SElemType e);
Status Pop(SqStack &S, SElemType &e);
bool isValid(SElemType *s);
//算法3.1　顺序栈的初始化
Status InitStack(SqStack &S) {
//构造一个空栈S
	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
	if (!S.base)
        return ERROR;
		//exit(OVERFLOW); //存储分配失败
		S.top = S.base; //top初始为base，空栈
		S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
		return OK;
}

int main() {
	SqStack s;
	SElemType str[20];
    InitStack(s);
    cin>>str;
    bool b=isValid(str);
    if(b)
        cout<<"有效"<<endl;
    else
        cout<<"无效"<<endl;
	return 0;
}

//算法　顺序栈的入栈
Status Push(SqStack &S, SElemType e) {
// 插入元素e为新的栈顶元素
	if (S.top - S.base == S.stacksize)
		return ERROR; //栈满
		*(S.top++) = e; //元素e压入栈顶，栈顶指针加1
		return OK;
}
Status Pop(SqStack &S,SElemType &e){
	if(S.top!=S.base){
		e=*--S.top;
		return e;
	}else{
		return ERROR;
	}
}
bool isValid(SElemType *s){
    bool b=true;
    SqStack p;
    SElemType t;
    InitStack(p);
    int len=strlen(s);
    for(int i=0;i<=len;i++){
    	switch(s[i]){
    		case '(':Push(p,s[i]);break;
    		case '[' :Push(p,s[i]);break;
    		case '{' :Push(p,s[i]);break;
    		
    		case ')' :{
    			Pop(p,t);
				if(t!='('){
					b=false;
					return b;
				}
				break;
			}
			case ']' :{
				Pop(p,t);
				if(t!='['){
					b=false;
					return b; 
				}
				break;
			}
			case '}' :{
				Pop(p,t);
				if(t!='{'){
					b=false;
					return b; 
				}
				break;
			}

		}
    }

    return b;
}
  1. Hanoi递归的实现
#include<iostream>
#include<fstream>
using namespace std;

void move(char x,int n,char z);
void hanoi(int n,char a,char b,char c);

int id=0;

int main() {
	int n;
	char a='a';
	char b='b';
	char c='c';
	cin>>n;
	hanoi(n,a,b,c);
	return 0;
}



void move(char a,int n,char c){
	printf("%d,%d,%c,%c\n",++id,n,a,c);
}
void hanoi(int n,char a,char b,char c){
	if(n==1)
		move(a,1,c);
	else{
		hanoi(n-1,a,c,b);
		move(a,n,c);
		hanoi(n-1,b,a,c);
	} 
}
挖洞的杰瑞
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构复习-链队列入队出队（期末不挂科系列）
blotemj.blog.csdn.net
12-31 596
章节思维导图： 代码： /***链队的基本操作***/ #include<iostream> #include<fstream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef char QElemType; typedef int Status; typedef char SElemType; //- - - - - 队列的链式存储结构- - - - - t..
数据结构——栈与队列
05-20 387
东北林业大学实验二实验名称：栈、队列 实验室名称：905 实验台号：18 学生姓名：** 专业班级：2016级计算机科学与技术四班 指导教师：王阿川(教授) 实验日期： 2018-04-25 一、实验目的1．掌握栈、队列的思想及其存储实现。2．掌握栈、队列的常见算法的程序实现。二、实验仪器及环境： PC计算机；windows 10操作系统、codeblocks17.12;三、实...
模式匹配-KMP算法
Fighting_Dream
10-23 1189
/***字符串匹配算法***/ #include #include using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; #define MAXSTRLEN 255 //用户可在255以内定义最长串长 typedef char SString[MAXSTRLEN+
在顺序表中第五个位置插入一个元素9，实现顺序表插入的基本操作，输出顺序表中所有元素
Zhangguohao666的博客
12-15 6891
题目 在顺序表中第五个位置插入一个元素9，实现顺序表插入的基本操作，输出顺序表中所有元素 #include&lt;iostream&gt; using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; //Status 是函数返回值类型，其值是函数结果状态代码。 typedef ...
数据结构——邻接矩阵创建无向图，图的深度遍历
weixin_43752912的博客
07-07 2268
1.完整代码 #include<iostream> using namespace std; #define OK 1 #define ERROR 0 #define MaxInt 0 #define MVNum 100 //最大顶点数 #define Max 20 typedef char VerTexType; //顶点的数据类型为字符型 typedef int ArcType; //权值类型为整形 typedef int Status; typedef str
05 虚拟机栈.pptx
06-26
本文记录 2020 JVM 第 5 章 虚拟机栈相关知识，包括虚拟机栈的基本知识，栈的内部结构等。 该 PPT 为重绘版本。
05_虚拟机栈.pptx
05-21
虚拟机栈
alienxcn#ZXBlog#剑指Offer - 05 - 用两个栈实现一个队列1
07-25
看个例子:代码:public class Solution {public void push(int node) {思路二:每次从队列中取队头元素的时候，都是
05栈的魔法：从栈切换的角度理解进程和协程1
08-03
通过今天的学习，你将掌握协程的基本知识，这样，你在 C++ 中使用各种协程库，或者在Lua、Go 等语言中使用原生协程的时候，就能理解它们背后发生了什么，也可以
OPCUA协议栈官方C源码
08-08
此压缩包为opc基金会官方C源码实现！！！！供大家 实现参考使用！！！如有不懂，我们可以尽情交流沟通，
顺序表的简单操作代码（c++实现）
qq_45918426的博客
01-28 1039
#include<iostream> using namespace std; #define ERROR 0 #define OK 1 #define MAXSIZE 100 typedef int Status; typedef int ElemType; typedef struct{ ElemType *elem; int length; }SqList; ...
5-1链队入队出队操作
m0_61630188的博客
05-16 862
链队基本操作。 #include<iostream> using namespace std; #define OK 1 #define ERROR 0 typedef int Status; typedef char QElemType; typedef struct QNode { QElemType data; struct QNode *next; } QNode, *QueuePtr; typedef struct { QueuePtr front;
C++学习笔记12：输入输出流实例整理（文本文件读写，二进制文件读写，一组数据的文件读写，随机访问文件实例
qq_37299596的博客
04-16 329
（这也太难记了555老阔疼 文件读写示例： #include <iostream> #include <string> #include <fstream> using namespace std; int main() { string srsfname("asdfile.txt"); //定义源文件 ifstream srsfile(...
链栈的基本操作C/C++代码实现
Ycy的博客
06-03 4583
链栈的结构： 由于栈的主要操作是在栈顶插入和删除， 显然以链表的头部作为栈顶是最方便的，且不需要附加一个头结点。 初始化： 栈顶指针S置空即可。 入栈： 链栈不需要判断栈是否满！ 出栈： 栈顶指针S等于NULL表空栈，即链栈S==NULL时为空栈。 代码如下： #include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 typedef int SElemType; //链栈的存储结构 typedef struct Sta
链栈实现数制的转换
qq_47142993的博客
08-08 2375
/***链栈实现数制的转换***/ #include<iostream> using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; typedef struct SNode { int data; struct SNode *next; } SNode, *LinkStack; Status InitStack(LinkStack &S) { S = N
数据结构链栈的基本操作的实现
tan-1210的博客
05-10 1817
数据结构中链栈操作的实现
在顺序表中删除指定位置（i=5）上的元素，实现顺序表的删除的基本操作，输出顺序表中所有元素
Zhangguohao666的博客
12-15 8436
题目 在顺序表中删除指定位置（i=5）上的元素，实现顺序表的删除的基本操作，输出顺序表中所有元素 #include&lt;iostream&gt; using namespace std; #define OK 1 #define ERROR 0 #define OVERFLOW -2 typedef int Status; //Status 是函数返回值类型，其值是函数结果状态代码。 type...
数据结构线性表
m0_53438035的博客
04-24 96
又是被数据结构折磨的一天 1：顺序表
实验一 顺序表、单链表基本操作的实现
陈的博客
12-06 2358
实验一 顺序表、单链表基本操作的实现 实验目的 1、顺序表 （1）掌握顺序表的存储结构形式及其描述 （2）掌握顺序表的建立、查找、插入、删除操作 2、链表 （1）掌握单链表的存储结构形式及其描述 （2）掌握单链表的建立、查找、插入和删除操作 实验内容 1、顺序表 编写函数，输入一组整型元素序列，建立一个顺序表。 编写函数，实现对该顺序表的遍历（每个元素被访问一次且仅被访问一次）。 编写函数，在顺序表中顺序查找某一元素，查找成功则返回其存储位置i，否则返回错误信息。 编写函数，实现在顺序表的第i个位置
C51 函数栈的实现 代码
最新发布
06-09
e = 0x05; f = 0x06; LED = 0; // 点亮LED delay(1000); // 延时1秒 LED = 1; // 熄灭LED delay(1000); // 延时1秒 } void delay(unsigned int i) { unsigned int j, k; for(j=0; j; j++) for(k=0; k; k++...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

挖洞的杰瑞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值