精华内容
下载资源
问答
  • 该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include "stdio.h"#include "stdlib.h"void init_stack( int *s,int m,int *top){s=malloc(m*sizeof(int));*top=0;}void push(int s[],int m,int*top, int x ){if(*top=...

    该楼层疑似违规已被系统折叠 隐藏此楼查看此楼

    #include "stdio.h"

    #include "stdlib.h"

    void init_stack( int *s,int m,int *top)

    {s=malloc(m*sizeof(int));

    *top=0;

    }

    void push(int s[],int m,int*top, int x )

    {if(*top==m){printf("stack-overflow\n");return;}

    *top=*top+1;

    s[*top-1]=x;

    return;}

    void pop( int s[],int *top,int*y)

    {if(*top==0)

    {printf("stack-underflow\n");

    return;}

    *y=s[*top-1];

    *top=*top-1;}

    void read( int s[],int *top,int*y )

    {if(*top==0)

    {printf("stack empty \n");

    return;}

    *y=s[*top-1];}

    main()

    {

    int s[10];

    int m, *y, *top;

    top=0;

    y=0;

    m=10;

    init_stack(s,m,top);

    /*scanf("%d",&x); */

    push(s,m,top,2);

    /*scanf("%d",&x); */

    push(s,m,top,3);

    push(s,m,top,4);

    push(s,m,top,5);

    push(s,m,top,6);

    /*for(i=0;i<5;i++)

    { scanf("%d",&x);

    push(s,m,top,x);} */

    read(s,top,y);

    printf("y=%d",*y);

    printf("\n");

    pop(s,top,y);

    pop(s,top,y);

    read(s,top,y);

    printf("y=%d",*y);

    printf("\n");

    return 0;

    }

    展开全文
  • 顺序,利用一组地址连续的存数单元依次存放自栈底到栈顶的数据元素,同时附设指针top指示栈顶元素在顺序中的位置,压栈、弹、获得栈顶元素、统计元素个数、打印元素
  • 栈顶元素以及顺序输出栈顶指针与中的元素 */ #include using namespace std; // template class sq_Stack { private: int mm; // 存储容量 int top;// 栈顶指针 T *s; //顺序存储控件首地址 public: sq_...
    /*
    	定义顺序栈类(初始化,入栈,退栈。读栈顶元素以及顺序输出栈顶指针与栈中的元素
    */
    #include<iostream>
    using namespace std;
    //
    template <class T>
    class sq_Stack
    {
    private:
    	int mm;	// 存储容量
    	int top;// 栈顶指针
    	T *s;	//顺序栈存储控件首地址
    
    public:
    	sq_Stack(int);
    	void prt_sq_Stack();
    	int flag_sq_Stack();
    	void ins_sq_Stack(T);
    	T del_sq_Stack();
    	T read_sq_Sqack();
    };
    
    //建立容量为mm的空栈
    template<class T>
    sq_Stack<T>::sq_Stack(int m)
    {
    	mm = m;
    	s = new T[mm];	// 动态申请存储空间
    	top = 0;
    	return;
    }
    
    // 顺序输出栈顶指针与栈中的元素
    template<class T>
    void sq_Stack<T>::prt_sq_Stack()
    {
    	int i;
    	cout<<"top = "<< top << endl;
    	for(int i = top; i > 0; i--)
    	{
    		cout << s[i - 1] << end;
    	}
    	return;
    }
    
    // 检测顺序表的状态
    template<class T>
    void sq_Stack<T>::flag_sq_Stack()
    {
    	if(top == mm)return -1;
    	if(top == 0) return 0;
    	return(1);
    }
    
    // 入栈
    template<class T>
    void sq_Stack<T>::ins_sq_Stack(T x)
    {
    	if(top == m)
    	{
    		cout << "Stack overflow!" << endl;
    		return;
    	}
    	top = top + 1;
    	s[top - 1] = x;
    	return;
    }
    
    // 退栈
    template<class T>
    T sq_Stack<T>::del_sq_Stack()
    {
    	T y;
    	if(top == 0)	
    	{
    		cout << "Stack underflow!" << endl;
    		return(0);
    	}
    	y = s[top - 1];
    	top = top - 1;
    	return y;
    }
    
    // 读栈顶元素
    template<class T>
    T sq_Stack<T>::read_sq_Sqack()
    {
    	if(top == 0)
    	{
    		cout<<"Stack empty!" << endl;
    		return 0;
    	}
    	return s[top - 1];
    }
    

    展开全文
  • 本例子讲述了如何创建一个,压栈即往里插入一个结点,删除栈顶元素,以及对里的结点进行清空,遍历里的结点 #include #include #include #include typedef struct Node { int data; //数据域 ...

    本例子讲述了如何创建一个栈,压栈即往栈里插入一个结点,删除栈顶元素,以及对栈里的结点进行清空,遍历栈里的结点

    #include <stdio.h>
    #include <stdlib.h>
    #include <malloc.h>
    #include <errno.h>
    
    typedef struct Node
    {
        int data;  //数据域
        struct Node *pNext;  //指针域
    }NODE, *PNODE;
    
    typedef struct Stack
    {
        PNODE pTop; //栈顶
        PNODE pBottom; //栈底
    }TSTACK, *PSTACK;
    
    //初始化栈
    int  init(PSTACK _pSt)
    {
        _pSt->pTop = (PNODE)malloc(sizeof(NODE)); //为栈顶分配内存
        if(NULL == _pSt->pTop)
        {
            printf("----malloc fail errno= %d\n", errno);
            return -1;
        }
        else
        {
            _pSt->pBottom = _pSt->pTop; //栈底指向了栈顶
            _pSt->pBottom->pNext = NULL; //将栈底指针域赋为空
        }
    
        return 0;
    }
    
    //压栈,往栈里写数据
    int push_stack(PSTACK _pSt, int _iVal)
    {
        PNODE pNew = (PNODE)malloc(sizeof(NODE));
        if(NULL == pNew)
        {
            printf("----Push_stack fail, errno\n", errno);
            return -1;
        }
        else
        {
            
            pNew->data = _iVal; //将待入栈的数据写入数据域中
            pNew->pNext = _pSt->pTop; //将新结点的指针域指向之前的栈顶
            _pSt->pTop = pNew;   //栈顶指向新结点  
        }
    }
    
    //判断栈是否为空栈
    int  Is_empty(PSTACK _pSt)
    {
        if(_pSt->pTop == _pSt->pBottom) //如果栈顶与栈底相等说明栈为空
        {
            return 1;
        }
        else
        {
            return 0;
        }
    }
    
    //对栈进行遍历
    void ergodic_stack(PSTACK _pSt)
    {
        if(1 == Is_empty(_pSt))
        {
            printf("----This stack is empty\n");
        }
        else
        {
            PNODE Temporary_node;
            Temporary_node = _pSt->pTop;
            while(Temporary_node != _pSt->pBottom) //不等于栈底
            {
                printf("%d ", Temporary_node->data);
                Temporary_node = Temporary_node->pNext;
            }
            printf("\n");
        }
    }
    
    //删除栈顶元素
    void pop_stack(PSTACK _pSt)
    {
        if(1 == Is_empty(_pSt))
        {
            printf("----This stack is empty\n");
        }
        else
        {
            PNODE Temporary_node;
            Temporary_node = _pSt->pTop;
            _pSt->pTop = _pSt->pTop->pNext;
    
            free(Temporary_node);
            Temporary_node = NULL;
        }  
    }
    
    //清空栈
    void clear_stack(PSTACK _pSt)
    {
        if(1 == Is_empty(_pSt))
        {
            printf("----This stack is already empty\n");
        }
        else
        {
            PNODE p = _pSt->pTop;
            PNODE q = NULL;
    
            while(p != _pSt->pBottom)
            {
                q = p->pNext;
                free(p);
                p = q;
            }
    
            _pSt->pTop = _pSt->pBottom; //栈顶指向栈底        
        }
    }
    
    int main(int argc, char* argv[])
    {
        TSTACK St;
        int iVal = 0;
        int i = 0;
         
        if(-1 == init(&St))
        {
            return -1;
        }
    
        while(i < 5)
        {
            printf("----Please input insert val to stack\n");
            scanf("%d", &iVal);
        
            push_stack(&St, iVal);
            i++;
        }
    
        ergodic_stack(&St); //对栈进行遍历
    
        pop_stack(&St);
        ergodic_stack(&St); //删除栈顶元素后再次进行遍历
    
        clear_stack(&St);
        ergodic_stack(&St); //清空栈元素后再次进行遍历
    
        return 0;
    }
    

    1 初始化栈

      初始化栈时为栈顶和栈底指向同一个结点,即栈顶指向栈底

    2 压栈

      压栈即往栈里插入一个结点,因为栈里插入元素只能插入到栈顶,所以压栈的步骤是,

     先创建一个新结点,然后把数据赋值到新结点数据域中,最后将栈顶指向新结点

    3 遍历栈

      因为栈时先进后出,所以栈顶元素先出来,栈底元素后出来。

     先定义一个新结点指针,新结点指向栈顶元素,进入while循环判断,如果新结点不等于栈底,则输出数据域,再将新结点指向新结点的下一个结点,以此进行

    循环判断

    4 删除栈结点

      因为删除栈结点时,必选从栈顶开始删除,所以删除一个栈元素,就是将栈顶元素删除,使栈顶指向下一个结点


    本程序的步骤,1 初始化栈

             2 往栈里插入五个结点,然后进行遍历输出,会输出5个结点的数据

                    3 删除一个栈元素,然后进行遍历输出,会输出4个节点的的数据

          4 将栈进行清空,然后进行遍历输出,会提示栈为空

    程序运行结果:


    展开全文
  • 的入栈出栈返回栈顶元素元素个数判空 #include <stdio.h> #include <stdlib.h> #include <string.h> //定义节点 typedef struct tag { int val; struct tag *pNext; }Node,*pNode;//别名 //...

    栈的入栈出栈返回栈顶元素元素个数判空

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    //定义节点
    typedef struct tag
    {
      int val;
      struct tag *pNext;
    }Node,*pNode;//别名
    
    //定义栈
    typedef struct{
      //头指针
    	pNode phead;
    	//栈中的元素个数
    	int size;
    }Stack,*pStack;
    
    //栈是先进后出,入栈实现,头插法头删法
    void push(pStack p,int val)
    {
    	//calloc申请空间并同时赋值为0
    	pNode pnew=(pNode)calloc(1,sizeof(Node));
    	pnew->val=val;
    	//头插法  也是实现判断栈是否为空empty()
    	if(NULL==p->phead)
    	{
    	 //链表为空
    		p->phead=pnew;
    	}else{
    		pnew->pNext=p->phead;
    	    p->phead=pnew;
    	}
    	p->size++;
    }
    //出栈实现
    void pop(pStack p)
    {
    	//定义一个节点pcur接收要被free的phead
    	pNode pcur;
      //判断链表是否为空
    	if(NULL==p->phead)
    	{
    	   printf("stack is empty\n");
    	   return;
    	}
    	//头部删除
    	//返回栈顶元素:int top()
    	pcur=p->phead;
    	p->phead=p->phead->pNext;
    	p->size--;
    	free(pcur);
    	pcur=NULL;
    }
    int size(pStack p)
    {
      return p->size;
    }
    
    int main()
    {
    	//定义栈
    	Stack s;
    	int i,s_size;
    	//先将s内存清空为0
    	memset(&s,0,sizeof(s));
    	//循环每次把i放入栈
    	while(scanf("%d",&i)!=EOF){
    	   //入栈:push()
    		push(&s,i);
    	}
    	//出栈:pop()
    	pop(&s);
    	//返回栈中元素个数:size()
    	s_size=size(&s);
    	printf("s_size=%d\n",s_size);
    	system("pause");
    }
    
    展开全文
  • cout输出栈顶元素"; cout结束程序"; cout; do { cout请输入选择的模式:"; cin>>k; switch(k) { case 1: cout请输入压入栈的姓名:"; cin>>e.name; SS.SqBTpush(e.name); break; case 2: e = SS....
  • 栈顶元素运算; 的判空判满运算:判断一个是空还是满; } 正在学c语言数据结构的同学最好不要照搬,通过注释自己摸索写出属于自己的代码才是最重要的。 话不多说,直接上代码: #include<stdio.h> #...
  • printf("请输入需要压入栈顶元素:"); scanf("%f",&e); if(S.top-S.base>=S.stacksize) { S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType)); } if(!S.base) { ...
  • #include #include #define STACK_INIT_SIZE 100 #define QUEUE_MAX_SIZE 100 #define STACK_INCREMENT 10 using namespace std; typedef struct Stack //结构体定义 { int *elem; //数据域 ... //顺序栈栈
  • 获取顺序栈顶元素

    千次阅读 2017-01-02 20:43:34
    获取顺序栈顶元素 GetTop (S,*e):若存在且非空,用e返回S的栈顶元素。参考之前线性表的话,就是设一个存储栈顶的变量 e,然后通过地址传递,用 *e 来保存指针为 top 的数组元素。 函数的设计如下:/* 若不...
  • 顺序有两种描述 typedef struct { ... //存放栈顶元素在数组中的下标 }SqStack; typedef struct{ ElemType *base; ElemType *top; int MaxSize; //当前已分配的空间 }SqStack; 今天拿出来的...
  • //定义元素的最大个数 //的结构类型 #define MaxSize 50 typedef struct { ElemType data[MaxSize];//存放元素 int top;//栈顶指针 }SqStack; //初始化 void InitStack(SqStack &S) { S.top=-1; ...
  • 假设S=(a1, a2, ….,a3),则称a1为栈底元素,an为栈顶元素元素按a1,a2,…,an的次序进栈,退的第一个元素应该为栈顶元素。换句话说,的修改是按照先进后出的原则进行的,因此,又称为
  • //栈底指针 ElemType *top; //栈顶指针 int stackSize; // 大小 int realSize; // 当前大小,可以不定义 }SqStack; /*********************************stack操作方法********************************...
  • 它类似于线性表的顺序存储结构,是利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素 通常用一维数组来实现的顺序存储,一般以数组小下标一端做栈底,每进栈一个元素,指针top+1,每出栈一个元素,top-...
  • :进栈,出栈,取栈顶元素,判断是否为空,置空栈,输出元素个数等 注:用switch进行选择操作。 //:进栈,出栈,取栈顶元素,判断是否为空,置空栈,输出元素个数等。 #include"stdio.h" #define maxsize 100...
  • 创建空的顺序的入栈、出栈、返回的长度、返回栈顶元素的遍历
  • 将编号为 0 和 1 的两个存放于一个数组空间 V[m]中,栈底分别处于数组的两端。当第0 号栈顶指针 top[0]等于-1 时该为空;当第 1 号栈顶指针 top[1]等于 m 时,该为空。两个两端向中间增长(见下...
  • 顺序的入栈出栈操作 #include <stdio.h> #include <stdlib.h> #include <malloc.h>...#define STACK_INIT_SIZE 100 //设元素有100个 ... // 栈底指针,若为空NULL则表示结构不存在
  • 顺序存储(进栈,出栈,获取栈顶元素的特点(LIFO)的基本操作代码实现测试结果 的特点(LIFO) ① 操作受限,只允许在一端进行插入,删除操作的线性表。 ② (LIFO)后进先出 的基本操作 //初始化空栈 ...
  • c语言中的栈顶元素为什么有时候用L->top,有时候用L.top这两个有什么区别,元素从栈底到栈顶输出的c语言代码怎么写,谢谢各位大神了
  • 用c++写的对的小程序,实现了堆栈,出栈,取栈顶元素的操作
  • 栈底 不允许操作的一端 入栈(push) 往中插入元素 出栈(pop) 删除元素 栈顶元素(peek) 返回栈顶元素(未出栈) 注:顺序–入出栈采用尾插入、删除,时间复杂度为O(1),自动...
  • 2.栈顶元素先出 3.新元素插入栈顶 的初始化: #include #include using namespace std; template //模板,表示可以"动态"定义Stack中某些数据元素的类型,这样的话可以增加代码的重用性 class Stack{ private: ...
  • 就像向箱子里堆东西一样,后放入的元素需要被先取出来。这篇文章,我将介绍链式的创建和基本操作。 ①链式的实现需要两个结构体:Stack和Node。 (1)Node结构体即为链表的结点,存放data和next指针。Node...
  • #include#include#define STACK_INIT_SIZE 100#define QUEUE_MAX_SIZE 100#define STACK_INCREMENT 10using namespace std;typedef struct Stack //结构体定义{int *elem;... //顺序栈栈顶int stacks...
  • 只把学习的代码与各位分享一下: 定义头文件LinkStack.h #ifndef LINKSTACK_H #define LINKSTACK_H //链式结点 typedef struct LINKNODE ...//链式 typedef struct LINKSTACK { LinkNode head; int size;...
  • class Stack(): #以顺序表形式实现 def __init__(self): self.__list = [] def push(self,item): #压栈 self.__list.append(item) def pop(self): #出栈 self.__list.pop() ... #弹出栈顶元素 if self

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,071
精华内容 20,828
关键字:

从栈底到栈顶输出元素