精华内容
下载资源
问答
  • 当第0号栈的栈顶指针top[0]等于-1时该栈为空;当第1号栈的栈顶指针top[1]等于m时,该栈为空。 两个栈均从两端向中间增长。试编写双栈初始化,判断栈空、栈满、进栈和出栈等算法的函数。 注意 左栈是通常意义的栈,右栈...

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

    注意

    左栈是通常意义的栈,右栈的入栈操作(栈顶指针减1),出栈操作(栈顶指针加1)

    #include <stdio.h>
    typedef int ElemType;
    typedef struct
    {
    	int top[2], bot[2];
    	ElemType *V;
    	int m;
    }DblStack;
    
    bool Init(DblStack *stk)
    {
    	stk->top[0] = -1;
    	stk->top[1] = stk->m;
    	stk->bot[0] = 0;
    	stk->bot[1] = stk->m - 1;
    	return 1;//初始化成功
    }
    
    int push(DblStack *stk, int i, int val)
    {
    	if (stk->top[1] - stk->top[0] == 1)
    	{
    		printf("OverFlow!/n");
    		return 0;
    	}
    	switch (i)
    	{
    	case 0:
    		V[++top[0]] = val;
    		return 1;
    		break;
    	case 1:
    		V[--top[1]] = val;
    		return 1;
    		break;
    	default:
    		printf("Error stack!\n");
    		return 0;
    	}
    }
    
    ElemType pop(DblStack *stk, int i)
    {
    	switch (i)
    	{
    	case 0:
    		if (stk->top[0] == -1)
    			printf("左栈为空!\n");
    		else
    			return stk->V[top[0]--];
    	case 1:
    		if (stk->top[1] == m)
    			printf("右栈为空!\n");
    		else
    			return stk->V[top[1]++];
    	default:
    	}
    }
    
    int Empty(DblStack *stk)
    {
    	return (stk->top[0] == -1 && stk->top[1] == m);
    }
    
    展开全文
  • 当第0 号栈的栈顶指针 top[0]等于-1 时该栈为空;当第 1 号栈的栈顶指针 top[1]等于 m 时,该栈为空。两个栈均从两端向中间增长(见下图)。试编写双栈初始化,判断栈空、栈满、进栈 和出栈等算法的函数。双栈数据...


    产出

    CSDN 技术博客 1 篇
    哔哩哔哩专栏1篇

    问题

    将编号为 0 和 1 的两个栈存放于一个数组空间 V[m]中,栈底分别处于数组的两端。当第0 号栈的栈顶指针 top[0]等于-1 时该栈为空;当第 1 号栈的栈顶指针 top[1]等于 m 时,该栈为空。两个栈均从两端向中间增长(见下图)。试编写双栈初始化,判断栈空、栈满、进栈
    和出栈等算法的函数。双栈数据结构的定义如下;
    在这里插入图片描述

    所需函数

    1、初始化双栈
    void InitDblStack(DblStack &stack)
    2、判断总体是否为空栈
    int EmptyDblStack(DblStack stack)
    3、判断左栈是否为空栈
    int EmptyLeft(DblStack stack)
    4、判断右栈是否为空栈
    int EmptyRight(DblStack stack)
    5、判断是否为满栈
    int FullDblStack(DblStack stack)
    6、左栈进栈
    int pushLeft(DblStack &stack, elem e)
    7、右栈进栈
    int pushRight(DblStack &stack, elem e)
    8、左栈出栈
    elem popLeft(DblStack &stack)
    9、右栈出栈
    elem popRight(DblStack &stack)
    10、遍历双栈
    void printDblStack(DblStack stack)

    实现代码

    #include <stdio.h>
    #include <stdlib.h>
    
    #define InitMaxsize 3//栈最大可容纳元素个数
    
    typedef int elem;
    
    typedef struct
    {
    	int top[2], bot[2];//定义栈顶和栈底指针
    	elem *V;			//栈数组
    	int m;				//栈最大可容纳元素个数
    }DblStack;
    
    //初始化双栈
    void InitDblStack(DblStack &stack)
    {
    	elem *arr = (elem*)malloc(sizeof(elem));//申请空间
    	stack.V = arr;							//将V指针指向申请的空间
    	stack.m = InitMaxsize;					//初始化栈最大可容纳最大元素个数
    	stack.top[0] = -1;						//左栈栈顶指针初始化
    	stack.top[1] = stack.m - 1;				//右栈栈顶指针初始化
    	stack.bot[0] = 0;						//左栈栈底指针初始化
    	stack.bot[1] = stack.m-1;				//右栈栈底指针初始化
    	
    	
    }
    
    //判断总体是否为空栈
    int EmptyDblStack(DblStack stack)
    {
    	if(stack.top[0] == -1 && stack.top[1] == stack.m-1)
    		return 1;		//若是返回1
    	return 0;			//否则返回0
    }
    
    //判断左栈是否为空栈
    int EmptyLeft(DblStack stack)
    {
    	if(stack.top[0] == -1)
    		return 1;		//若是返回1
    	return 0;			//否则返回0
    }
    
    //判断右栈是否为空栈
    int EmptyRight(DblStack stack)
    {
    	if(stack.top[1] == stack.m-1)
    		return 1;		//若是返回1
    	return 0;			//否则返回0
    }
    
    //判断是否为满栈
    int FullDblStack(DblStack stack)
    {
    	if(stack.top[1] == stack.top[0] || stack.top[0] >= stack.m || stack.top[1] < 0 )
    		//三种满栈情况左右两栈中间相遇,左栈满,右栈满
    		return 1;//满栈返回1
    	return 0;//否则返回0
    }
    
    //左栈进栈
    int pushLeft(DblStack &stack, elem e)
    {
        if (FullDblStack(stack) == 1)//判断是否为满栈
    	{
    		printf("栈已满不能进行进栈操作\n");
    		return 0;				//满栈返回0
    	}
        stack.top[0]++;				//左栈栈顶指针加一
    	stack.V[stack.top[0]] = e;	//将数据元素进栈
        return 1;					//完成操作返回1
    }
    
    //右栈进栈
    int pushRight(DblStack &stack, elem e)
    {
        if (FullDblStack(stack) == 1)//判断是否为满栈
    	{
    		printf("栈已满,无法进行进栈操作\n");
    		return 0;				//满栈返回0
    	}
        stack.V[stack.top[1]] = e;	//将数据元素进栈
        stack.top[1]--;				//右栈栈顶指针加一
        return 1;
    }
    
    //左栈出栈
    elem popLeft(DblStack &stack)
    {
        if (EmptyLeft(stack) == 1)//判断是否为空栈
    	{
    		printf("左栈已空,无法进行出栈操作\n");
    		return 0;					//空栈返回0
    	}
        elem e = stack.V[stack.top[0]];	//取出栈顶数据元素
        stack.top[0]--;					//左栈栈顶元素减一
        return e;						//返回原栈顶元素
    }
    
    //右栈出栈
    elem popRight(DblStack &stack)
    {
        if (EmptyRight(stack) == 1)	//判断是否为空栈
    	{
    		printf("右栈已空,无法进行出栈操作\n");
    		return 0;					//空栈返回0
    	}
    	stack.top[1]++;					//右栈栈顶指针加一
        elem e = stack.V[stack.top[1]];	//取出右栈栈顶元素
        return e;						//返回原栈顶元素
    }
    
    //遍历双栈
    void printDblStack(DblStack stack) 
    {
        for (int i = 0; i <= stack.top[0]; i++) //输出左栈
    	{
            printf("|%d| ", stack.V[i]);
        }
    	for(int i = ++stack.top[1]; i < stack.m; i++)//输出右栈
    	{
    		 printf("|%d| ", stack.V[i]);
    	}
        printf("\n");
    }
    
    
    //调试
    int main()
    {
    	DblStack stack;
    	InitDblStack(stack);											//初始化双栈
    	printf("双栈%s空栈\n", EmptyDblStack(stack) == 1?"是":"不是");	//判断总体是否为空栈
    	pushLeft(stack, 1);												//左栈进栈
    	pushLeft(stack, 2);												//左栈进栈
    	pushRight(stack, 3);											//右栈进栈
    	printf("双栈%s满栈\n", FullDblStack(stack) == 1?"已":"未");//判断是否为满栈
    	popLeft(stack);
    	popRight(stack);
    	popRight(stack);
    	printDblStack(stack);
    	return 0;
    }
    

    运行结果

    在这里插入图片描述

    理解方法

    1、根据题意想象出程序运行的动态图,如果想不出来可以尝试用笔画一下。
    2、源代码注释很全,看代码不能急躁,慢慢看。一行一行代码分析。
    如有错误,欢迎读者批评指正。
    如有疑问,可在下方留言。

    展开全文
  • 当第0号栈的栈顶指针top[0]等于-1时该栈为空;当第1号栈的栈顶指针top[1]等于m时,该栈为空。两个栈均从两端向中间增长(见下图)。试编写双栈初始化,判断栈空、栈满、进栈和出栈等算法的函数。双栈数据结构的定义...

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

    typedef struct{
    int top [ 2],bot [ 2]//栈顶和栈底指针
    SElemType *v ;//栈数组
    int m ;//栈最大可容纳元素个数
    }Dblstack;
    

    图示
    在这里插入图片描述

    代码

    #include <stdio.h>
    #include <stdlib.h>
    
    #define TRUE 1
    #define FALSE 0
    #define ERROR 0
    #define OK 1
    #define INIT_SIZE 5
    #define INCREASE_SIZE 2
    #define OVERFLOW -1
    #define EMPTY_ELEM -1
    
    typedef int ElemType;
    typedef int status;
    
    typedef struct {
        int top[2], bot[2];//栈顶和栈底指针
        ElemType *v;//栈数组
        int m;//栈最大可容纳元素个数
    } DblStack;
    
    //数组初始化要使用malloc, 否则只是进行了声明, 未开辟空间无法存储内容
    void initDblStack(DblStack &stack) {
        ElemType *arr = (ElemType *) malloc(sizeof(ElemType) * INIT_SIZE);
        stack.v = arr;
        stack.m = INIT_SIZE;
        stack.top[0] = 0;
        stack.bot[0] = 0;
        stack.top[1] = stack.m - 1;
        stack.bot[1] = stack.m - 1;
    }
    
    status isEmpty(DblStack stack) {
        if (stack.top[0] == stack.bot[0] && stack.top[1] == stack.bot[1]) {
            return 1;
        }
        return 0;
    }
    
    
    status isFull(DblStack stack) {
        if (stack.top[1] - stack.top[0] <= -1 || stack.top[1] < 0 || stack.top[0] > stack.m - 1) {
            return 1;
        }
        return 0;
    }
    
    //右栈稍麻烦, 需要一些计算步骤处理
    void extendCapacity(DblStack &stack) {
        ElemType *new_arr = (ElemType *) malloc(sizeof(ElemType) * (stack.m + INCREASE_SIZE));
        int new_size = stack.m + INCREASE_SIZE;
        int i, j;
        for (i = stack.bot[0]; i < stack.top[0]; i++) {
            new_arr[i] = stack.v[i];
        }
    
        int n = stack.bot[1] - stack.top[1];
        for (j = new_size - 1, i = stack.m - 1; j > new_size - 1 - n; j--, i--) {
            new_arr[j] = stack.v[i];
        }
        //重新计算右栈
        stack.bot[1] = new_size - 1;
        stack.top[1] = stack.bot[1] - n;
        stack.m = new_size;
    
        ElemType *old_arr = stack.v;
        stack.v = new_arr;
        free(old_arr);
    }
    
    status pushLeft(DblStack &stack, ElemType e) {
        if (isFull(stack) == TRUE) extendCapacity(stack);
        stack.v[stack.top[0]] = e;
        stack.top[0]++;
        return OK;
    }
    
    status pushRight(DblStack &stack, ElemType e) {
        if (isFull(stack) == TRUE) extendCapacity(stack);
        stack.v[stack.top[1]] = e;
        stack.top[1]--;
        return OK;
    }
    
    ElemType popLeft(DblStack &stack) {
        if (isEmpty(stack) == TRUE)return ERROR;
        if (stack.top[0] <= stack.bot[0])return ERROR;
        ElemType e = stack.v[--stack.top[0]];
        stack.v[stack.top[0]] = EMPTY_ELEM;
        return e;
    }
    
    ElemType popRight(DblStack &stack) {
        if (isEmpty(stack) == TRUE)return ERROR;
        if (stack.top[1] >= stack.bot[1])return ERROR;
        ElemType e = stack.v[++stack.top[1]];
        stack.v[stack.top[1]] = EMPTY_ELEM;
        return e;
    }
    
    void printDblStack(DblStack stack) {
        for (int i = 0; i < stack.m; i++) {
            printf("|%d|\t", stack.v[i]);
        }
        printf("\n");
    }
    
    
    //测试
    int main() {
        DblStack stack;
        initDblStack(stack);
        printf("stack is Empty:%d\n",isEmpty(stack));
    
        pushLeft(stack, 1);
        pushLeft(stack, 2);
        pushLeft(stack, 3);
        pushLeft(stack, 1010);
    
        pushRight(stack, 5);
        pushRight(stack, 4);
        pushRight(stack, 3);
        pushRight(stack, 2);
    
        pushLeft(stack,4);
        pushLeft(stack,4);
        printDblStack(stack);
    
        printf("%d\n",popLeft(stack));
        printf("%d\n",popLeft(stack));
        printf("%d\n",popRight(stack));
        printDblStack(stack);
    
        return 0;
    }
    

    本文完.


    想了解作者更多,请移步我的个人网站,欢迎交流、留言~
    极客技术空间:https://elltor.com/

    展开全文
  • //栈顶指针,这个栈结构没有bottom指针,感觉更简洁! } Status InitStack(LStack &s) //构造一个空栈 { struct LNode *p; p=(LNode *)malloc(sizeof(LNode)); if(!p) { printf("存储分配失败!"); exit...
    #define TRUE        1 
    #define FALSE       0 
    #define OK          1 
    #define ERROR       0 
    #define OVERFLOW    -1 
    #define UNDERFLOW   -2 
    
    struct LNode// 链式栈s中的结点结构
    {
     char data;//数据
     struct LNode *next;//指针
    };
    struct LStack{
     struct LNode *top;//栈顶指针,这个栈结构没有bottom指针,感觉更简洁!
    }
    Status InitStack(LStack &s)
     //构造一个空栈
    {
     struct LNode *p;
     p=(LNode *)malloc(sizeof(LNode));
     if(!p)
     {
      printf("存储分配失败!");
      exit(OVERFLOW);
     }
     s.top=p;
     p->next=NULL;
     return OK;
    }
    Status DestoryStack(LStack &s)
     //初始条件:栈s已存在
     //操作结果:销毁栈
    {
     struct LNode *p;
     p=s.top;
     while(p)
     {
      s.top=p->next;
      free(p);
      p=s.top;
     }
     return OK;
    }
    Status StackEmpty(LStack s)
     初始条件:栈s已存在
     //操作结果:若栈为空栈,返回true,否则返回false
    {
     if(s.top->next==NULL)
      return TRUE;
     return FALSE;
    }
    Status  StackLength(LStack s)
    //初始条件:栈s已存在 
    //操作结果:返回s的元素个数,即栈的长度
    {
       int length=0;
       struct LNode *p;
       p=s.top;
       while(p){
       length++;
       p=p->next;
       }
       return length;
    }
     
    Status Push(LStack &s,ElemType e)
    //初始条件:栈s已存在 
    //操作结果:插入元素e成为新的栈顶元素
    { 
       struct LNode *p;
       p=(LNode *)malloc(sizeof(LNode));
       if(!p)
        exit(OVERFLOW);
       p->data=e;
       p->next=s.top;
       s.top=p;
       return OK;
    }  
      
      
    Status  Pop(LStack &s,ElemType &e)
     //初始条件:栈s已存在且非空 
     //操作结果:删除s的栈顶元素,并且用e返回其值
    {
        struct LNode *p;
        if(!(s.top->next))
           exit(ERROR);
        p=s.top;
        s.top=p->next;
        e=p->data;
        free(p);
        return OK;
    }
    
    Status  GetTop(LStack s,ElemType &e)
     //初始条件:栈s已存在且非空 
    //操作结果:用e返回s的栈顶元素
    {
         if(!(s.top->next))
    	exit(ERROR);
         e = s.top->data;    
         s.top=s.top->next;
         e=s.top->data;
         return OK;
    }
     
    Status  StackTraverse(LStack s)
    //从栈顶开始依次输出
    {
         struct LNode *p;
         if(!(s.top->next))
       	exit(ERROR);
         p=s.top;
         while(p)
        {
    	cout<<p->data<<endl;   
    	p=p->next;
        }
        return OK;
    }
    

    展开全文
  • 【单选题】条件语句“Where 工资额>1000”的意思是【单选题】以下查询中不能更改数据库中表记录的是__。【单选题】以下关于查询显示结果中字段名显示的叙述,正确的是__。【单选题】在创建带子窗体的窗体时,主窗体...
  • 顺序栈栈顶指针指向详析

    千次阅读 2020-03-25 14:23:09
    顺序栈栈顶指针指向详析 1.变长型(动态分配内存空间) #define STACK_INIT_SIZE 100 //存储空间初始分配量 #define STACKINCREMENT 10... //定义栈顶指针top SElemType *base; //定义栈底指针base int stacksi...
  • 栈顶指针:S.top 栈顶元素:S.data[S.top] 当栈顶指针的初始值设置 S.top=-1时 ps: 当栈为空时,栈顶指针指向data[-1],但栈底是data[0] top data{4} data{3} data{2} data{1} data{0} data{-1} ...
  • 读栈顶元素以及顺序输出栈顶指针与栈中的元素 */ #include using namespace std; // template class sq_Stack { private: int mm; // 存储容量 int top;// 栈顶指针 T *s; //顺序栈存储控件首地址 public: sq_...
  • 顺序栈有两种描述 typedef struct { ... //存放栈顶元素在数组中的下标 }SqStack; typedef struct{ ElemType *base; ElemType *top; int MaxSize; //当前已分配的空间 }SqStack; 今天拿出来的...
  •   通常情况,栈都是从栈底往栈顶压,初始状态栈顶指针top=0(栈空)。当top=m+1,栈满;当top=23,栈内有23个元素。   当从栈顶往栈底压时,初始状态栈顶指针top=m+1(栈空)。当top=0,栈满;当top=23,栈内有...
  • //修改栈顶指针 S->StackSize=S->StackSize+INCREMENT; //扩容后栈的存储容量 } *++S->top=e; //将e入栈 } 四、栈的当前长度: /*栈的当前长度*/ Status StackLength(SqStack *S) { if( S->top >= ...
  • 链栈初始化即先构造一个空栈,将栈顶指针top所指的头结点的指针域置空。 //初始化 LinkedStack Init_LinkedStack() { LinkedStack top=(LinkedStackNode * )malloc (sizeof( LinkedStackNode)); if(top!=NULL)//...
  • 数据结构与算法笔记(二)顺序栈、链栈、环形队列、链队顺序栈链栈环形队列链队 顺序栈、链栈、环形队列、链队 顺序栈 顺序栈采用数组的形式对数据...进栈时将栈顶指针top+1,再对此时所指向的数组空间(data域)进...
  • 当从尾部压入栈的栈顶指针top2+1与从数据首部压入的栈的栈顶指针top1相等的时候,数组需要进行扩容处理;即top1=top2+1;
  • 2007-05-31 21:13:00
    栈是在只能在表尾进行插入和删除操作的...最后入栈者先出栈 1 顺序栈 栈空时栈顶指针top==-1,栈满时栈顶指针topv==StackSize-1,入栈时栈顶指针top加1,出栈时栈顶指针top减1;顺序栈存储结构数组实现类的声明 con
  • 堆叠顺序

    2015-12-13 20:36:00
    底指针base与栈顶指针top。若base=NULL,则表明栈结构不存在。top指针初值指向栈底,top=base可用作栈为空的标记。新插入元素后栈顶指针top的值加1,删除元素时减1。即非空栈的栈顶指针top始终在栈顶元素的下一个位置...
  • #include #include #define STACK_INIT_SIZE 100//初始容量 #define STACKINCREMENT 10//每次增加的容量 typedef struct ... int *top;//栈顶指针  int stacksize;//栈容量 }Sqstack; int InitS
  • 栈的应用

    2021-01-19 17:00:38
    栈顶指针TOP置为-1,表示栈中没有元素。 void clear() { TOP = -1; } 获取栈内元素个数 由于栈顶指针TOP始终指向栈顶元素,而数组下标从0开始,因此栈内元素的数为TOP+1。 int size() { return
  • *top为栈顶指针其初值指向栈底,即top = base 可作为栈空的标记插入新的栈顶元素,指针top增1;删除栈顶元素时指针top减1;#include #include # define STACK_INIT_SIZE 100 # define STACKINCREMENT 10 # define ...
  • 数据结构笔记||栈

    2020-06-17 09:35:46
    元素e的进栈操作:先将栈顶指针top增1,然后将元素e放在栈顶指针处 出栈操作:先将栈顶指针top处的元素取出放在e中,然后将栈顶指针减1 算法如下 #include<iostream> #include<cstdlib> us
  • 栈与队列

    2020-11-02 11:47:21
    栈的清空操作将栈顶指针TOP置为-1,表示栈中没有元素。 void clear() { TOP=-1; } (2)获取栈内元素个数(size) 由于栈顶指针TOP始终指向栈顶元素,而数组下标从0开始,因此栈内元素的数位TOP+1. int

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,589
精华内容 635
关键字:

栈顶指针top