精华内容
下载资源
问答
  • 栈与队列--判断栈/队列为空/满

    万次阅读 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;
    }
    展开全文
  • :是一种思想,实现将数据以先进后出(FILO:first in last out)方式操作 一、模型:井口 二、数据类型: //宏: #define MAXSIZE 10 //重命名:将int取一个别名:StackType typedef int StackType; //...

    栈:是一种思想,实现将数据以先进后出(FILO:first in last out)方式操作

    一、模型:井口

    二、数据类型:
            //宏:
            #define MAXSIZE  10
            //重命名:将int取一个别名:StackType
            typedef int StackType;
            //栈的类型:
            struct stack
            {
            //数据:
                    StackType buf[6];       //栈的元素
            //方法
                    short top;              //栈顶下标
            };
      三、功能:
        1、初始化InitStack
        2、清空栈:ClearStack
        3、出栈:pop
        4、进栈:push
        5、判断栈为满:IsFull
        6、判断栈为空:IsEmpty
        7、取次栈顶
        8、栈的元素个数:StackLength

    四、栈的应用:撤消与恢复,记忆,递归,高级功能计算

     

    栈的代码详解、将二进制结果取出,实现代码如下

    #include<stdio.h>
    //宏
    #define MAXSIZE 32
    #define FALSE 0
    #define TRUE 1
    //重命名:将char取一个别名:StackType
    typedef char StackType;
    typedef char BOOL;
    //栈的类型;
    struct st
    {
    //数据
    	StackType buf[MAXSIZE];//栈的元素
    //方法
    	short top;//栈顶下标
    };
    //重命名:
    typedef struct st stack;//将struct stde 类型取别:stack
    
    /*功能:初始化栈
     *函数名:InitStack
     *返回值:void
     */
    void InitStack(stack *p)
    {
    	p->top=-1;
    }
    
    /*功能:判断栈为满
     *函数名:IsFull
     *返回值:为满——真1,非满——假0
     */
    BOOL IsFull(stack *p)
    {
    	if(MAXSIZE-1==p->top)
    	{
    		return TRUE;
    	}else
    	{
    		return FALSE;
    	}
    }
    
    /*功能:判断栈为空
     * 函数名:IsEmpty
     *返回值:为空——真1,非空——假0
     */
    BOOL IsEmpty(stack *p)
    {
    	if(-1==p->top)
    	{
    		return TRUE;
    	}else
    	{
    		return FALSE;
    	}
    }
    /*功能:进栈
     *函数名:push
     *返回值:成功TRUN 失败FALSE
     *注:不能为满,否则进栈失败
     */
    BOOL push(stack *p,StackType data)//p=&s
    {
    //判断栈是否为满
    	if(TRUE==IsFull(p))//为满
    	{
    		return FALSE;//返回失败
    	}
    	p->buf[++p->top]=data;
    	return TRUE;//返回成功
    }
    /*功能:出栈
     *函数名:pop
     *返回值:出栈成功TRUE 失败FALSE
     */
    BOOL pop(stack *p,StackType *pd)
    {
    //判断是否为空,为空出栈无意义
    	if(TRUE==IsEmpty(p))
    	{
    		return FALSE;//出栈失败
    	}
    	*pd=p->buf[p->top--];//优先级->大于--
    	return TRUE;//出栈成功
    }
    void main()
    {
    //定义变量:类型 变量名
    //struct st s;
    	struct st s;//分配空间
    	//初始化
    	InitStack(&s);
    	int num=0;
    	printf("请输入");
    	scanf("%d",&num);
    	//求二进制
    	while(num!=0)
    	{
    	//将余数入栈
    		if(FALSE==push(&s,num%2))
    		{
    			return;//结束
    		}
    		num/=2;
    	}
    	//将二进制结果取出来
    	char value=0;
    	while(FALSE!=pop(&s,&value))
    	{
    		printf("%d",value);
    	}
    	printf("\n");
    }

     

    展开全文
  • 顺序栈,遵循先进后出后进先出原则。我在写的时候,宏定义的 ...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<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;
    		}
    		}
    	}
    }
    

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

    展开全文
  • 假设S=(a1, a2, ….,a3),则称a1为栈底元素,an栈顶元素,中元素按a1,a2,…,an的次序进栈,退的第一个元素应该栈顶元素。换句话说,的修改是按照先进后出的原则进行的,因此,又称为
  • 栈:进栈,出栈,取栈顶元素,判断栈是否为空,置空栈,输出元素个数等 注:用switch进行选择操作。 //栈:进栈,出栈,取栈顶元素,判断栈是否为空,置空栈,输出元素个数等。 #include"stdio.h" #define maxsize 100...
  • 将编号0和1的两个栈存放于一个数组空间V[m]中,栈底分别...试编写双栈初始化,判断栈空、栈满、进栈和出栈等算法的函数。双栈数据结构的定义如下: typedef struct{ int top [ 2],bot [ 2];//栈顶和栈底指针 SE...
  • 顺序的基本操作实现---入栈、出栈、判断是否为空 本身就比较简单,的基本概念推荐文章:http://blog.csdn.net/hguisu/article/details/7674195 实现代码如下: stack.h 的头文件: #pragma once #...
  • 将编号0和1的两个栈存放于一个数组...试编写双栈初始化,判断栈空、栈满、进栈和出栈等算法的函数。 注意 左栈是通常意义的栈,右栈的入栈操作(栈顶指针减1),出栈操作(栈顶指针加1) #include <stdio.h>...
  • 功能:顺序栈函数的使用 栈的数据只能够通过栈顶去操作 顺序栈是通过创建一个管理结构体的方式,去管理一个数组 管理结构体中包含:指向数组首地址的指针*stack_arr, 数组的大小size, 栈顶相对于栈底的偏移量top(起始...
  • 【每日一C之二十一】判断栈增长方向

    千次阅读 多人点赞 2014-04-13 21:43:40
     今日贝壳:一个小程序判断栈增长方向,揭示了函数调用的内幕。  关于函数调用的更多精彩【C解析之五】函数-你不知道的事。  思考?: 如何判断栈增长的方向?函数被调用时,会在栈区构建函数运行环境并分配临时...
  • 的基本函数C++实现

    千次阅读 2018-11-14 21:57:45
    前两天自己照着一些博客仿写了的C++,其间也出了一些问题,但是通过调试,各个基本函数都得到了验证。当然可能存在我不知道的问题,如果有小伙伴验证我代码的时候出现了问题希望可以告知我一下,非常感谢。 代码...
  • 链栈采用链表来存储 //链栈的定义 typedef struct LNode { int data; struct LNode *next; }LNode; 初始化链栈,要制造一个头节点 //初始化一个链栈 void initstack(LNode*&Lst) { Lst=(LNode*)malloc...
  • JAVA顺序栈操作——初始化、入栈、出栈、判断空栈、判断栈满;顺序栈:使用一组连续的内存依次保存栈中的数据,定义一个top变量来保存栈顶序号。栈结构是“后进先出”的原则。
  • 文章目录产出问题所需函数实现代码运行结果理解方法 ...试编写双栈初始化,判断栈空、栈满、进栈 和出栈等算法的函数。双栈数据结构的定义如下; 所需函数 1、初始化双栈 void InitDblStack(DblSt
  • linux协议skb操作函数

    千次阅读 2015-09-08 18:02:58
    一. SKB_BUFF的基本概念 ...(2) header data--独立于sk_buff结构体的数据缓冲区,用来存放报文分组,使各层协议的header存储在连续的空间中,以方便协议对其操作 (3) struct skb_shared_info --作为heade
  • 如何判断栈溢出及解决方式

    千次阅读 2019-11-10 00:37:16
    怎么判断栈溢出,栈溢出是否超过整形范围?怎么处理 判断:1、用一个变量记录栈大小 2、重新设置堆栈指针,指向新的堆栈,并设置堆栈两端页面保护页面,一旦堆栈溢出,就会产生保护异常 解决的方法: 1、...
  • 今天我们来看看在VC++6.0继承环境中,C语言的空函数在反汇编中是怎样的结构,然后来学习C和汇编的混合编程中裸函数与...1、C空函数的反汇编结构分析:以下面的代码例,进行反汇编:#include "stdafx.h" //C空函数 vo
  • 溢出笔记1.1 函数调用过程

    千次阅读 2016-04-09 23:04:35
    区随着函数调用动态变化,每个函数调用时在上占用的空间称为栈帧。用一个示例来说明上保存的内容及动态变化的过程。 下面是一个程序,生成一个对话框显示一条“Hello World!”消息。下面是该程序的C代码: ...
  • 设计两个函数,一个作为调用方(main函数),另一个作为被调用方(fun函数)。被调用方以一个地址(也就是指针)作为自己的入口参数,调用方传入的地址是自己的一个局部变量的地址,然后,被调用方比较这个地址和...
  • 【C语言】演示(的几个函数)

    千次阅读 2017-08-07 20:38:24
    演示(的几个函数)
  • 如何判断栈、堆的增长方向?

    万次阅读 多人点赞 2016-07-06 15:35:12
    如何判断栈的增长方向? 对于一个用惯了i386系列机器的人来说,这似乎是一个无聊的问题,因为栈就是从高地址向低地址增长。不过,显然这不是这个问题的目的,既然把这个问题拿出来,问的就不只是i386系列的机器,跨...
  • 今天写算法时,无意间看到了判断栈是否为空的两个方法,之前一直用isEmpty(),从未用过empty(),却不曾想两者均可判断一个栈是否为空,所以深入源码探究了一番: java.util.Vector: /** * Tests if this vector ...
  • 数据结构之的运用
  • 使用C语言判断栈的方向

    千次阅读 2014-07-29 14:58:41
    避免这种编译器优化的情况,可以采用将变量定义到函数中,然后递归调用该函数。例如下面的代码: #include static int stack_direction = 0; static void FindStackDirection() { static char *addr = NULL...
  • 首先我们需要确定思路,如何用判断字符串是否回文。 1.是先进后出 2.回文是指正读反读均相同的字符序列 从这两点很容易就可以联想到一个方法,我们先将字符串全部存进去中,再将它全部出栈,进行对比,...
  • 如何判断栈的增长方向?

    千次阅读 2008-06-16 09:19:00
    如何判断栈的增长方向?对于一个用惯了i386系列机器的人来说,这似乎是一个无聊的问题,因为栈就是从高地址向低地址增长。不过,显然这不是这个问题的目的,既然把这个问题拿出来,问的就不只是i386系列的机器,跨...
  • C语言利用栈判断字符串是否回文

    万次阅读 多人点赞 2017-11-12 09:31:01
    #include #include #define OK 1 #define ERROR 0 typedef char ElemType; typedef int Status; typedef struct Stack1 { ElemType data; struct Stack1 *next;...//初始化一个 Status Init(SqlSta
  • 本处使用顺序栈判断括号匹配,首先我们知道是一种只能在一段操作的线性表。其插入,删除仅能在一端进行操作,就像一个瓶子一样,不管是取东西还是放东西都只能在瓶口进行,那么最后最先进的元素就一定是最后出栈...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 207,390
精华内容 82,956
关键字:

判断栈为空的函数