精华内容
下载资源
问答
  • 主讲人章万静 否 是 开始 结束 top==MAX-1 栈顶元素下标top 顺序栈最大空间MAX 定义变量 栈已 栈没 顺序栈判断栈满 顺序栈判断栈满 顺序栈判断栈满很重要在进栈操作之前必须要进行判断 顺序栈判断栈满条件top=...
  • 顺序栈 栈空:top==-1 栈:top==maxsize-1 链栈 栈空:s->next==NULL 栈:不存在 环形队列 队空:p->front==p->rear 队:(p->rear+1)%maxsize==p->front 链队 队空:q->rear==NULL 队:不...

    顺序栈

    栈空:top==-1

    栈满:top==maxsize-1

    链栈

    栈空:s->next==NULL

    栈满:不存在

    环形队列

    队空:p->front==p->rear

    队满:(p->rear+1)%maxsize==p->front

    链队

    队空:q->rear==NULL

    队满:不存在

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

    千次阅读 多人点赞 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为减一)
    图四

    展开全文
  • 我是采用了两个值得比较大小判断得(可能比较浪费空间但是代码我感觉简单一点) 首先是定义一个的结构元素,由于是字符串类型就直接定义一个char的数组就可以: typedef struct stack { char data[MAX_SIZE]; //...

    我是采用了两个栈值得比较大小判断得(可能比较浪费空间但是代码我感觉简单一点)

    首先是定义一个栈的结构元素,由于是字符串类型就直接定义一个char的数组就可以:

    typedef struct stack
    {
        char data[MAX_SIZE];      //储存字符串// 
        int top;                  //记录栈顶// 
    }SeqStack;

    下来就是初始化,我这里是用的耿国华老师的方法就直接给一个top元素指向栈顶,传入的指针地址:

    void Initstack(SeqStack *S)   //初始化栈,让top指向栈顶// 
    {
    	S->top=-1;
    }

    下面就是创建顺序栈了,元素只要没满就一直可以入住:

    int Push(SeqStack *S,char x)  //压栈,只要top小于MAX_SIZE-1就可以继续入栈// 
    {
    	if(S->top<=MAX_SIZE-1)
    	{
    	S->top++;
    	S->data[S->top]=x;
        }else{
        	return -1;;
    	}
    }

    下面是核心函数,操作实现回文序列的判断,我注释的比较清楚直接看就可以了:

    void Pop(SeqStack *S)        //出栈操作,也是最主要的操作// 
    {
    	SeqStack *p;                       
    	p=(SeqStack*)malloc(sizeof(SeqStack));  //建立一个新的空栈,由于是指针类型要分配动态地址//
    	Initstack(p);                           //给新的栈进行初始化// 
    	int i=S->top/2;                         //i用来分割两个字符串,将第二个字符串赋给新的空栈// 
    	int j=i-1;                              //j用来记录除了@之外的其他字符数量大小// 
    	while(S->top!=i)                        //开始对空栈进行赋值,对原来的栈开始清空(清空一般大小)// 
    	{
    		p->top++;
    		p->data[p->top]=S->data[S->top];
    		S->top--;
        }
        S->top=S->top-2;                        //让原来的栈直接指向数字,跨过了字符@// 
        for(int k=0;k<i-1;k++)                  //循环次数由i-1决定,也就是出去@字符之后的其他需要比较的字符// 
        {
        	if(S->data[S->top]==p->data[p->top])  //由于栈的特点先进后出,所以新栈的存储顺序和去掉@字符之后的旧栈的存储顺序是一样的,所以这里直接比较// 
        	{
        		j--;                             //j是定义需要比较字符的大小,只要两个栈的元素ASCLL相等j就减一,如果全部相等j为0,该字符串就是互为回文序列// 
    		}
    		S->top--;                            //两个top指针向下值// 
        	p->top--;
    		if(j==0)                         //判断// 
    		{
    			printf("两个字符串互为回文序列!");
    		}
    	}
    	if(j!=0)
    	{
    		printf("两个字符串不互为回文序列!");
    	}
    	free(p);                       //free掉分配的空间// 
    }

    下面附上整个代码:

    #include<stdio.h>
    #include<stdlib.h>
    #define MAX_SIZE 100
    typedef struct stack
    {
        char data[MAX_SIZE];      //储存字符串// 
        int top;                  //记录栈顶// 
    }SeqStack;
    void Initstack(SeqStack *S)   //初始化栈,让top指向栈顶// 
    {
    	S->top=-1;
    }
    int Push(SeqStack *S,char x)  //压栈,只要top小于MAX_SIZE-1就可以继续入栈// 
    {
    	if(S->top<=MAX_SIZE-1)
    	{
    	S->top++;
    	S->data[S->top]=x;
        }else{
        	return -1;;
    	}
    }
    void Pop(SeqStack *S)        //出栈操作,也是最主要的操作// 
    {
    	SeqStack *p;                       
    	p=(SeqStack*)malloc(sizeof(SeqStack));  //建立一个新的空栈,由于是指针类型要分配动态地址//
    	Initstack(p);                           //给新的栈进行初始化// 
    	int i=S->top/2;                         //i用来分割两个字符串,将第二个字符串赋给新的空栈// 
    	int j=i-1;                              //j用来记录除了@之外的其他字符数量大小// 
    	while(S->top!=i)                        //开始对空栈进行赋值,对原来的栈开始清空(清空一般大小)// 
    	{
    		p->top++;
    		p->data[p->top]=S->data[S->top];
    		S->top--;
        }
        S->top=S->top-2;                        //让原来的栈直接指向数字,跨过了字符@// 
        for(int k=0;k<i-1;k++)                  //循环次数由i-1决定,也就是出去@字符之后的其他需要比较的字符// 
        {
        	if(S->data[S->top]==p->data[p->top])  //由于栈的特点先进后出,所以新栈的存储顺序和去掉@字符之后的旧栈的存储顺序是一样的,所以这里直接比较// 
        	{
        		j--;                             //j是定义需要比较字符的大小,只要两个栈的元素ASCLL相等j就减一,如果全部相等j为0,该字符串就是互为回文序列// 
    		}
    		S->top--;                            //两个top指针向下值// 
        	p->top--;
    		if(j==0)                         //判断// 
    		{
    			printf("两个字符串互为回文序列!");
    		}
    	}
    	if(j!=0)
    	{
    		printf("两个字符串不互为回文序列!");
    	}
    	free(p);                       //free掉分配的空间// 
    }
    int main()
    {
    	SeqStack S;
    	char x;
    	int m=0;
    	Initstack(&S);
    	printf("请输入第一串字符\n");
    	while(m!=2)                            //因为只需要输入两个字符串的判断,判断条件为m!=2// 
    	{
    	    scanf("%c",&x);
    	    if(x=='@')                           //输入@后表明第一个字符串结束// 
    	    {
    	    	m++;
    	        if(m==1)
    	        {
    	        	printf("请输入第二串字符:\n");
    	     	}
        	}
         	Push(&S,x);
        }
        Pop(&S);
    	return 0;
    }

    下面加一个例子:

    判断3+1与1+3是否为回文序列

    展开全文
  • 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]);
    	}
    	
    	
    }
    


    展开全文
  • 顺序栈,遵循先进后出后进先出原则。我在写的时候,宏定义的 firstsize 为创建一个栈时这个栈的初始大小,这里为100。addsize 为当栈时,再想入栈的话每次栈大小的增量,这里用10来代替。 create函数为创建栈函数...
  • {//判断t字符向量是否为回文,若是,返回1,否则返回0 SqStack s; int i , len; char temp; InitStack( &s); len=strlen(t); //求向量长度 for ( i=0; i; i++)//将一半字符入栈 Push( &s, t[i]); while( !EmptyStack...
  • 顺序栈的设计及运行 1. 顺序栈 栈是在顺序表和链表的基础上学习的另一种存储形式,是只能在表的一端(栈顶)进行插入和删除的线性表,也就是遵循先进后出的原则,它与线性表一样,仍然是一对一的关系,根据存储关系...
  • 顺序栈—基本操作的实现及简单应用(C语言)

    千次阅读 多人点赞 2020-12-02 17:53:28
    文章目录栈的顺序表示和实现以及简单应用(C语言)一、顺序栈的基本概念二、代码实现:1.引入库2.读入数据总结 提示:以下是本篇文章正文内容,下面案例可供参考 一、顺序栈的基本概念 示例:pandas 是基于NumPy 的...
  • 对于顺序栈,入栈时,首先判断栈是否为,栈条件为:p->top= =MAXNUM-1,栈时,不能入栈; 否则出现空间溢出,引起错误,这种现象称为上溢。 出栈和读栈顶元素操作,先判栈是否为空,为空时不能操作,否则...
  • 数据结构--栈--共享顺序栈

    千次阅读 2019-03-29 00:09:31
    共享顺序栈:内部也是一个数组 将两个栈放在数组的两端,一个从数组首端开始压栈,一个从数组尾部开始压栈,等到两边栈顶在中间相遇时,栈。 共享顺序栈在某些情况下可以节省空间。 头文件 sharingStack.h //共享...
  • Python描述数据结构之顺序栈

    千次阅读 2020-08-07 20:32:33
    本篇章主要介绍栈里的栈及顺序栈,并用Python实现顺序栈的基本操作。
  • 点击图片上方蓝字字体"算法简堂"即可订阅栈——顺序栈1 栈大家都有将物品收纳进盒子里的经历,也一定有先放进去的物品需要在最后才能取出的认识。对栈的操作就如同使用这个盒子。栈是一种只能在一端进行插入与删除...
  • 顺序栈与链式栈的实现

    千次阅读 2017-10-23 17:23:32
    栈的概念:栈(stack)又名堆栈,它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶,相对地,把另一端称为栈底...顺序栈:base.h 这个头文件主要用来存放公用的常量和类型。
  • //判断栈的空间是否用完 if(k){ printf("请输入一个整数\n"); scanf("%d",&d); v[k]=d; *n=k; } else printf("栈的空间已!\n"); } //出栈函数 void pop_sq_LList(int* v,int m, int* n){ ...
  • 栈之顺序栈

    2017-03-26 11:07:06
    顺序栈的简介在顺序栈中有”上溢”和”下溢”的概念。顺序栈好比一个盒子,我们在里头放了一叠书,当我们要用书的话只能从第一本开始拿(你会把盒子翻过来吗?真聪明^^),那么当我们把书本放到这个栈中超过盒子的顶部...
  • 在进行各类操作时,底指针固定不动,掌握空、栈满判断条件。 (2)实验内容 用顺序存储结构,实现教材定义的的基本操作,提供数制转换功能,将输入的十进制整数转换成二进制、八进制或十六进制。 (3)...
  • 数据结构——共享算法的栈满问题

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

    万次阅读 2017-10-14 11:21:15
    由于顺序栈的操作位置基本在栈底,所以,不需要查找插入和删除的位置,也不需要移动元素,因而顺序栈的基本操作要比顺序表简单的多,其基本操作时间复杂度均为O(1)。下面给出顺序栈的部分操作的实现。(1)初始化...
  • 问题:链表,,队列(循环队列)判定或者空的条件?急求 1、为空条件 单链表:头结点指针域next == NULL 静态链表:数组最后一个元素值为0 循环链表:头结点的指针域指向它本身(循环查找时以p->next !=头结点...
  • 二、顺序存储的实现 1.的定义和初始化 注意:在内存中还要申请top栈顶指针空间,top记录的是数组的下标 栈顶指针记录的是数组的下标 #define MaxSize 10 //定义中元素的最大个数 typedef struct { int ...
  • 顺序栈-初始化栈顶指针为-11.头文件及类型定义2.顺序栈类型定义3.函数声明4.基本操作4.1 初始化顺序栈4.2 判空4.3 入栈4.4 出栈4.5 读取栈顶元素4.6 main函数5.小结 1.头文件及类型定义 #include<stdio.h> #...
  • 顺序栈实现数制转换

    千次阅读 2020-07-18 12:12:21
    顺序栈实现数制转换 ...数制转换思路:对十进制的整数 N ,N%2结果放入栈中 N/2结果作为循环判断条件 N==0循环终止 ********************************************************************************/ #i
  • 实验只包括的相关操作,没有用到队列,其实我觉得队列也挺复杂的。哈哈哈,刚刚看了一下,下一个实验就是关于队列的,慢慢学吧,加油! 定义: 和队列是两种特殊的线性表,即操作受限的线性表,只是对插入、...
  • 往前学习数据结构,想运行一个完整的顺序栈的程序都运行不了,因为书上给的都是一部分一部分的算法,并没有提供一个完整可运行的程序,听了实验课,自己折腾了一下,总算可以写一个比较完整的顺序栈操作的小程序,...
  • (2)掌握顺序栈的入栈和出栈等基本操作算法实现。 (3)了解栈在解决实际问题中的简单应用。 2.上机内容 利用顺序栈的基本操作实现将任意一个十进制整数转化为R进制(二进制、八进制)整数,主要包括: (1)定义栈的顺序...
  • 的定义:是一种只能在一端进行插入或删除操作的线性表 栈顶(Top):表尾 允许插入和删除的一端。 约定Top始终指向下一个数据元素将存放的位置。 底(Base):表头 不允许插入和删除的一端 约定base始终指向...
  • 顺序栈比较简单。本程序只是插入一个数据之后直接删除该数据。不够完善请原谅。 seqstack.h文件。 #include #include #define MAXSIZE 50 #define False 0; #define True 1; typedef struct{...
  • 顺序栈即栈的顺序存储结构,它利用一组地址连续的存储单元存放自栈底到栈顶的... 判断栈不存在的条件为:S.base=NULL;  空栈:S.base=S.top;   栈:S.top-S.base=S.stacksize;  #include "stdafx.h" #include
  • # 顺序栈与链式栈的图解与实现 栈是一种特殊的线性表,它与线性表的区别体现在增删操作上 栈的特点是先进后出,后进先出,也就是说栈的数据操作只能发生在末端,而不允许在中间节点进行操作 如上图所示,对栈的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 83,295
精华内容 33,318
关键字:

顺序栈判断栈满的条件