精华内容
下载资源
问答
  • 实现顺序栈的初始化、入栈和出栈操作

    万次阅读 多人点赞 2018-05-04 09:49:59
    编写一个程序实现顺序栈的初始化、入栈和出栈操作; //方案1 # include<stdlib.h> #include<iostream> using namespace std; # define ...

    编写一个程序实现顺序栈的初始化、入栈和出栈操作;

    //方案1
    # include<stdlib.h>
    #include<iostream>
    using namespace std;
    # define STACK_INIT_SIZE 20
    # define stackincrement 20/*不是动态分配存储空间,所以需要定义一个增量*/
    typedef int SElemType;
    typedef bool Status;
    typedef struct
    {
        SElemType *base;//栈底指针,栈构造之前和销毁之后,其值为NULL
        SElemType *top;//栈顶指针
        int stacksize;//当前已经分配的存储空间,以元素为单位
    }SqStack;
    void print(SElemType c)
    {
        printf("%d ",c);
    }
        //构造一个空栈S
    Status InitStack(SqStack &S)
    {
        S.base = new SElemType[STACK_INIT_SIZE];
        if(!S.base) cout << "分配内存失败" << endl;
        
        S.top = S.base;
        S.stacksize = STACK_INIT_SIZE;
        return true;
    }
        //将元素e插入栈顶
    Status Push(SqStack &S,SElemType e)
    {
        if (S.top-S.base >= S.stacksize)//栈满,利用realloc增加存储空间每次增加stackincrement个int类型空间
        {
            S.base = (SElemType *)realloc(S.base,((S.stacksize+stackincrement)*sizeof(SElemType)));
            if (!S.base)
            {
                exit (-1);
            }
            S.top = S.base + S.stacksize;
            S.stacksize = S.stacksize + stackincrement;
        }
        *S.top++ = e;
        return true;
    }
        //从栈底到栈顶依次对栈中每个元素调用函数visit
    void StackTraverse(SqStack S,void (* visit)(SElemType))
    {
        while (S.top > S.base)
        {
            visit(*(S.base)++);
        }
        cout << endl;
    }
    int main(void)
    {
        int j;
        SqStack s;
        InitStack(s);
        cout << "初始化后栈s的空间为:" << s.stacksize << endl;
        for (j=1; j<=20; ++j)
        {
            Push(s,j);
        }
        cout << "操作完后,栈s的空间为:" << s.stacksize <<endl;
        cout << "栈中的元素为:" << endl;
        StackTraverse(s,print);
        return 0;
    }
    
    
    
    //方案2
    # include<stdlib.h>
    #include<iostream>
    using namespace std;
    # define STACK_INIT_SIZE 20
    # define stackincrement 20/*不是动态分配存储空间,所以需要定义一个增量*/
    typedef int SElemType;
    typedef struct
    {
        SElemType *base;//栈底指针,栈构造之前和销毁之后,其值为NULL
        SElemType *top;//栈顶指针
        int stacksize;//当前已经分配的存储空间,以元素为单位
    }SqStack;
    void print(SElemType c)
    {
        cout << c << " ";
    }
        //构造一个空栈S
    void InitStack(SqStack * S)
    {
        if (! ((* S).base = (SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))//一次分配20个int类型的空间
        {
            exit(-1);
        }
        (* S).top = (* S).base;
        (* S).stacksize = STACK_INIT_SIZE;
    }
        //将元素e插入栈顶
    void Push(SqStack * S,SElemType e)
    {
        if ((* S).top-(* S).base >= (* S).stacksize)//栈满,利用realloc增加存储空间每次增加stackincrement个int类型空间
        {
            (* S).base = (SElemType *)realloc((* S).base,((* S).stacksize+stackincrement)*sizeof(SElemType));
            if (!(* S).base)
            {
                exit (-1);
            }
            (* S).top = (* S).base + (* S).stacksize;
            (* S).stacksize = (* S).stacksize + stackincrement;
        }
        *((* S).top)++ = e;
    }
        //从栈底到栈顶依次对栈中每个元素调用函数visit
    void StackTraverse(SqStack S,void (* visit)(SElemType))
    {
        while (S.top > S.base)
        {
            visit(*(S.base)++);
        }
        cout << endl;
    }
    int main(void)
    {
        int j;
        SqStack s;
        InitStack(&s);
        cout << "初始化后栈s的空间为:" << s.stacksize << endl;
        for (j=1; j<=20; ++j)
        {
            Push(&s,j);
        }
        cout << "操作完后,栈s的空间为:" << s.stacksize <<endl;
        cout << "栈中的元素为:" << endl;
        StackTraverse(s,print);
        return 0;
    }
    
    展开全文
  • #include <iostream>...//栈的链式存储类型 typedef struct Linknode { ElemType data; struct Linknode *next; }*LiStack; //初始化 void InitStack(LiStack &L) { L=NULL;//初始化一个.
    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    typedef int ElemType;//链栈的结点类型
    //栈的链式存储类型
    typedef struct Linknode
    {
        ElemType data;
        struct Linknode *next;
    }*LiStack;
    //初始化
    void InitStack(LiStack &L)
    {
        L=NULL;//初始化一个空栈
    }
    //元素进栈
    bool push(LiStack &L, ElemType e)
    {
        Linknode *s=(Linknode *)malloc(sizeof(Linknode));//为新元素分配内存空间
        if(s==NULL)
            return false;//内存空间分配失败,返回false
        s->data=e;
        s->next=L;//将元素插在栈顶
        L=s;//改变栈顶指针
        return true;
    }
    //元素出栈
    bool pop(LiStack &L, ElemType &e)
    {
        if(L==NULL)
            return false;//栈空则失败
        e=L->data;
        cout<<"栈顶元素"<<e<<"出栈!"<<endl;
        Linknode *s=L;//用指针s指向要删除的栈顶元素
        L=L->next;//改变栈顶指针
        free(s);//释放s指向的元素
        return true;
    }
    //取栈顶元素
    void GetElem(LiStack L)
    {
        if(L==NULL)
            cout<<"栈空"<<endl;
        else
            cout<<"栈顶元素为: "<<L->data<<endl;
    
    }
    //打印栈中元素
    void printList(LiStack L)
    {
        if(L==NULL)
            return;
        else
        {
            cout<<"当前栈中的元素为: ";
            while(L)
                {
                    cout<<L->data<<" ";
                    L=L->next;
                }
            return;
        }
    
    
    }
    bool StackEmpty(LiStack L)
    {
        if(L==NULL)
        {
            cout<<"当前栈空"<<endl;
            return true;
        }
        else
            return false;
    }
    int main()
    {
        int e;
        LiStack L;
        InitStack(L);
        StackEmpty(L);
        cout<<"元素进栈......"<<endl;
        push(L,1);
        push(L,2);
        push(L,3);
        push(L,4);
        printList(L);
        GetElem(L);
        pop(L,e);
        GetElem(L);
        printList(L);
        return 0;
    }
    

    展开全文
  • /顺序栈的实现/ /***顺序栈的实现***/ #include<iostream> #include<fstream> using namespace std; //顺序栈定义 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define MAXSIZE 100//顺序栈...

    /顺序栈的实现/

    /***顺序栈的实现***/
    
    #include<iostream>
    #include<fstream>
    using namespace std;
    
    //顺序栈定义
    #define OK 1
    #define ERROR 0
    #define OVERFLOW -2
    #define MAXSIZE  100//顺序栈存储空间的初始分配量
    typedef int Status;
    typedef char SElemType;
    
    typedef struct {
    	SElemType *base;//栈底指针
    	SElemType *top;//栈顶指针
    	int stacksize;//栈可用的最大容量
    } SqStack;
    
    //算法3.1 顺序栈的初始化
    Status InitStack(SqStack &S) {
    	//构造一个空栈S
    	S.base = new SElemType[MAXSIZE];//为顺序栈动态分配一个最大容量为MAXSIZE的数组空间
    	if (!S.base)
    		exit(OVERFLOW); //存储分配失败
    	S.top = S.base; //top初始为base,空栈
    	S.stacksize = MAXSIZE; //stacksize置为栈的最大容量MAXSIZE
    	return OK;
    }
    //算法3.2 顺序栈的入栈
    Status Push(SqStack &S, SElemType e) {
    	// 插入元素e为新的栈顶元素
    	if (S.top - S.base == S.stacksize)
    		return ERROR; //栈满
    	*(S.top++) = e; //元素e压入栈顶,栈顶指针加1
    	return OK;
    }
    //算法3.3 顺序栈的出栈
    Status Pop(SqStack &S, SElemType &e) {
    	//删除S的栈顶元素,用e返回其值	
    	if (S.base == S.top)
    		return ERROR;//栈空
    	e = *(--S.top); //栈顶指针减1,将栈顶元素赋给e
    	return OK;
    }
    //算法3.4 取顺序栈的栈顶元素
    char GetTop(SqStack S) {//返回S的栈顶元素,不修改栈顶指针
    	if (S.top != S.base) //栈非空
    		return *(S.top - 1); //返回栈顶元素的值,栈顶指针不变
    }
    
    int main() {
    	SqStack s;
    	int choose, flag = 0;
    	SElemType j, e, t;
    	cout << "1.初始化\n";
    	cout << "2.入栈\n";
    	cout << "3.读栈顶元素\n";
    	cout << "4.出栈\n";
    	cout << "0.退出\n\n";
    
    	choose = -1;
    	while (choose != 0) {
    		cout << "请选择:";
    		cin >> choose;
    		switch (choose) {
    		case 1://算法3.1 顺序栈的初始化
    			if (InitStack(s)) {
    				flag = 1;
    				cout << "成功对栈进行初始化\n\n";
    			} else
    				cout << "初始化栈失败\n\n";
    			break;
    		case 2: {//算法3.2 顺序栈的入栈
    			fstream file;
    			file.open("SqStack.txt");//
    			if (!file) {
    				cout << "错误!未找到文件!\n\n" << endl;
    				exit(ERROR);
    			}
    			if (flag) {
    				flag = 1;
    				cout << "进栈元素依次为:\n";
    				while (!file.eof()) {
    					file >> j;
    					if (file.fail())
    						break;
    					else {
    						Push(s, j);
    						cout << j << "  ";
    					}
    				}
    				cout << endl << endl;
    			} else
    				cout << "栈未建立,请重新选择\n\n";
    			file.close();
    		}
    			break;
    		case 3://算法3.3 顺序栈的出栈
    			if(flag != -1 && flag != 0)
    				cout << "栈顶元素为:\n" << GetTop(s) << endl << endl;
    			else
    				cout << "栈中无元素,请重新选择\n" << endl;
    			break;
    		case 4://算法3.4 取顺序栈的栈顶元素
    			cout << "依次弹出的栈顶元素为:\n";
    			while (Pop(s, t)){
    				flag = -1;
    				cout << t << "  ";
    			}
    			cout << endl << endl;
    			break;
    		}
    	}
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述
    file.open(“SqStack.txt”);//读取打开SqStack.txt文件
    方法:
    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 用链表实现栈的初始化、入栈、出栈、删除和销毁、 #include&amp;amp;lt;stdio.h&amp;amp;gt; #include&amp;amp;lt;stdlib.h&amp;amp;gt; #include&amp;amp;lt;malloc.h&amp;amp;gt; ...

    用链表实现栈的基本功能

    用链表实现栈的初始化、入栈、出栈、删除和销毁、

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    
    typedef int SElemType;
    typedef int Status;
    #define Ok 1;
    #define Error 0;
    #define Ture 1;
    #define False 0;
    typedef struct StackNode{
        SElemType data;
        struct StackNode *next;
    }StackNode, *LinkStack;
    
    Status InitStack(LinkStack &s)//初始化栈
    {
        s=NULL;
        return Ok;
    }
    
    Status Push(LinkStack &s,SElemType e)//入栈
    {
        StackNode *p;
        p=new StackNode;
        p->data=e;
        p->next=s;
        s=p;
        return Ok;
    }
    
    Status Pop(LinkStack &s,SElemType &e)//出栈
    {
        StackNode *p;
        if(s==NULL) return Error;
        e=s->data;
        p=s;
        s=s->next;
        delete p;
        return Ok;
    }
    
    SElemType GetTop(LinkStack s)//取栈顶元素
    {
        if(s!=NULL)
            return s->data;
    }
    
    Status ClearStack(LinkStack &s)//清空栈
    {
        StackNode *p;
        p=s;
        while(s!=NULL)
        {
        p=s;
        s=s->next;
        delete p;
        }
    }
    
    Status StackDestroy(LinkStack s)//销毁栈
    {
        StackNode *p,*q;
        p=s;
        if(p==NULL)
            free(p);
        else
        {
        while(!p)
        {
        q=p;
        p=p->next;
        free(q);
        }
        }
        return Ok;
    }
    
    Status StackTraverse(LinkStack s)
    {
        if(s==NULL)
            printf("当前为空栈\n");
        else
        {
            StackNode *p;
            p=s;
            printf("顶-->");
            while(p->next!=NULL)
            {
                printf("%d",p->data);
                p=p->next;
            }
            printf("%d",p->data); 
            printf("-->底");
        }
    
    }
    
    int main(){
        LinkStack s;
        SElemType e;
        int i,j;
        printf("1.创建 2.入栈 3.出栈 4.清空 5.销毁 0.退出\n");
        while(i!=EOF){
        scanf("%d",&i);
        switch(i){
        case(1):
        InitStack(s);
        printf("建栈成功\n");
        break;
        case(2):
        int n;
        printf("请输入进栈的个数\n");
        scanf("%d",&n);
         printf("输入进栈元素\n");
        while(n--){
            int m;
            scanf("%d",&m);
            Push(s,m);
        }
        StackTraverse(s);
        puts("");
        break;
        case(3):
            Pop(s,e);
            printf("出栈元素是%d\n",e);
            StackTraverse(s);
            break;
        case(4):
            ClearStack(s);
            if(s==NULL)
               {
                printf("清空成功\n");
                StackTraverse(s);
                }
            else
                printf("清空失败\n");
            break;
        case(5):
            StackDestroy(s);
            printf("销毁成功\n");
        case(0):
            exit(0);
            break;
        }
        }
    return 0;
    }
    
    
    展开全文
  • 栈的定义: 栈是一种特殊的线性表,其只允许在固定的一端进行插入和删除...而栈的实现一般可以使用数组或者链表实现,相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。 下面是定长的静态栈...
  • 定义 /** * className:Statck * * @author:zjl * @version:0.1 * @date:2020/7/1512:22 * @since:jdk1.8 */ public class Statck { private int maxSize;//最大容量 private int top;//栈顶指针(始终...
  • 栈的特点:后进先出一、顺序栈如果在顺序表的头部入栈,则需要将原有站内的元素依次后移,时间复杂度On,所以可以采用尾部入栈,入栈时只需要把size下标设置为指定元素,出栈时直接删除下标为size-1就行,stack.h ...
  • 数据结构之C语言实现栈的初始化、入栈、出栈、查看栈顶、查看栈大小、判空等基础操作。 #define _CRT_SECURE_NO_WARNINGS 1 #include &lt;assert.h&gt; #include &lt;stdio.h&gt; #include &...
  • 有趣的数据结构算法8——栈的初始化、入栈与出栈什么是栈栈的初始化入栈出栈实现代码GITHUB下载连接 新的结构又要出现了。我心里有点害怕,但是! 什么是栈 栈(stack)又名堆栈,它是一种运算受限的线性表。它的...
  • cout请输入数字选择您要线性存储结构:"、顺序结构,1、链式结构,2.顺序队列,3、链式队列" ; int a; cin>>a; cout请输入数列"; switch(a) { case 0:InitStack(l1); for(int i=0;i;i++) {cin>>e;...
  • /*顺序表实现栈的一系列操作*/ #include<stdio.h> #include<stdlib.h> #define Stack_Size 50 //设栈中元素个数为50 #define OK 1 #define ERROR 0 typedef struct ...
  • 用C语言实现非循环单链表创建和遍历等各种功能
  • 用结构实现栈,函数压栈,弹初始化,释放 #include using namespace std; struct stack { int *data; //数据存储,后面 把一维数组地址给了data int memnum; //元素个数 int size; //大小 ...
  • _rt_thread_init() 函数会调用栈初始化函数 rt_hw_stack_init(),在栈初始化函数里会手动构造一个 上下文内容,这个上下文内容将被作为每个线程第一次执行的初始值。上下文在里的排布如下图所示: 下代码是栈初始...
  • //初始化链栈 void initStack(Lnode *ln){ ln=(Lnode *)malloc(sizeof(Lnode)); if(ln == NULL){ printf("error"); } ln->next=NULL; } //判断链栈是否为空 int StackEmpty(Lnode *ln){ return (ln-...
  • 链式栈的初始化、进栈、出栈、取栈顶 // stcuct node { datatype data; struct node *next; } typedef struct { struct node *top; int size; }linkstack; static linkstack *init_stack() { linkstack *...
  • //此代码只实现十进制转换为二进制 #include&lt;stdio.h&gt; #include&lt;math.h&gt; #include&lt;stdlib.h&gt; #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 typedef...
  • 下面介绍采用顺序结构存储的栈的相关基本操作,用一个int top 来作为栈顶的指针,指明当前栈顶的位置,空栈时s -&gt; top = -1,入栈时s -&gt;top ++;出栈时s -&gt; top --;将data和top封装在一个...
  • BLE协议栈的初始化实现了三个部分的功能:初始化时钟,协议栈使能,回调派发函数使能。 1.初始化时钟 BLE协议栈时钟有一下三个选项,功耗由低至高排序: #define NRF_CLOCK_LF_SRC_XTAL (1) /**< LFCLK crystal ...
  • 实现顺序,并利用该完成进制转换
  • C语言实现栈的初始化、出入、销毁、清空等基本操作引言代码运行结果 引言 简单记录一下新学知识,直接上代码。 代码 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MAX ...
  • #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define maxsize 100 typedef struct SqStack{ int data[maxsize];... void SqStackEmpty(SqStack *st)//判断是否为空{ st-&gt;to...
  • int InitStack (SqStack &S){ //0栈的初始化  S.base=(int *)malloc (STACK_INIT_SIZE *sizeof(int));  if (! S.base) exit (OVERFLOW);  S.top=S.base;   S.stacksize=STACK_INIT_SIZE;//栈的空间...
  • 结构体指针要想直接对结构体内成员进行赋值,必须: 1、依附于一个结构体实体,例如: Element *a; a->data=123; 这样编译没问题,运行时有问题; 可以这样,Element b; a=&b; a->data=123; 2、或者, 给...

空空如也

空空如也

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

栈的初始化实现