精华内容
下载资源
问答
  • 数据结构 主讲人章万静 否 是 开始 结束 top==MAX-1 栈顶元素下标top 顺序栈最大空间MAX 定义变量 栈已满 栈没满 顺序栈判断栈满 顺序栈判断栈满 顺序栈判断栈满很重要在进栈操作之前必须要进行判断 顺序栈判断栈满...
  • 数据结构 主讲人章万静 目录 栈实验-判断栈满操作 算法分析 Part 01 一算法分析 栈在什么情况下是满栈 top指向最后一个进栈数据时就是满栈即top是否等于STACKSIZE-1 #define STACKSIZE 6 //顺序栈有6个空间 int top=...
  • 数据结构 主讲人章万静 顺序栈判断栈满 32 2 41 位置1 位置2 位置3 位置4 位置5 位置6 s[0] s[1] s[2] s[3] s[4] s[5] 栈底 判断顺序栈是否已满需要考虑top与栈最大空间之间的关系 如图顺序栈最大有6个空间可以存放6...
  • JAVA顺序栈操作——初始化、入栈、出栈、判断空栈、判断栈满;顺序栈:使用一组连续的内存依次保存栈中的数据,定义一个top变量来保存栈顶序号。栈结构是“后进先出”的原则。

    顺序栈:使用一组连续的内存依次保存栈中的数据,定义一个top变量来保存栈顶序号。

    栈结构是“后进先出”的原则。

    栈的最基本操作有两个:push(入栈) + pop(出栈)


    import java.util.Scanner;
    
    /** 
    *  @author   LilyLee
     * @date     2017年4月25日
     * @time     下午4:25:15
     * @Version  1.0
     * @email    lilylee_1213@foxmail.com
     *
     */
    public class Mystack {
    
    	public static void main(String[] args) {
    		Stack_type st=new Stack_type();
    		Stack_Data data1=new Stack_Data();
    		Stack_type stack =st.STinit(); //初始化栈
    		Scanner sc=new Scanner(System.in);
    		System.out.println("input  name age end with name='0'"); //输入栈元素,以0结束
    		while(true){
    			Stack_Data sdata=new Stack_Data();
    			sdata.name=sc.next();
    			if(sdata.name.equals("0")){break;}
    			sdata.age=sc.nextInt();
    			st.PushST(stack, sdata);
    		}
    		String flag="1";
    		System.out.println("pop stack  end with 0");//输入任意非0元素完成弹栈
    		flag=sc.next();
    		while(!(flag.equals("0"))){
    			data1=st.PopST(stack);
    			if(data1==null){break;}
    			System.out.println(data1.name+" "+data1.age);
    			flag=sc.next();
    		}
    		System.out.println("End and Free");
    		st.STFree(st);
    		
    	}
    }
    
    class Stack_Data{
    	String name;
    	int age;
    }
    
    class Stack_type{
    	static final int MAXLEN=50; //定义栈的最大长度
    	Stack_Data[] data=new Stack_Data[MAXLEN+1];
    	int top;
    	
    	Stack_type STinit(){
    		Stack_type p;
    		
    		if((p=new Stack_type())!=null){  //申请栈内存
    			p.top=0;
    			return p;
    			}
    		return null;
    		
    	}
    	
    	boolean STIsEmpty(Stack_type s){  //判断栈是否为空
    		boolean t;
    		t=(s.top==0);
    		return t;
    	}
    	
    	boolean STIsFull(Stack_type s){  //判断栈是否已满
    		boolean t;
    		t=(s.top==MAXLEN);
    		return t;
    	}
    	
    	void STClear(Stack_type s){  //清空栈
    		s.top=0;
    	}
    	
    	void STFree(Stack_type s){ //释放栈所占用空间
    		if(s!=null){
    			s=null;
    		}
    	}
    	
    	int PushST(Stack_type s,Stack_Data data){
    		if((s.top+1)>MAXLEN){return 0;}  //栈溢出
    		s.data[++s.top]=data;
    		return 1;
    	}
    	
    	Stack_Data PopST(Stack_type s){
    		if(s.top==0){System.out.println("no elements!"); return null;} //栈为空,操作失败
    		return (s.data[s.top--]);
    	}
    	
    	Stack_Data PeekST(Stack_type s){
    		if(s.top==0){System.exit(0);}  //栈为空,操作失败
    		return (s.data[s.top]);
    	}
    	
    	
    }
    


    展开全文
  • 数据结构——共享栈的栈满条件判断

    千次阅读 多人点赞 2020-09-08 09:42:04
    共享栈判断栈满的条件,即判断两个栈顶的位置的状态,其根本是由两个栈顶指针的操作方式决定的。 用入栈操作来说有以下两种操作方式:(1)栈顶指针先加1,再赋值,那么栈顶指针所指的地方是最后入栈的元素(2)若先...

    共享栈判断栈满的条件,即判断两个栈顶的位置的状态,其根本是由两个栈顶指针的操作方式决定的。
    用入栈操作来说有以下两种操作方式:(1)栈顶指针先加1,再赋值,那么栈顶指针所指的地方是最后入栈的元素(2)若先赋值,栈顶指针再加1,则指针指向的位置是在最后入栈元素的后面1位,指向的地方为空值

    由此导致下面可能发生的四种情况:
    (1)初始值:top0=-1,top1=maxsize ,栈顶指针先加1(top1为减一),再赋值
    图一
    (2)初始值:top0=-1,top1=maxsize-1,top0先加1再赋值,top1先赋值,再减1
    图二
    (3)初始值:top0=0,top1=maxsize,top0先赋值再加1,top1先减1再赋值
    图三
    (4)初始值:top0=0,top1=maxsize-1,栈顶指针先赋值再加1(top1为减一)
    图四

    展开全文
  • 双栈的建立、判断栈空、栈满、插入和删除操作
  • 试编写双栈初始化,判断栈空、栈满、进栈和出栈等算法的函数。 #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;
    		}
    		}
    	}
    }
    

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

    展开全文
  • 数据结构——共享栈算法的栈满问题

    千次阅读 多人点赞 2018-07-15 03:13:21
    一、共享栈的优点 ...判断栈满的条件,就是判断两个栈顶的位置的状态,其根本原因是由两个栈顶指针的操作方式决定的。 用入栈操作来说:①栈顶指针先加1,再赋值,那么栈顶指针所指的地方,则最...

    一、共享栈的优点

    共享栈是为了有效的利用存储空间,两个栈的空间可以相互调节

    二、共享栈的概念

    因为栈底位置不变,所以让两个顺序栈共享一个数组空间,两个栈的栈底分别设置在两端,两个栈顶向数组中间延伸。

     

    三、共享栈栈满问题

    判断栈满的条件,就是判断两个栈顶的位置的状态,其根本原因是由两个栈顶指针的操作方式决定的

    用入栈操作来说:①栈顶指针先加1,再赋值,那么栈顶指针所指的地方,则最后入栈的元素

                               ②若先赋值,栈顶指针再加1,则指针指向的位置则在最后入栈元素的后面1位,指向的地方也为空值。

     

    下面为会发生的四种情况:

    ①初始值:top0=-1,top1=10 ,栈底指针都是先加1,再赋值

     

    ②初始值:top0=-1,top1=9 ,top0:先加1,再赋值,           top1:先赋值,再加1

     

    ③初始值:top0=0,top1=10 ,top0:先赋值,再加1              top1:先加1,再赋值

     

     

    ④初始值:top0=0,top1=9 ,栈顶指针都是:先赋值,再加1

     

    此时还有两个剩余空间

     

     

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

    万次阅读 2016-06-28 10:24:15
    数组栈 ...完成int IsFull(Stack S)函数,该函数判断栈是否已,如果返回1,否则返回0。typedef int ElemType; struct StackRecord; typedef struct StackRecord *Stack; struct StackRecord {
  • :是一种思想,实现将数据以先进后出(FILO:first in last out)方式操作 一、模型:井口 二、数据类型: //宏: #define MAXSIZE 10 //重命名:将int取一个别名:StackType typedef int StackType; //...
  • 为当栈满时,再想入栈的话每次栈大小的增量,这里用10来代替。 create函数为创建栈函数。push为入栈函数。empty函数用来判断 栈是否为空,print函数用来出栈。 //以下为全部代码 #include "stdio.h" #include "mall....
  • 如何判断栈溢出及解决方式

    千次阅读 2019-11-10 00:37:16
    怎么判断栈溢出,栈溢出是否超过整形范围?怎么处理 判断:1、用一个变量记录栈大小 2、重新设置堆栈指针,指向新的堆栈,并设置堆栈两端页面为保护页面,一旦堆栈溢出,就会产生保护异常 解决的方法: 1、...
  • 判断顺序是否为空 top指针和base指针相等 给我们一个S,判断是否为空,不为空,则返回false 求顺序的长度:里头有多少个元素,给我一个顺序S,求两个指针的差 清空顺序:不管里面...
  • (stack)是限定仅在表尾进行插入或删除操作的线性表。因此,对来说,表尾端有其特殊含义,称为栈顶(top),相应的,表头端称为底(bottom)。不含元素的空表称为空栈。 假设S=(a1, a2, ….,a3),则称...
  • 顺序栈的函数源码 #include <stdio.h> #include <stdbool.h> #include <stdlib.h>...顺序栈是通过创建一个管理结构体的...在顺序栈中:我们主要讨论顺序栈的 初始化,栈空,栈满,入栈,出栈,遍历
  • 栈的顺序存储的初始化、判断栈空、入栈、出栈、读取栈顶元素、栈置空、求栈长操作 代码如下: //栈的顺序存储表示 #include #include #include #define MAXSIZE 100 typedef int ElemType; typedef struct Node...
  • 试题名称 判断栈输出顺序正确与否 时间限制: 1 秒 内存限制: 10KB 问题描述 给定一个栈,其中最多存储M个数据。将N个数据以1,2,3,…,N的顺序压栈,然后再随机弹栈。判断一下哪些是有可能的弹栈顺序,而哪些不是。...
  • 判断栈的弹出顺序

    2013-06-17 11:37:05
    题目:输入两个整数序列,第一个序列表示的压入顺序,请判断第二个序列是否为该的弹出顺序。 分析:建立一个辅助,将第一个序列数字依次压入栈中,并按照第二个序列顺序依次出栈。 #include #include ...
  • 题目:设一个的输入序列为1,2,3…n,编写算法,判断序列,p1,p2,…pn是否是合理的输出序列 思想: 将预期的出栈顺序用一个辅助保存起来,然后将元素按照入栈的顺序依次存入,若元素等于辅助的栈顶元素,则...
  • C语言实现顺序.c

    2020-06-22 23:40:54
    C语言实现顺序栈 顺序栈的常规操作 ... // 判断栈满 int StackEmpty(); // 判断栈空 int StackLength(); // 求栈长(栈元素个数) int Push(); // 入栈 压栈 ElemType Pop(); // 出栈 弹栈
  • 实现回文判断

    2021-03-26 15:19:12
    实现回文的判断实验要求实验目的分析代码段结果 实验要求 (1)能够用高级语言描述的存储结构; (2)能够用高级语言编写的入栈和出栈等基本操作算法并通过程序测试其正确性; (3)能够运用的基本操作...
  • *栈满判断 *栈空的判断 *入栈 *出栈 *取栈顶元素 */ #include<stdio.h> #include<stdlib.h> typedef int element; typedef struct link_stack { element data; struct link_stack *next; }Link_...
  • 判断一下哪些是有可能的弹顺序,而哪些不是。例如M是5,N是7,我们可以得到1, 2, 3, 4, 5, 6, 7的弹顺序,而不能得到3, 2, 1, 7, 5, 6, 4这样的弹顺序。(M,N 输入说明 输入包含了一种情况下的测试数据。...
  • 运算受限的线性表-

    2020-05-28 15:50:50
    主要操作: 初始化栈、入栈、出栈、判断栈空、判断栈满 初始化栈 #define MAXSIZE 100 typedef struct{ int data[MAXSIZE];//栈数组 int top;//栈顶指针 }Stack; 判断栈空:栈顶指针指向-1 即不指向任何数组元素...
  • 栈:进栈,出栈,取栈顶元素,判断栈是否为空,置空栈,输出元素个数等 注:用switch进行选择操作。 //栈:进栈,出栈,取栈顶元素,判断栈是否为空,置空栈,输出元素个数等。 #include"stdio.h" #define maxsize 100...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 63,675
精华内容 25,470
关键字:

如何判断栈满了