精华内容
下载资源
问答
  • } //判断是否为空 int stack_empty(MYSTACK *pstack) { if(NULL == pstack) { puts("stack is not exist"); return -1; } if(pstack->count == 0) { return 1; } else { return 0; } } //满栈的时候 int stack_full...
    #ifndef __MYSTACK_H__
    #define __MYSTACK_H__
    
    //头文件
    
    	typedef int DATA_T;
    	typedef struct mystack
    	{
    		DATA_T *phead;
    		int size;int count;
    	}MYSTACK;
    	MYSTACK *create_stack(int size);
    	int destroy_stack(MYSTACK **ppstack);
    	int stack_empty(MYSTACK *pstack);
    	int stack_full(MYSTACK *pstack);
    	int mypush(MYSTACK *pstack,DATA_T nedata);
    	int mypop(MYSTACK *pstack,DATA_T *pdata);
    
    
    #endif
    #include "mystack.h"
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    MYSTACK *create_stack(int size)
    {
    	if(size < 0)
    	{
    		puts("size < 0 ");
    		return NULL;
    	}
    	MYSTACK *pstack = NULL;
    	pstack = (MYSTACK *)malloc(sizeof(MYSTACK));
    	if(NULL == pstack)
    	{
    		puts("malloc stack struct error");
    		return NULL;
    	}
    	pstack->phead = (DATA_T *)malloc(size *sizeof(DATA_T));
    	if (NULL == pstack->phead)
    	{
    		puts("malloc pstack->phead error");
    		free(pstack);
    		return NULL;
    	}
    	pstack->size = size;
    	pstack->count = 0;
    	return pstack;
    }
    
    int destroy_stack(MYSTACK **ppstack)
    {
    	if(NULL == ppstack)
    	{
    		puts("NULL pointer error");
    		return -1;
    	}
    	if(NULL != *ppstack)
    	{
    		return 0;
    	}
    	if(NULL !=(*ppstack)->phead)
    	{
    		free((*ppstack)->phead);
    	}
    	free(*ppstack);
    	*ppstack = NULL;
    	return 0;
    }
    //判断是否为空
    int stack_empty(MYSTACK *pstack)
    {
    	if(NULL == pstack)
    	{
    		puts("stack is not exist");
    		return -1;
    	}
    	if(pstack->count == 0)
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	}
    }
    //满栈的时候
    int stack_full(MYSTACK *pstack)
    {
    /*	if(NULL == pstack)
    	{
    		puts("stack is not exist");
    		return -1;
    	}*/
    	if(pstack->count == pstack->size)
    	{
    		return 1;
    	}
    	else 
    	{
    		return 0;
    	}
    }
    //压栈
    int mypush(MYSTACK *pstack,DATA_T newdata)
    {
    	if(NULL == pstack || pstack->phead)
    	{
    		puts("NULL pointer error");
    		return -1;
    	}
    	int ret = stack_full(pstack);
    	if(ret > 0)
    	{
    		puts("stack is full,cannot push");
    		return -1;
    	}
    	pstack->phead[pstack->count] = newdata;
    	pstack->count += 1;
    	return 0;
    }
    //出栈
    int mypop(MYSTACK *pstack,DATA_T *pdata)
    {
    	if(NULL == pstack || NULL == pstack->phead)
    	{
    		puts("NULL pointer error");
    		return -1;
    	}
    	int ret = stack_empty(pstack);
    	if(ret > 0)
    	{
    		puts("stack is empty,cannot pop");
    		return -1;
    	}
    	*pdata = pstack->phead[pstack->count - 1];
    	pstack->count -= 1;
    	return 0;
    }
    
    //实现栈的分装
    #include "mystack.h"
    #include <stdio.h>
    int main()
    {
    	MYSTACK *pstack =create_stack(100);
    	if(NULL == pstack)
    	{
    		puts("create_stack error");
    		return -1;
    	}
    	printf("pstack:%p\n",pstack);
    	printf("pstack->phead:%p\n",pstack->phead);
    	printf("pstack->size:%d\n",pstack->size);
    	printf("pstack->count:%d\n",pstack->count);
    	int ret = stack_empty(pstack);
    	if(ret > 0) 
    	{
    		puts("stack is empty");
    	}
    	int i = 2;
    	for(i;i<104;i++);
    	{
    		mypush(pstack,i);
    	}
    	i = 0;
    	for(i;i<104;i++)
    	{
    		DATA_T num;
    		int ret = mypop(pstack,&num);
    		if(ret == 0)
    		{
    			printf("%d->",num);
    		}
    	}
    	destroy_stack(&pstack);
    	return 0;
    }

    展开全文
  • 对于顺序栈,入栈时,首先判断栈是否,栈的条件为:p->top= =MAXNUM-1,栈时,不能入栈; 否则出现空间溢出,引起错误,这种现象称为上溢。 出栈和读栈顶元素操作,先判栈是否为空,为空时不能操作,否则...
  • 为当栈满时,再想入栈的话每次大小的增量,这里用10来代替。 create函数为创建函数。push为入栈函数。empty函数用来判断 栈是否为空,print函数用来出栈。 //以下为全部代码 #include "stdio.h" #include "mall....

    顺序栈,遵循先进后出后进先出原则。我在写的时候,宏定义的
    firstsize 为创建一个栈时这个栈的初始大小,这里为100。addsize
    为当栈满时,再想入栈的话每次栈大小的增量,这里用10来代替。
    create函数为创建栈函数。push为入栈函数。empty函数用来判断
    栈是否为空,print函数用来出栈。
    //以下为全部代码

    #include "stdio.h"
    #include "malloc.h"
    #define firstsize 100
    #define addsize 10
    typedef struct{
     int *base;
     int *top;
     int size;
    }Sq;
    
    void create(Sq &s)
    {
     s.base=(int*)malloc(firstsize*sizeof(int));
     if(s.base)printf("create OK!\n");
     s.top=s.base;
     s.size=firstsize;
    }
    
    void push(Sq &s,int e)
    {
     if(s.top-s.base>=s.size)
     {
     s.base=(int*)realloc(s.base,(s.size+addsize)*sizeof(int));
     printf("栈内空间分配成功\n");
     }
     *s.top=e;
     s.top++;
     printf("元素[%d]已入栈!\n",e);
    }
    
    void print(Sq &s)
    {
     if(empty(s))printf("抱歉,栈已满,无法出栈\n");
     else
     {
       s.top--;
       printf("出栈:[%d]\n",*s.top);
      }
    }
    
    int empty(Sq &s)
    {
     if(s.top==s.base||s.top<s.base)
     { printf("栈空\n");
     return 1;}
     else {printf("栈未空\n");
     return 0;}
    }
    
    void main()
    {
    int i; Sq s;
    do
    {
    printf("\n----------------\n1-");
    printf("创建一个栈\n2-判断栈是否为空\n3-入栈\n4-出栈\n0-退出");
    printf("\n----------------\n\n");
    scanf("%d",&i);
    switch(i)
    {
     case 1:create(s);break;
     case 2:empty(s);break;
     case 3:
     {
     int e;
     printf("输入入栈元素:\n");
     scanf("%d",&e);
     push(s,e);
     }break;
     case 4:print(s);break;
     case 0:break;
     default:
     {printf("输入错误,请重新输入\n");
     }continue;
     }
     }while(i!=0);
     printf("程序已退出\n");
    }
    
    
    

    运行结果:sxz

    展开全文
  • } //判空 int StackEmpty(SqStack S) { if(S.top==S.base||S.top { printf("为空\n"); return 1; } else { printf("不为空\n"); return 0; } } //求中元素个数 int StackLength(SqStack S) { return (S.top...

    #include<stdio.h>    //若用printf,scanf,getchar,putchar,gets,puts函数需包含该头文件
    #include<stdlib.h>
    #include<malloc.h>    //用malloc,free,realloc函数需包含该头文件
    #include<conio.h>    //若用getch()使得屏幕暂停,需包含该头文件
    #define OVERFLOW 0;
    #define STACK_INIT_SIZE 10
    #define STACKINCREMENT 10
    typedef int ElemType;
    typedef struct STACK
    {
        ElemType *base;
        ElemType *top;
        int stacksize;
    }SqStack;

    //函数声明
    //int InitStack(SqStack &S);
    //void ClearStack(SqStack &S);
    //int StackEmpty(SqStack S);
    //int StackLength(SqStack S);
    //int GetTop(SqStack S,ElemType &e);
    //int Push(SqStack &S,ElemType e);
    //int Pop(SqStack &S,ElemType &e);

    //初始化,创建空栈
    int InitStack(SqStack &S)
    {
        S.base=(ElemType*)malloc(STACK_INIT_SIZE *sizeof(ElemType));
        if(!S.base)    {
            return 0;
        }    
        S.top=S.base;
        S.stacksize=STACK_INIT_SIZE;
        return 1;     
    }

    //清空栈
    void ClearStack(SqStack &S)
    {
        if(S.base) 
            S.top = S.base;
    }

    //判栈空
    int StackEmpty(SqStack S)
    {
        if(S.top==S.base||S.top<S.base)
        {
            printf("栈为空\n");
            return 1;
        }
        else
        {
            printf("栈不为空\n");
            return 0;
        }
    }

    //求栈中元素个数
    int StackLength(SqStack S)
    {
        return (S.top-S.base);
    }

    //获取栈顶元素值
    int GetTop(SqStack S,ElemType &e)
    {
        if(S.top==S.base)
            return 0;
        e=*(--S.top);
        return 1;    
    }

    //入栈
    int Push(SqStack &S,ElemType e)
    {
        if(S.top-S.base>=S.stacksize)
        {
            S.base=(ElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(ElemType));
            if(!S.base) 
                return 0;
            S.top=S.base+S.stacksize;
            S.stacksize+=STACKINCREMENT;
        }
        *S.top++=e;
        return 1;
    }

    //出栈
    int Pop(SqStack &S,ElemType &e)

        if(S.top==S.base)
            return 0;
        e=*(--S.top);
        return 1;
    }

    //打印栈中元素
    void PrintElem(SqStack S)
    {
        ElemType *p = S.base;
        while(p<S.top)
        {
            printf("%d\n",*p);
            p++;
        }
    }

    //数制转换函数
    void conversion()
    {
        SqStack S;
        int n;
        printf("请输入要进行数制转换的数:\n");
        scanf("%d",&n);
        int m;
        printf("请输入要进行转换的进制:\n");
        scanf("%d",&m);
        InitStack(S);
        int e;
        while(n)
        {
            Push(S,n%m);
            n=n/m;
        }
        while(Pop(S,e)){
            printf("%d",e);
        }
    }

    //主函数
    void main()
    {
        ElemType e;
        SqStack S;
        printf("1.初始化栈\n");
        InitStack(S);
        printf("现在栈为空.\n");
        printf("请输入第一个要入栈的元素值:");
        scanf("%d",&e);
        Push(S,e);
        printf("现在栈中有一个元素:\n");
        PrintElem(S);
        printf("请输入第二个要入栈的元素值:");
        scanf("%d",&e);
        Push(S,e);
        printf("现在栈中有两个元素:\n");    
        PrintElem(S);
        getch();
        int n;
        printf("请输入还要入栈的元素的个数:");
        scanf("%d",&n);

        for(int i=1; i<=n; i++)
        {
            printf("请输入第%d个元素:",i+2);
            scanf("%d",&e);
            Push(S,e);
        }
        printf("现在栈中元素有:%d个\n",StackLength(S));
        printf("现在栈中元素为:\n");    
        PrintElem(S);
        getch();
        printf("2.现在出栈\n出栈前栈顶元素为:");    
        Pop(S,e);
        printf("%d\n",e);
        GetTop(S,e);
        printf("出栈后新的栈顶元素为:%d\n",e);
        printf("栈中剩余元素有:\n");
        PrintElem(S);
        printf("现在栈中元素个数为:%d\n",StackLength(S));
            getch();
        printf("\n3.数制转换\n");
        conversion();
        getch();
    }
     

    写的比较简陋、毕竟是给自己看的   有些地方可能不对、希望有发现的好人们 能不吝指出  我只个小菜鸡

    展开全文
  • 系列文章目录 ...使用栈判断一个字符串是否回文 二、c++代码 1.顺序 代码如下: #include<iostream> using namespace std; #define MaxSize 100 typedef char datatype; typedef struct {

    系列文章目录

    前言

    《数据结构基础》c语言版 第2版,Ellis Horowitz著,朱仲涛译
    4.3节,page124,习题1

    一、题目描述

    使用栈判断一个字符串是否回文

    二、c++代码

    1.顺序栈

    代码如下:

    #include<iostream>
    using namespace std;
    
    #define MaxSize 100
    typedef char datatype;
    typedef struct
    {
        datatype data[MaxSize];
        int top;
    }seq_stack;
    
    void InitStack(seq_stack *&s)
    {
        s = (seq_stack*)malloc(sizeof(seq_stack));
        s->top = -1;
    }  //初始化栈
    void DestroyStack(seq_stack *s)
    {
        free(s);
    }  //释放栈空间
    bool StackEmpty(seq_stack *s)
    {
        if(s->top == -1)
            return true;
        else
            return false;
    }   //判断栈是否为空,本程序中未用到
    void Push(seq_stack *s,datatype e)
    {
        if (s->top==MaxSize-1)    //栈满的情况,即栈上溢出
            printf("栈满!\n");
        else{
            s->top ++;
            s->data[s->top] = e;
        }
    }   //入栈
    datatype Pop(seq_stack *s)
    {
        if (s->top==-1)		//栈为空的情况,即栈下溢出
        {
            printf("栈空!\n");
            return '\0';
        } else{
            return s->data[s->top--];
        }
    }  //出栈
    datatype GetTop(seq_stack *s)
    {
        if (s->top==-1) 		//栈为空的情况,即栈下溢出
        {
            printf("栈空!\n");
            return '\0';
        } else{
            return s->data[s->top];
        }
    }  //获取栈顶元素
    
    //判断是否回文
    bool is_palindrome(char const *c)
    {
        datatype e;
        seq_stack *s;
        InitStack(s);
        for(int i=0;c[i]!='\0';i++)
            Push(s,c[i]);
        for(int i=0;c[i]!='\0';i++)
        {
            e = Pop(s);
            if(e!=c[i])
            {
                DestroyStack(s);	//销毁栈
                return false;
            }
        }
        DestroyStack(s);
        return true;
    }
    int main()
    {
        char const *c="abcba";
        if(is_palindrome(c))
            printf("%s 该字符串是回文串!\n",c);
        else
            printf("%s 该字符串不是回文串!\n",c);
        return 0;
    }
    

    2.链表栈

    代码如下:

    #include<iostream>
    using namespace std;
    
    #define MaxSize 100
    typedef char datatype;
    typedef struct link_stack
    {
        datatype data;
        struct link_stack *link;
    }link_stack;
    
    void InitStack(link_stack *&s)
    {
        s = (link_stack*)malloc(sizeof(link_stack));
        if(!s)
            exit(-1);
        s->link = NULL;
    }  //初始化栈
    void clear_stack(link_stack *s)
    {
        link_stack *p = s->link;
        link_stack *r;
        s->link = NULL;
        while (p!=NULL)
        {
            r = p;
            p = p->link;
            free(r);
        }
    }  //清空链栈
    bool StackEmpty(link_stack *s)
    {
        if(s->link == NULL)
            return true;
        else
            return false;
    }   //判断链栈是否为空,本程序中未用到
    int stack_len(link_stack *s)
    {
        int len = 0;
        link_stack *temp = s->link;
        while (temp!=NULL)
        {
            len++;
            temp = temp->link;
        }
        return len;
    }  //获取链栈的长度
    datatype GetTop(link_stack *s)
    {
        link_stack *temp = s;
        if(temp->link == NULL)
            return '\0';
        return temp->link->data;
    }  //获取栈顶元素
    void Push(link_stack *s,datatype e)
    {
        link_stack *temp = new link_stack;
        temp->data = e;
        temp->link = s->link;
        s->link = temp;
    }   //入栈
    datatype Pop(link_stack *s)
    {
        if(s->link == NULL)
            return '\0';
        datatype e = s->link->data;
        link_stack *temp = s->link;
        s->link = temp->link;
        free(temp);
        return e;
    }  //出栈
    
    //判断是否回文
    bool is_palindrome(char const *c)
    {
        datatype e;
        link_stack *s;
        InitStack(s);
        for(int i=0;c[i]!='\0';i++)
            Push(s,c[i]);
        for(int i=0;c[i]!='\0';i++)
        {
            e = Pop(s);
            if(e!=c[i])
            {
                return false;
            }
        }
        return true;
    }
    int main()
    {
        char const *c="abcba";
        if(is_palindrome(c))
            printf("%s 该字符串是回文串!\n",c);
        else
            printf("%s 该字符串不是回文串!\n",c);
        return 0;
    }
    

    总结

    添加链接描述
    添加链接描述

    展开全文
  • 栈的顺序存储的初始化、判断栈空、入栈、出栈、读取栈顶元素、栈置空、求栈长操作 代码如下: //栈的顺序存储表示 #include #include #include #define MAXSIZE 100 typedef int ElemType; typedef struct Node...
  • 《数据结构与算法Python语言描述》裘宗燕 笔记系列 该系列笔记结合PPT的内容整理...和队列 - 和队列的概念 - 数据的生成,缓存,使用和顺序 - 的实现和问题 - Python 的实现 - 队列的实现和问题 - Py...
  • C语言 的基本操作-【栈顶、底 双指针】【初始化、出栈、入栈、栈是否为空】
  • 数据结构——

    2021-07-29 19:47:08
    数据结构——栈栈1.的概念:2.的基本运算:3.基本操作的代码:的顺序存储结构顺序基本操作置空栈判空栈入栈出栈取栈顶元素注意事项多共享邻接空间共享的基本操作 1.的概念: 作为一种数据结构,...
  • 栈未满,则进行入栈操作,即车辆进入停车场;如果栈已满,则不能进行入栈操作,车辆进不了停车场 ,车辆必须进入便道等待。 a. 当某辆车要离开时,比它后进入的车要先退出,暂时离开停车位。 b.使用一个队列来...
  • 文章目录双向顺序栈双向栈在一维数组中的实现栈的结构体定义识别左右栈判断栈满共享栈的基本操作:初始化共享栈的基本操作:入栈共享栈的基本操作:出栈链栈的实现链栈的基本操作接口链栈的基本操作初始化入栈出栈取...
  • 这几天在看一些数据结构方面的书,自己总结了一下的实现方式,通过解决了回文的判断,如果有错的话大家在评论里指出来。 public class WStack<T> { //储存数据的数组 private T[] StoreArray; //当前...
  • 在之前讲解了线性表的链式存储、顺序存储以及静态链表,循环链表和双向链表我们只需了解即可,接下来我们讲解线性表的应用“ 是限定仅在表尾进行插入和删除操作的线性表 我们吧允许插入和删除的一端称为...
  • 结构之顺序详解(C语言版)

    千次阅读 2020-10-24 16:40:35
    本文对结构的顺序进行详解并使用C语言对顺序进行实现,文章的主要内容包括顺序的定义、顺序的结构以及顺序的常用操作
  • C语言实现顺序.c

    2020-06-22 23:40:54
    C语言实现顺序栈 顺序栈的常规操作 ... // 判断栈满 int StackEmpty(); // 判断栈空 int StackLength(); // 求栈长(栈元素个数) int Push(); // 入栈 压栈 ElemType Pop(); // 出栈 弹栈
  • 2018-04-07 11:18:06
    简单_使用数组 #include&lt;iostream&gt; #define MAX 5 using namespace std; typedef int elemType; struct seqStack { elemType elem[MAX]; int top; }; //初始化顺序 void initStack(seqStack...
  • //判断栈空 bool StackEmpty(SqStack s){ if(S.top == -1) //栈空 return true; else //不空 return false; } (三)、共享栈 定义:两个栈共享同一片空间。 栈的条件:top0 + 1 == top1 #define ...
  • 【数据结构】两共享空间的进一步理解

    千次阅读 多人点赞 2019-01-03 23:03:55
    栈满条件的理解: 总结  前言 在阅读《大话数据结构》时,对文中“两共享空间”中部分知识点存在困惑,多读了几遍后,将其中的疑惑进行梳理一下。 (关于书中“两共享空间”的知识点,大家可以看一下我...
  • 数据结构——的详解

    万次阅读 多人点赞 2020-04-20 00:02:43
    和队列是两种重要的线性结构,从数据结构的角度看,和...C语言和C++中的C语言中的栈栈的定义C语言中的基本操作的初始化判断是否为空栈判断是否满栈入栈出栈C语言实现的具体代码C++中的C++中的基...
  • 数据结构 主讲人章万静 未满 已满 开始 结束 栈是否已满 求栈顶元素下标top 定义变量 不能进栈 进栈操作 顺序进栈 顺序进栈 顺序进栈操作之前必须判断堆栈是否为满 为满则不能进栈非满则可以进栈 谢谢观看
  • Java实现数据结构基本算法——(第三章)一、的定义二、交换排序——冒泡排序1. 基本思想:2. 排序过程:3. 代码实现:4. 运行结果:三、交换排序——快速排序1. 基本思想:2. 排序过程:3. 代码实现:4. 运行...
  • 1. 1.1的概述 1.2的几个概念 1.3的特点 1.4的例题 1.5基本功能 1.6的分类 2.队列 2.1队列概述 2.2队列几个概念 2.3队列特点 2.4队列基本功能 2.5队列的分类 2.6链队基本功能实现头文件......
  • 一、: 只能在一端插入或删除的线性表,允许插入和删除操作的一端称为栈顶(top),底固定不变。 的操作: 入栈、出栈。 的特点: 先进后出,就像车队进入死胡同,只能后车先出。 的本质: ...
  • 如何自己实现一个

    千次阅读 2019-03-18 00:01:00
    前言 栈是一种应用广泛的数据结构,例如函数的调用就需要使用栈,其实我们在介绍《快速排序优化详解》的时候也使用到了栈结构。...入栈(PUSH),将一个元素压入栈中,访问栈顶元素(TOP),判断栈是否为空等。 栈的...
  • 的基本操作

    2018-08-28 21:54:11
    首先判断栈中元素是否已满,若满了直接返回 若未满将元素插入栈顶 void StackPush ( Stack *ps, SDataType data ) { assert(ps); if ( MAXSIZE == ps->_top) { printf( "栈空间已满,无法...
  • 数据结构:和队列(Stack & Queue)【详解】

    万次阅读 多人点赞 2021-02-18 19:52:33
    和队列知识框架 一、的基本概念 1、的定义 (Stack):是只允许在一端进行插入或删除的线性表。首先是一种线性表,但限定这种线性表只能在某一端进行插入和删除操作。 栈顶(Top):线性表允许进行...
  • 概要 因为操作的需要现在重新学习了...的存储结构:顺序和链式,实际上的本质是线性表,不过是加了操作限制 2.队列的基本概念 队列的定义:和类似都是操作受限制的线性表,只允许在一端进行插入(队尾:rea
  • 数据结构

    2021-09-06 11:13:22
    1 的定义:只允许一端进行插入或删除操作的线性表。是一种线性表。但是限定这种线性表只能在某一端进行插入和删除操作。...StackEmpty(S): 判断一个栈是否为空,若S为空返回True,否则返回false ...
  • ✍、王道数据结构与算法(三)
  • 一、(后进先出,LIFO表) 定义:限定仅在表尾进行插入或删除操作的线性表。表尾为栈顶,表头为底,不含元素的空表称为空栈。 最先放入中元素在底,最后放入的元素在栈顶;而删除元素刚好相反,最后放入的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 28,735
精华内容 11,494
关键字:

判断栈是否为满