精华内容
下载资源
问答
  • 试编写双栈初始化,判断栈空、栈、进栈出栈等算法的函数。 #include<iostream> using namespace std; typedef struct { int top[2], bot[2]; int *V; int m; }DblStack; void ShowM

    将编号为0和1的两个栈存放于一个数组空间V[m]中,栈底分别处于数组的两端。当第0号栈的栈顶指针top[0]等于-1时该栈为空;当第1号栈的栈顶指针top[1]等于m时,该栈为空。两个栈均从两端向中间增长。试编写双栈初始化,判断栈空、栈满、进栈和出栈等算法的函数。

    在这里插入图片描述

    #include<iostream>
    using namespace std;
    typedef struct {
    	int top[2], bot[2];
    	int *V;
    	int m;
    }DblStack;
    void ShowMenu() {
    	cout << "************下面我们开始设计双栈************" << endl;
    	cout << "****************0.双栈初始化****************" << endl;
    	cout << "****************1.插入数据******************" << endl;
    	cout << "****************2.删除数据******************" << endl;
    	cout << "****************3.打印数据******************" << endl;
    	cout << "****************本实验仅进行一次************" << endl;
    }
    //初始化一个大小为m的双向栈
    void InitDblStack(DblStack &S) {
    	cout << "请输入双栈的大小" << endl;
    	cin >> S.m;
    	//动态分配一个最大容量为m的数组空间
    	S.V = new int[S.m];
    	//左栈栈底指针
    	S.bot[0] = -1;
    	//右栈栈底指针
    	S.bot[1] = S.m;
    	//左栈栈顶指针
    	S.top[0] = -1;
    	//右栈栈顶指针
    	S.top[1] = S.m;
    	system("pause");
    	system("cls");
    }
    //向指定的i号栈中插入元素
    void DblPush(DblStack &S) {
    	int i = 0;
    	int j = 0;
    	int flag=0;
    	int *x = new int();
    	cout << "请输入您要插入数据的栈号" << endl;
    	cin >> i;
    	//判断栈号是否输入错误
    	if (i < 0 || i>1) 
    		cout << "栈号输入错误" << endl;
    	//向0栈插入数据,反之向1栈插入数据
    	if (i == 0) {
    		cout << "您要在此栈插入数据的个数" << endl;
    		cin >> j;
    		for (int t = 0;t < j;t++) {
    			cout << "插入第" << (t + 1) << "个数" << endl;
    			cin >> *x;
    			//判断栈是否已满
    			if (S.top[0] + 1 == S.top[1]) {
    				cout << "双栈已满,无法再继续添加数据" << endl;
    				flag=1;
    				}
    			else
    				S.V[++S.top[0]] = *x;
    			if(flag==1break;
    		}
    	}
    	else {
    		cout << "您要在此栈插入数据的个数" << endl;
    		cin >> j;
    		for (int t = 0;t < j;t++) {
    			cout << "插入第" << (t + 1) << "个数" << endl;
    			cin >> *x;
    			if (S.top[0] + 1 == S.top[1]){
    				cout <<"双栈已满,无法插入该数据" << endl;
    				flag=1;
    				}
    			else
    				S.V[--S.top[1]] = *x;
    			if(flag==1)	
    			    break;
    		}
    	}
    	delete x;
    	system("pause");
    	system("cls");
    }
    
    //删除指定的i号栈的栈顶元素,用x返回其值
    void DblPop(DblStack &S){
    	int i,j;
    	cout << "您需要删除哪号栈的栈顶元" << endl;
    	cin >> i;
    	cout << "您需要删除几个数" << endl;
    	cin >> j;
    	for (int t = 0;t < j;t++) {
    		if (S.top[i] == S.bot[i])
    			{
    			    cout << "该栈已为空栈" << endl;
    			    break;
    			    }
    		if (i == 0)
    			S.V[S.top[0]--];
    		else
    			S.V[S.top[1]++];
    	}
    	system("pause");
    	system("cls");
    }
    void PrintDblStack(DblStack &S) {
    	if (S.top[0] == S.bot[0])
    		cout << "第0栈为空栈。无法打印" << endl;
    	else {
    		cout << "第0栈的数据" << endl;
    		for (int i = 0; i < S.top[0] - S.bot[0];i++)
    		{
    			cout << S.V[i];
    			cout << " \t";
    		}
    		cout << endl;
    	}
    	if (S.top[1] == S.bot[1])
    		cout << "第1栈为空栈。无法打印" << endl;
    	
    	else {
    		cout << "第1栈的数据" << endl;
    		for (int i = S.m;i > S.top[1];i--)
    		{
    			cout << S.V[i - 1];
    			cout << "\t";
    		}
    		cout << endl;
    	}
    	//本实验打印后就退出
    		system("pause");
    		exit(0);
    }
    int main() {
    	DblStack S;
    	int i;
    	while (1) {
    		ShowMenu();
    		cout << "请选择你的操作" << endl;
    		cin >> i;
    		switch(i)
    		{
    			case 0:{
    				//初始化双向栈
    				InitDblStack(S);
    				break;
    				}
    			case 1:{
    				//给栈添加数据
    				DblPush(S);
    				break;
    				}
    			case 2:{
    				//删除栈中数据
    				DblPop(S);
    				break;
    				}
    			case 3:{
    				//打印数据
    				PrintDblStack(S);
    				break;
    				}
    			default:
    				break;
    		}
    		}
    	}
    }
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    本代码仅是为了完成数据结构的作业,所以还不完善,见谅。
    。。。。。。。。
    其实是敲不动了
    。。。。。。。。

    展开全文
  • 与队列--判断栈/队列为/

    万次阅读 2016-06-28 10:24:15
    完成int IsEmpty(Stack S)函数,该函数判断栈是否已,如果返回1,否则返回0。 完成int IsFull(Stack S)函数,该函数判断栈是否已,如果返回1,否则返回0。typedef int ElemType; struct StackRecord; ...

    数组栈
    完成int IsEmpty(Stack S)函数,该函数判断栈是否已空,如果空返回1,否则返回0。
    完成int IsFull(Stack S)函数,该函数判断栈是否已满,如果满返回1,否则返回0。

    typedef int ElemType;
    struct StackRecord;
    typedef struct StackRecord *Stack;
    struct StackRecord
    {
        int Capacity; //栈容量
        int Top; //栈顶,初始为1
        ElemType *Array;
    };
    
    int IsEmpty(Stack S)
    {
        if(S‐>Top==‐1)
        {
            return 1;
        } 
        else
        {
            return 0;
        }
    }
    int IsFull(Stack S)
    {
        if(S‐>Top==S‐>Capacity‐1)
        {
            return 1;
        } 
        else
        {
            return 0;
        }
    }

    链栈
    完成int IsEmpty(Stack S);函数,该函数判断栈S是否为空,空栈返回1,否则返回0,已知S是带头结点的链栈。

    typedef int ElemType;
    struct Node;
    typedef struct Node * PtrToNode;
    typedef PtrToNode Stack;
    struct Node
    {
        ElemType data;
        PtrToNode next;
    };
    
    int IsEmpty(Stack S)
    {
        return S‐>next==NULL?1:0;
    }

    数组队列
    完成int IsEmpty(Queue Q);函数,该函数判断队列Q是否已空,如果已空返回1,否则返回0,其中Q是基于数组的非循环队列。
    完成int IsFull(Queue Q)函数,该函数判断队列Q是否已满,如果已满返回1,否则返回0,其中Q是基于数组的非循环队列。

    typedef int ElemType;
    struct QueueRecord;
    typedef struct QueueRecord * Queue;
    struct QueueRecord
    {
        int Capacity; //队列总容量
        int Front; //队首 初始值为0
        int Rear; //队尾,初始值为1
        int Size; //队列中数据数,初始值为0
        ElemType *Array;
    };
    
    int IsEmpty(Queue Q)
    {
        return Q‐>Size==0;
    }
    int IsFull(Queue Q)
    {
        return Q‐>Rear==Q‐>Capacity‐1?1:0;
    }

    链队列
    完成int IsEmpty(Queue q)函数,该函数判定基于链表的队列q是否为空,空队列返回1,非空队列返回0,其中q是不带头节点的链表队列。

    typedef int ElemType;
    struct node;
    typedef struct node Node;
    struct queue;
    typedef struct queue * Queue;
    struct node
    {
        ElemType data;
        Node * next;
    };
    struct queue
    {
        Node * front; //队首
        Node * rear; //队尾
        int size; //队列中数据数int IsEmpty(Queue q)
    {
        return q‐>size==0?1:0;
    }
    展开全文
  • 为当栈满时,再想入栈的话每次大小的增量,这里用10来代替。 create函数为创建函数。push为入栈函数。empty函数用来判断 是否为,print函数用来出栈。 //以下为全部代码 #include "stdio.h" #include "mall....

    顺序栈,遵循先进后出后进先出原则。我在写的时候,宏定义的
    firstsize 为创建一个栈时这个栈的初始大小,这里为100。addsize
    为当栈满时,再想入栈的话每次栈大小的增量,这里用10来代替。
    create函数为创建栈函数。push为入栈函数。empty函数用来判断
    栈是否为空,print函数用来出栈。
    //以下为全部代码

    #include "stdio.h"
    #include "malloc.h"
    #define firstsize 100
    #define addsize 10
    typedef struct{
     int *base;
     int *top;
     int size;
    }Sq;
    
    void create(Sq &s)
    {
     s.base=(int*)malloc(firstsize*sizeof(int));
     if(s.base)printf("create OK!\n");
     s.top=s.base;
     s.size=firstsize;
    }
    
    void push(Sq &s,int e)
    {
     if(s.top-s.base>=s.size)
     {
     s.base=(int*)realloc(s.base,(s.size+addsize)*sizeof(int));
     printf("栈内空间分配成功\n");
     }
     *s.top=e;
     s.top++;
     printf("元素[%d]已入栈!\n",e);
    }
    
    void print(Sq &s)
    {
     if(empty(s))printf("抱歉,栈已满,无法出栈\n");
     else
     {
       s.top--;
       printf("出栈:[%d]\n",*s.top);
      }
    }
    
    int empty(Sq &s)
    {
     if(s.top==s.base||s.top<s.base)
     { printf("栈空\n");
     return 1;}
     else {printf("栈未空\n");
     return 0;}
    }
    
    void main()
    {
    int i; Sq s;
    do
    {
    printf("\n----------------\n1-");
    printf("创建一个栈\n2-判断栈是否为空\n3-入栈\n4-出栈\n0-退出");
    printf("\n----------------\n\n");
    scanf("%d",&i);
    switch(i)
    {
     case 1:create(s);break;
     case 2:empty(s);break;
     case 3:
     {
     int e;
     printf("输入入栈元素:\n");
     scanf("%d",&e);
     push(s,e);
     }break;
     case 4:print(s);break;
     case 0:break;
     default:
     {printf("输入错误,请重新输入\n");
     }continue;
     }
     }while(i!=0);
     printf("程序已退出\n");
    }
    
    
    

    运行结果:sxz

    展开全文
  • 栈的顺序存储的初始化、判断栈空、入栈、出栈、读取栈顶元素、栈置空、求栈长操作 代码如下: //栈的顺序存储表示 #include #include #include #define MAXSIZE 100 typedef int ElemType; typedef struct Node...

    栈的顺序存储的初始化、判断栈空、入栈、出栈、读取栈顶元素、栈置空、求栈长操作

    代码如下:

    //栈的顺序存储表示 
    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    #define MAXSIZE 100 
    typedef int ElemType; 
    typedef struct Node{    //定义栈 
    	ElemType data[MAXSIZE];
    	int top;
    }SeqStack; 
    void *Init_Stack(SeqStack *&s)  //栈的初始化 
    {
    	s=(SeqStack*)malloc(sizeof(SeqStack));  //方法一 
    //	s=new SeqStack;                           方法二  
    	s->top=-1;
    } 
    int Stack_Empty(SeqStack *s)  //当栈空时返回1,否则返回0 									
    {
    	if(s->top==-1)
    	return 1;
    	else 
    	return 0;
     } 
    
    void Push_Stack(SeqStack *s,ElemType x) //入栈操作,当栈未满的时候入栈 
    {
    	if(s->top==MAXSIZE-1)
    	printf("Stack full\n");
    	else
    	{
    		s->top++;
    		s->data[s->top]=x;
    	}
    }
    void GetTop_Stack(SeqStack *s)  //读取栈顶元素操作
    { 
    	ElemType x;
    	if(Stack_Empty(s))
    	{
    		printf("Stack empty.\n");
    	 } 
    	else
    	{
    		x=s->data[s->top];
    		printf("%d\n",x);
    	}
    }
    ElemType Pop_Stack(SeqStack *s)   //出栈操作,若栈不为空则删除栈顶元素 
    {
    	ElemType x;
    	if(Stack_Empty(s))         //判断栈是否为空 
    	{
    		printf("Stack Empty\n");
    		return NULL; 
    	}
    	else
    	{
    		x=s->data[s->top];
    		s->top--;
    		return x;
    	}
    }
    void Clear_Stack(SeqStack *s)  //栈置空操作 
    {
    	s->top=-1;
    }
    void Stack_Length(SeqStack *s)
    {
    	printf("stack length is %d\n",s->top+1);
    }
    int main()
    {
    	SeqStack *s;
    	Init_Stack(s);
    	Push_Stack(s,1);
    	Push_Stack(s,2);
    	Push_Stack(s,3);
    	GetTop_Stack(s);
    	Pop_Stack(s);
    	GetTop_Stack(s); 
    	Stack_Length(s);
    	Clear_Stack(s);
    	Stack_Length(s);
    	return 0; 
    }

    展开全文
  • 不含元素的表称为空栈。 假设S=(a1, a2, ….,a3),则称a1为底元素,an为栈顶元素,中元素按a1,a2,…,an的次序进栈,退的第一个元素应该为栈顶元素。换句话说,的修改是按照先进后出的原则进行的,...
  • 链栈采用链表来存储 //链栈的定义 typedef struct LNode { int data; struct LNode *next; }LNode; 初始化链栈,要制造一个头节点 //初始化一个链栈 void initstack(LNode*&Lst) { Lst=(LNode*)malloc...
  • JAVA顺序操作——初始化、入栈、出栈、判断空栈、判断栈满;顺序:使用一组连续的内存依次保存中的数据,定义一个top变量来保存栈顶序号。结构是“后进先出”的原则。
  • 顺序栈的函数源码 #include <stdio.h> #include <stdbool.h> #include <stdlib.h>...顺序栈是通过创建一个管理结构体的...在顺序栈中:我们主要讨论顺序栈的 初始化,栈空,栈,入栈,出栈,遍历
  • :是一种思想,实现将数据以先进后出(FILO:first in last out)方式操作 一、模型:井口 二、数据类型: //宏: #define MAXSIZE 10 //重命名:将int取一个别名:StackType typedef int StackType; //...
  • /* 判断栈是否为 */ int IsEmpty(LinkStack top) { if(top->next == NULL) return TRUE; return FALSE; } /* 元素入栈 */ int Push(LinkStack top, ElementType element) { LinkStack temp; temp = ...
  • 目录 一、栈的逻辑结构 ...3.判断栈空和 4.压栈 5.弹栈 6.取栈顶元素 7.顺序栈进行数制转换,实现10进制转8进制 三、链栈 1.链栈数据结构定义 2.初始化 3.判断栈空 4.压栈 5.弹栈 6...
  • 数据结构——共享栈满条件判断

    千次阅读 多人点赞 2020-09-08 09:42:04
    共享栈判断的条件,即判断两个栈顶的位置的状态,其根本是由两个栈顶指针的操作方式决定的。 用入栈操作来说有以下两种操作方式:(1)栈顶指针先加1,再赋值,那么栈顶指针所指的地方是最后入栈的元素(2)若先...
  • *栈空判断 *入栈 *出栈 *取栈顶元素 */ #include<stdio.h> #include<stdlib.h> typedef int element; typedef struct link_stack { element data; struct link_stack *next; }Link_Stack; ...
  • 顺序比较简单。本程序只是插入一个数据之后直接删除该数据。不够完善请原谅。 seqstack.h文件。 #include #include #define MAXSIZE 50 #define False 0; #define True 1; typedef struct{...
  • //判断栈空 int empty(Stack* ps); //入栈操作 void push(Stack* ps, int data); //出栈操作 int pop(Stack* ps); int main(void) { return 0; } //判断 int ...
  • 判断队列或者的方式

    千次阅读 2019-07-28 14:58:18
    s.empty():empty()是说这个吗,为返回true,不为返回false,所以有时候在循环的时候,是while(!s.empty()),这样的,意识是如果s不为,同理队列q不为的意思也是这样的。while(!q.empty()) s.size(),...
  • 数据结构——共享算法的栈满问题

    千次阅读 多人点赞 2018-07-15 03:13:21
    一、共享的优点 ...判断栈满的条件,就是判断两个栈顶的位置的状态,其根本原因是由两个栈顶指针的操作方式决定的。 用入栈操作来说:①栈顶指针先加1,再赋值,那么栈顶指针所指的地方,则最...
  • :进栈,出栈,取栈顶元素,判断栈是否为,置空栈,输出元素个数等 注:用switch进行选择操作。 //:进栈,出栈,取栈顶元素,判断栈是否为,置空栈,输出元素个数等。 #include"stdio.h" #define maxsize 100...
  • 栈空:top==-1 栈:top==maxsize-1 链栈 栈空:s->next==NULL 栈:不存在 环形队列 队空:p->front==p->rear 队:(p->rear+1)%maxsize==p->front 链队 队空:q->rear==NULL 队:不存在
  • 和栈的精华大总结

    万次阅读 多人点赞 2019-11-18 18:37:41
    、堆、常量池虽同属Java内存分配时操作的区域,但其适用范围功用却大不相同。 一般Java在内存分配时会涉及到以下区域: ◆寄存器:我们在程序中无法控制 ◆:存放基本类型的数据对象的引用,但对象本身不...
  • 判断栈的出栈顺序是否正确

    千次阅读 2016-10-28 21:51:56
    判断栈的出栈顺序是否正确
  • 将编号为01的两个栈存放于一个数组空间V[m]中,栈底分别...试编写双栈初始化,判断栈空、栈、进栈出栈等算法的函数。双栈数据结构的定义如下: typedef struct{ int top [ 2],bot [ 2];//栈顶栈底指针 SE...
  • 栈和队列判断回文数

    千次阅读 2017-10-21 13:15:54
    #include <stdio.h> #include<malloc.h>... #define SMaxSize 20//顺序初始分配单元个数 typedef struct // 顺序结构定义 { elemtype *list; int top; }SeqStack; typedef...
  • 对于的概念、图示以及顺序的实现我在上一篇博客进行了讲解代码共享。如果大家需要看顺序的综合操作可以看我的上一篇博客。 http://blog.csdn.net/zxnsirius/article/details/51206766 这里主要给大家讲...
  • 就是当栈空时的处理,因为栈空你没有数据可以返回,但是此方法的是有返回值的所以if里即使判断栈空也需要返回数据。 1、程序简单要求不高的时候用System.exit(1);就可以来解决此问题。public int pop() { if ...
  • 【每日一C之二十一】判断栈增长方向

    千次阅读 多人点赞 2014-04-13 21:43:40
    每日一C之判断栈增长方向  每天拾一个C语言贝壳,厚积薄发,积跬步以致千里。  今日贝壳:一个小程序判断栈增长方向,揭示了函数调用的内幕。...函数被调用时,会在区构建函数运行环境并分配临时变量存储

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 357,402
精华内容 142,960
关键字:

如何判断栈空和栈满