scau：数据结构oj 实验二

最新推荐文章于 2024-10-17 20:50:47 发布
最新推荐文章于 2024-10-17 20:50:47 发布
阅读量115 收藏
点赞数 1
文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zero_019/article/details/139729566
版权 
//8583 顺序栈的基本操作
#include<malloc.h>
#include<stdio.h>
#define OK 1
#define ERROR 0
#define STACK_INIT_SIZE 100 // 存储空间初始分配量
#define STACKINCREMENT 10 // 存储空间分配增量

typedef int SElemType; // 定义栈元素类型
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等

struct SqStack
{
SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
SElemType *top; // 栈顶指针
int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈

Status InitStack(SqStack &S)
{
// 构造一个空栈S，该栈预定义大小为STACK_INIT_SIZE
// 请补全代码
   S.base=new SElemType[STACK_INIT_SIZE];
   if(!S.base)
   return ERROR;
   S.top=S.base;
   S.stacksize=STACK_INIT_SIZE;
   return OK;

}

Status Push(SqStack &S,SElemType e)
{
// 在栈S中插入元素e为新的栈顶元素
// 请补全代码
    if(S.top-S.base==S.stacksize)
    return ERROR;
    else
    {
        *S.top=e;
        S.top++;
        return OK;
    }


}

Status Pop(SqStack &S,SElemType &e)
{
// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
// 请补全代码
    if(S.base==S.top)
    return ERROR;
    else 
    {
        S.top--;
    e=*S.top;
    return OK;
    }
}

Status GetTop(SqStack S,SElemType &e)
{
// 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
// 请补全代码
   if(S.base==S.top)
    return ERROR;
    else 
    {
        
    e=*(S.top-1);
    return OK;
    }

}

int StackLength(SqStack S)
{
// 返回栈S的元素个数
// 请补全代码
    return S.top-S.base;
}

Status StackTraverse(SqStack S)
{
// 从栈顶到栈底依次输出栈中的每个元素
SElemType *p = (SElemType *)malloc(sizeof(SElemType));

p = S.top; //请填空
if(StackLength(S)==0)

printf("The Stack is Empty!"); 
else
{
printf("The Stack is: ");

while(p>S.base) //请填空
{
    p--;
printf("%d ", *p);
 //请填空
}
}
printf("\n");
return OK;
}
//8584 循环队列的基本操作
#include <malloc.h>
#include <stdio.h>
#define MAXQSIZE 100
#define OK 1
#define ERROR 0

using namespace std;

typedef int Status;

typedef int QElemType;

//初始化
typedef struct
{
    QElemType *base;
    int front;
    int rear;
}SqQueue;

//创建空队列
Status InitQueue(SqQueue &Q)
{
    Q.base=new QElemType[MAXQSIZE];
    Q.front=Q.rear=0;
    return OK;
}

//入队
Status EnQueue(SqQueue &Q,QElemType e)
{
    if((Q.rear+1)%MAXQSIZE==Q.front) return ERROR;
    Q.base[Q.rear]=e;
    Q.rear=(Q.rear+1)%MAXQSIZE;
    return OK;
}

//出队
Status DeQueue(SqQueue &Q,QElemType &e)
{
    if(Q.rear==Q.front) return ERROR;
    e=Q.base[Q.front];
    Q.front=(Q.front+1)%MAXQSIZE;
    return OK;
}

//取对头元素
Status GetHead(SqQueue &Q,QElemType &e)
{
    if(Q.front==Q.rear) return ERROR;
    e=Q.base[Q.front];
    return OK;
}

//求队列元素个数
Status QueueLength(SqQueue &Q)
{
    return (Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

//遍历输出队列元素
Status QueueTraverse(SqQueue &Q)
{
    int i;
    i=Q.front;
    if(QueueLength(Q)==0) return ERROR;
    else{
        printf("The Queue is: ");
        while(i!=Q.rear)
        {
            printf("%d ",Q.base[i]);
            i=(i+1)%MAXQSIZE;
        }
    }
    printf("\n");
    return OK;
}

int main()
{
	int a;
    SqQueue S;
	QElemType x, e;
    if(InitQueue(S))    // 判断顺序表是否创建成功，请填空
	{
		printf("A Queue Has Created.\n");
	}
	while(1)
	{
	printf("1:Enter \n2:Delete \n3:Get the Front \n4:Return the Length of the Queue\n5:Load the Queue\n0:Exit\nPlease choose:\n");
		scanf("%d",&a);
		switch(a)
		{
			case 1: scanf("%d", &x);
				  if(!EnQueue(S,x)) printf("Enter Error!\n"); // 判断入队是否合法，请填空
				  else printf("The Element %d is Successfully Entered!\n", x);
				  break;
			case 2: if(!DeQueue(S,e)) printf("Delete Error!\n"); // 判断出队是否合法，请填空
				  else printf("The Element %d is Successfully Deleted!\n", e);
				  break;
			case 3: if(!GetHead(S,e))printf("Get Head Error!\n"); // 判断Get Head是否合法，请填空
				  else printf("The Head of the Queue is %d!\n", e);
				  break;
			case 4: printf("The Length of the Queue is %d!\n",QueueLength(S));  //请填空
				  break;
			case 5: QueueTraverse(S); //请填空
				  break;
			case 0: return 1;
		}
	}
}
//8585 栈的应用——进制转换
int main()
{
    SqStack s;
    int n;
    scanf("%d",&n);
    InitStack(s);
    while(n>0)
    {
        Push(s,n%8);
        n/=8;
    }
    StackTraverse(s);
}
//8586 括号匹配检验
#include<stdio.h>
#include<math.h>
#include<stdlib.h> // exit()
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define STACK_INIT_SIZE 10 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量
typedef char SElemType;
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等

struct SqStack
{
 SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
 SElemType *top; // 栈顶指针
 int stacksize; // 当前已分配的存储空间，以元素为单位
 }; // 顺序栈

Status InitStack(SqStack &S)
{
    S.base =(SElemType*)malloc(STACK_INIT_SIZE *sizeof(SElemType));
    if(!S.base ) return FALSE;
    S.top =S.base ;
    S.stacksize =STACK_INIT_SIZE;
    return OK;
}

Status StackEmpty(SqStack S)
{
    if(S.base ==S.top ) return 1;
    else return 0;
 }

Status Push(SqStack &S,SElemType e)
{
    if(S.top -S.base >=S.stacksize  )
    {
        S.base =(SElemType*)realloc(S.base ,(S.stacksize +STACKINCREMENT)*sizeof(SElemType));
        if(!S.base )  return FALSE;
        S.top =S.base +S.stacksize ;
        S.stacksize +=STACKINCREMENT;
    }
    *(S.top )=e;
    S.top ++;
    return OK;


 }
 Status Pop(SqStack &S,SElemType &e)
{
    if(S.base ==S.top )
    return FALSE;
    --S.top ;
    e=*(S.top );
    return OK;

 }
void check()
 {
    // 对于输入的任意一个字符串，检验括号是否配对
   SqStack s;
   SElemType ch[80],*p,e;
   if(InitStack(s)) // 初始化栈成功
   {
    //printf("请输入表达式\n");
     gets(ch);
     p=ch;
     while(*p) // 没到串尾
       switch(*p)
       {
         case '(':
         case '[':Push(s,*p++);
                  break; // 左括号入栈，且p++
         case ')':
         case ']':if(!StackEmpty(s)) // 栈不空
                  {
                   Pop(s,e); // 弹出栈顶元素
                    if(*p==')'&&e!='('||*p==']'&&e!='[')
                                                // 弹出的栈顶元素与*p不配对
                    {
                      printf("isn't matched pairs\n");
                      exit(ERROR);
                    }
                    else
                    {
                        p++;
                        break; // 跳出switch语句
                    }
                  }
                  else // 栈空
                  {
                    printf("lack of left parenthesis\n");
                    exit(ERROR);
                  }
         default: p++;; // 其它字符不处理，指针向后移
       }
        if(StackEmpty(s)) //字符串结束时栈空
            printf("matching\n");
        else
            printf("lack of right parenthesis\n");
   }
 }
int main()
{
    check();
}
//行编辑程序
typedef char SElemType;
#include"cstdlib"
#include"stdio.h"
#include"math.h"
#include"stdlib.h" // exit()
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
typedef int Status; // Status是函数的类型,其值是函数结果状态代码，如OK等
#define STACK_INIT_SIZE 30 // 存储空间初始分配量
#define STACKINCREMENT 2 // 存储空间分配增量

struct SqStack
{
    SElemType *base; // 在栈构造之前和销毁之后，base的值为NULL
    SElemType *top; // 栈顶指针
    int stacksize; // 当前已分配的存储空间，以元素为单位
}; // 顺序栈

Status InitStack(SqStack &S)
{    // 构造一个空栈S
    // 请补全代码
    S.base=(SElemType*)malloc(STACK_INIT_SIZE* sizeof(SElemType));
    if(!S.base)
        return  ERROR;
    S.top=S.base;
    S.stacksize=STACK_INIT_SIZE;
    return OK;

}

Status ClearStack(SqStack &S)
{ // 把S置为空栈
    S.top=S.base;
    return OK;
}

Status DestroyStack(SqStack &S)
{ // 销毁栈S，S不再存在
    free(S.base);
    S.base=NULL;
    S.top=NULL;
    S.stacksize=0;
    return OK;
}

Status Push(SqStack &S,SElemType e)
{
// 在栈S中插入元素e为新的栈顶元素
// 请补全代码
    if(S.top-S.base>=S.stacksize)
    {
        S.base=(SElemType*)malloc((STACK_INIT_SIZE+STACKINCREMENT)*sizeof(SElemType));
        if(!S.base)
            return ERROR;
        S.top=S.base+S.stacksize;
        S.stacksize+=STACKINCREMENT;
    }
    *S.top=e;
    S.top++;
    return OK;

}

Status Pop(SqStack &S,SElemType &e)
{
// 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
// 请补全代码
    if(S.top==S.base)return ERROR;
    e=*(S.top-1);
    S.top--;
    return OK;
}

Status StackTraverse(SqStack S,Status(*visit)(SElemType))
{ // 从栈底到栈顶依次对栈中每个元素调用函数visit()。
    // 一旦visit()失败，则操作失败
    while(S.top>S.base)
        visit(*S.base++);
    printf("\n");
    return OK;
}

Status visit(SElemType c)
{
    printf("%c",c);
    return OK;
}

void LineEdit()
{ // 利用字符栈s，从终端接收一行并送至调用过程的数据区。算法3.2
    //2
    //
    //defne##ine OK 1
    //
    //typp cila@type int element
    SqStack s;
    char ch,c;
    int n,i;
    InitStack(s);
    scanf("%d",&n);
    ch=getchar();//读换行
    for(i=1;i<=n;i++)
    { ch=getchar();
        while(ch!='\n')
        {
            switch(ch)
            {
                case '#':Pop(s,c);
                    break; // 仅当栈非空时退栈
                case '@':ClearStack(s);
                    break; // 重置s为空栈
                default :Push(s,ch); // 有效字符进栈
            }
            ch=getchar(); // 从终端接收下一个字符
        }
        StackTraverse(s,visit); // 将从栈底到栈顶的栈内字符输出
        ClearStack(s); // 重置s为空栈
    }
    DestroyStack(s);
}

int main()
{
    LineEdit();
}

//18938 汉诺塔问题
#include <stdio.h>
int m;
// 将 n 个盘子从 a借助 c 移动到b
void mmove(int n, char a, char b, char c)
{
	if( 1 == n )
	{
		printf("%c->%d->%c\n", a,n,b);
	}
	else
	{
		mmove(n-1, a, c, b);				// 将 n-1 个盘子从 a 借助 b 移到 c 上
		printf("%c->%d->%c\n", a, n,b);		// 将 第 n 个盘子从 a 移到 b 上
		mmove(n-1, c, b,a);				// 将 n-1 个盘子从 c借助 a 移到 b 上
	}
}

int main()
{
	int n;
	char a,b,c;
	scanf("%d %c %c %c", &n,&a,&b,&c);
	mmove(n, a, b, c);

	return 0;
}
//18937 阿克曼(Ackmann)函数
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
 
int akm(int m, int n)
{
	if (m > 0 && n > 0)
	{
		return akm(m - 1, akm(m, n - 1));
	}
	else if (m > 0 && n == 0)
	{
		return akm(m - 1, 1);
	}
	else if (m == 0)
	{
		return n + 1;
	}
 
}
 
int main()
{
	int m, n;
	scanf("%d %d", &m, &n);
	printf("%d", akm(m, n));
	return 0;
}

zero_019
关注
SCAU程序设计在线实训平台_实验_高级语言程序设计_实验12 文件操作_堂上练习
YelloooBlue's Blog
12-29 2792
1107 文本文件操作_单词的排序 Description 在当前目录有文件“case1.in”，文件里存放有多个（总个数不超过10000个）英文单词（每个英文单词不会超过10个字文字符）， 每行一个，单词未排序。现要求，将文件中的所有单词按字典顺序排序，然后将排序好的单词写入新建的文件answer.txt中（注：文件存放于当前目录）。 请完成程序，实现该功能，（注意，填空题，请不要使用return 0结束，否则会影响评判而判错）（如case1.in文件中原内容如下） hello bye yes （程序执
scau：数据结构oj 实验一
zero_019的博客
03-13 1832
时间限制:1000MS 代码长度限制:10KB提交次数:9027 通过次数:2456题型: 编程题 语言: G++;GCC。
scau：数据结构oj 实验六
zero_019的博客
06-17 149
【代码】scau：数据结构oj 实验六。
scau：数据结构oj 实验五
zero_019的博客
06-17 129
【代码】scau：数据结构oj 实验五。
scau：数据结构oj 实验四
zero_019的博客
06-17 112
【代码】scau：数据结构oj 实验四。
scau：数据结构oj 实验三
zero_019的博客
06-17 156
【代码】scau：数据结构oj 实验三。
scau：数据结构oj 实验七
zero_019的博客
06-17 138
【代码】scau：数据结构oj 实验七。
SCAU 数据结构 实验6：排序
2301_79586308的博客
06-03 310
SCAU 数据结构 排序算法
SCAU 数据结构 实验四 树
hzl12138666的博客
06-05 1120
构造二叉链表表示的二叉树：按先序次序输入二叉树中结点的值（一个字符），'#'字符表示空树，构造二叉链表表示的二叉树T；再输出三种遍历序列。本题只给出部分代码,请补全内容。输入格式第一行：输入一棵二叉树的先序遍历序列输出格式第一行：二叉树的先序遍历序列第二行：二叉树的中序遍历序列第三行：二叉树的后序遍历序列输入样例AB##C##输出样例ABCBACBCA。
SCAU OJ 数据结构 综合性实验
06-11
2. **高级数据结构**：掌握如何设计和实现高级数据结构，如使用二分查找优化查找时间，或使用平衡树保证插入和删除的性能。 3. **算法与数据结构结合**：将特定算法（如排序、搜索）与数据结构相结合，解决实际问题...
scau归并排序 SCAU数据结构年期末复习
07-05
SCAU数据结构年期末复习 本资源摘要信息涵盖了SCAU数据结构年期末复习的主要知识点，包括数据结构的概念、时间复杂度、算法设计、表的顺序存储结构、链式存储结构、栈的实现、队列的实现等。 数据结构的概念： * ...
"SCAU: 深入了解STL中的数据结构与例题
SCAU（South China Agricultural University）的STL数据结构介绍了STL的基本内容以及一些例题。STL在C++程序中具有非常重要的作用，它提供了丰富的数据结构和算法，可以大大简化程序员的工作，提高代码的可读性和可...
scau 数据结构实验一 8578 顺序表逆置
qq_61974198的博客
03-18 452
Description 顺序表的基本操作代码如下： #include<stdio.h> #include<malloc.h> #define OK 1 #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREMENT 10 #define ElemType int typedef int Status; typedef struct { int *elem; int length; int
【数据结构】宜宾大学-计院-实验三
2303_80737493的博客
10-17 770
线性表的应用——实现两多项式的相加 课前准备： 实验学时：2 实验目的： 实验内容： 实验结果： 实验报告:（及时撰写实验报告） 实验测试结果： 代码实现：（C/C++）【含注释】
《数据结构》学习系列——树（中）
Kenjuan的博客
10-17 1184
通过遍历二叉树可得到一个结点的一个线性序列，在线性序列中，除第一个结点外, 每个结点有且仅有一个前驱，除最后一个结点外，每个结点有且仅有一个后继，但是在二叉树中只能找到结点的左孩子、右孩子，结点在线性序列中的前驱和后继只有在遍历过程中才能得到为了与结点在二叉树中所具有的前驱(即父结点)和后继(即子结点)区别开来，通常把某种序列中结点的前驱或后继冠以某种遍历的名称，如把中根序列中结点的前驱称作中根前驱，结点的后继称作中根后继设 T是由增加某种遍历顺序的线索域的结点所构成的一棵二叉树，在 T。
数据结构 —— 链式二叉树（C语言讲解）
最新发布
知其然 知其所以然
10-17 1100
本篇文章主要讲解链式存储的二叉树，如果读者不清楚二叉树的基础知识，推荐阅读数据结构——树和二叉树简介。对于二叉树这种数据结构的学习，重点不是增删改查，而是学习这种结构，所以，主要讲解一些链式二叉树的操作。
结构体通讲——数据结构解惑
weixin_73236117的博客
10-17 475
结构：一个变量里包含很多变量。
优先级队列和PriorityQueue
2301_79985750的博客
10-17 724
优先级队列是一种特殊的队列，每个元素都有一个优先级或者权重，与普通队列的先进先出不同，它按照优先级的大小从高到低进行排序，优先级最高的优先出队列。在任务调度，事件模拟中发挥着重要的作用。Java中的优先级队列是一种利用堆这种数据结构进行实现，按照数据的优先级顺序进行排序，可以任意的顺序插入，但是取出时按照规定好的优先级进行操作。
数据结构-回溯笔记
2302_80490510的博客
10-17 849
1 递归函数的返回值以及参数2 回溯函数终止条件3 单层搜索的过程。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zero_019

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

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

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

打赏作者

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

抵扣说明：

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

余额充值