c语言数组实现栈（用C语言实现栈的基本操作（数制的转换））

本文目录

• 用C语言实现栈的基本操作（数制的转换）
• 用C语言实现栈的操作，包括创建空栈，PUSH，和POP用标准C，就是能在TC上运行的
• c语言编写，用数组表示栈，不用指针，编写gettop函数（取栈顶元素）
• 数据结构（C语言）两个栈共存储在一个长度为n的一维数组中
• C语言中如何用栈存储多个二维数组
• 建立顺序存储的栈，并对之进行入栈、出栈、取栈顶元素操作的c语言算法
• c语言写一个数组栈
• 数据结构定义一个栈并实现入栈和出栈操作的程序c语言完整版
• c语言 为什么栈的初始化时候栈顶指针要指向-1

用C语言实现栈的基本操作（数制的转换）

//顺序栈以及基本操作如下：

#include《iostream.h》
enum
{
MAX_SIZE=20
};
typedef struct
{
int* base;
int* top;
int stacksize;
}SqStack;
void InitStack(SqStack& S)
{
S.base=new int;
S.top=S.base;
S.stacksize=MAX_SIZE;
}
bool Push(SqStack& S,int e)
{
if(S.top-S.base》=S.stacksize)
return false;
*S.top=e;
S.top++;
return true;
}
bool Pop(SqStack& S,int& e)
{
if(S.top==S.base)
return false;
S.top--;
e=*S.top;
return true;
}
void DestroyStack(SqStack& S)
{
if(S.base)
delete S.base;
S.top=S.base=NULL;
S.stacksize=0;
}
bool StackEmpty(SqStack S)
{
return (S.top==S.base);
}
void Print(SqStack S)
{
int i=0;

while(i《S.top-S.base)
{

cout《《S.base《《endl;
}
}

用C语言实现栈的操作，包括创建空栈，PUSH，和POP用标准C，就是能在TC上运行的

#include 《stdio.h》
#include 《stdlib.h》
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
typedef char SElemtype;
typedef struct
{
SElemtype *base;
SElemtype *top;
int stacksize;
}SqStack;
int InitStack(SqStack &S);
int Push(SqStack &S, SElemtype e);
int GetTop(SqStack S, SElemtype &e);
int Pop(SqStack &S, SElemtype &e);
int main()
{
SElemtype e, f = 0, g = 0;
int c;
SqStack S;
if (!InitStack(S))
return 0;
printf("栈已初始化好,输入一个数据入栈.\n");
scanf("%c", &e);
if (!Push(S, e))
return 0;
if (!GetTop(S, f))
return 0;
printf("栈顶元素是:%c\n", f);
if (!Pop(S, g))
return 0;
printf("栈顶元素出栈,它是:%c\n", g);
scanf("%d", &c);
return 1;
}
int InitStack(SqStack &S)
{
S.base = (SElemtype *)malloc(STACK_INIT_SIZE * sizeof (SElemtype));
if (!S.base)
return 0;
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;
return 1;
}
int Push(SqStack &S, SElemtype e)
{
if (S.top - S.base == S.stacksize)
{
S.base = (SElemtype *)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof (SElemtype));
if (!S.base)
return 0;
S.top = S.base + S.stacksize;
S.stacksize += STACKINCREMENT;
}
*S.top++ = e;
return 1;
}
int GetTop(SqStack S, SElemtype &e)
{
if (S.top == S.base)
return 0;
e = *(S.top - 1);
return 1;
}
int Pop(SqStack &S, SElemtype &e)
{
if (S.top == S.base)
return 0;
e = *--S.top;
return 1;
}
我学这本书时写的，刚好给你。
针对补充问题：
&不是伪代码，是C++的传引用，你看的那本书上都是这样用的。
楼上的顺序栈实质就是一个数组。。
TC不能建C++项目吗？ 不能的话你还是装个VC吧，你若听了老师的话就应该知道在这里传引用是什么意思，且看下面：
int InitStack(SqStack &S);
int Push(SqStack &S, SElemtype e);
int GetTop(SqStack S, SElemtype &e);
int Pop(SqStack &S, SElemtype &e);
有没有发现GetTop()的参数没有使用&S,因为它对S只读，不改变S。
如果不使用传引用的话，那么InitStack(),Push()等将要返回一个S,若要保存还要把它赋给另一个SqStack类型的变量S1，这样做浪费时间还浪费空间，且之前的S也就没用了，如果反复地调用Push()的话，这样的浪费可想而知。
所以，为了节省时间跟空间，以及按大多数情况下的需要，我们还是得始终只用一个S保存我们要的数据。
至于传引用是什么意思，跟指针有点像，你若不想翻书就再补充问题吧。。

c语言编写，用数组表示栈，不用指针，编写gettop函数（取栈顶元素）

int top;//要求栈顶为全局变量
int gettop(int a)
{
int e;
if(top == -1)//top=-1视为栈空.视具体情况分析，也可以top==0
{
printf("栈空\n");
}

e=a;//取值
top--; //栈顶自减
return e;
}
-》是指针变量对结构成员的调用等同 点符号.

数据结构（C语言）两个栈共存储在一个长度为n的一维数组中

想法是stack1，stack2的base分别在数组的两端。
stack1每次push的时候top + 1，stack2每次push时top-1，
初始时top1=base1，top2=base2，判断是否用空余空间可以用stack1.top 》 stack2.top
pop操作相反，判断栈空可以用stack.base == stack.top

C语言中如何用栈存储多个二维数组

typedef struct{
int left_pos; //左边栈顶，靠0方向
int right_pos; //右边栈顶，靠MAXSIZE-1方向
int split_pos; //左右栈分割位置
int stack;
}DoubleStack;
初始的时候，为了能够高效方便的让2个栈进数据，建议把split_pos设置为MAXSIZE/2，也即中间，并初始化 left_pos，right_pos也为MAXSIZE/2；typedef struct{
int left_pos; //左边栈顶，靠0方向
int right_pos; //右边栈顶，靠MAXSIZE-1方向
int split_pos; //左右栈分割位置
int stack;
}DoubleStack;
初始的时候，为了能够高效方便的让2个栈进数据，建议把split_pos设置为MAXSIZE/2，也即中间，并初始化 left_pos，right_pos也为MAXSIZE/2；

建立顺序存储的栈，并对之进行入栈、出栈、取栈顶元素操作的c语言算法

#include "process.h"
#include "stdio.h"
#include "assert.h"
const int stackIncreament=20; //栈溢出时扩展空间的增量
class SeqStack
{
private:
int top; //栈顶指针
int MAX; //栈的最大可容纳个数
int *elements; //存放栈中元素的栈数组
void overflowProcess(); //栈的溢出处理
public:
SeqStack(int sz=50); //构造函数
~SeqStack() { deleteelements; } //析构函数
bool pop1(int & x); //元素出栈
void push1(const int & x); //新元素进栈
bool IsEmpty1()const; //判断栈空与否
bool IsFull1()const; //判断栈满与否
void output1(); //输出元素进栈顺序
void output(int x); //输出x
};
SeqStack::SeqStack(int sz):top(-1),MAX(sz)
{
elements=new int; //创建栈的数组空间
assert(elements!=NULL); //断言：动态存储分配成功与否
}
bool SeqStack::pop1(int & x) //栈顶元素出栈
{
if(IsEmpty1()==true) return false;//判栈空否，若栈空则函数返回
x=elements; //栈顶指针退1
return true; //退栈成功
}
void SeqStack::push1(const int & x) //新元素进栈
{
if(IsFull1()==true) overflowProcess(); //栈满则溢出处理
elements=x; //栈顶指针先加1,再进栈
}
bool SeqStack::IsEmpty1() const //判断栈空与否
{
return (top==-1)?true:false;
}
bool SeqStack::IsFull1()const //判断栈满与否
{
return (top==MAX-1)?true:false;
}
void SeqStack::overflowProcess() //栈的溢出处理
{
//私有函数，扩充栈的存储空间。
int *Array=new int; //和课本不一样 ??????????
if(Array==NULL)
{
printf("存贮分配失败 ! \n");
exit(1);
}
for(int i=0;i《=top;i++) Array;
MAX=MAX+stackIncreament;
delete elements;
//elements=Array;
}
void SeqStack::output1() //元素入栈顺序输出
{
int n=0;
int t=top;
for(int i=0;i《top;i++)
{
printf(" %d",elements);
n++;
if(n%10==0)
printf("\n");
}
}
void SeqStack::output(int x) //栈内元素输出
{
printf(" %d",x);
}
//----------------------顺序栈函数--------------------------//
void SeqStack1( SeqStack A)
{
int x=-1;
int X;
printf("请输入要入栈A的元素值,以0结束：\n");
while(x!=0){ //新元素进栈
scanf("%d",&x);
A.push1(x);
}
printf("\n元素进栈顺序是 :");
A.output1();
printf("\n\n");
A.pop1(X); //元素出栈
if(!A.pop1(X))
printf("元素出栈失败 ！\n");
else
{
printf("\n栈顶元素是： ");
A.output(X);
printf("\n");
printf("\n元素出栈的结果是 : ");
A.output(X);
while(A.pop1(X))
A.output(X);
}
}
void main()
{
printf("----------顺序栈的调试----------\n");
printf("\n \n");
SeqStack A;
SeqStack1(A);
printf("\n \n");
}

c语言写一个数组栈

#include 《stdio.h》
#include 《stdlib.h》
#define Size 20
typedef char ElementType;
typedef struct
{
    ElementType    data;
    int top;
}Stack;    
int  StackFull(Stack *s)
{
    return (s-》top==Size-1);
}
void PushStack(Stack *s, char *buf)
{
    if(NULL==s || NULL==buf)
        return;
    while( *buf!=’\0’ && *buf!=’^’ && !StackFull(s))
    {
        if(*buf != ’ ’)
            s-》data = *buf;
        ++buf;    
    }
}
void PopStack(Stack *s)
{
    if(NULL == s)
        return;
    while(s-》top != -1)
        putchar(s-》data);
}
int main()
{
    char str;
    Stack *s = (Stack*)malloc(sizeof(Stack));
    s-》top = -1;
    
    gets(str);
    PushStack(s, str);
    PopStack(s);
                  
    return 0;
}

数据结构定义一个栈并实现入栈和出栈操作的程序c语言完整版

如下：

#include "stdio.h"
struct stackNode{
  int data;
  struct stackNode *nextPtr;
};
typedef struct stackNode LISTSTACK;
typedef LISTSTACK *STACKNODEPTR;
void push(STACKNODEPTR *,int);
int pop(STACKNODEPTR *);
int isEmpty(STACKNODEPTR);
void printStack(STACKNODEPTR);
void instruct();
int main()
{
     int item;
     int choice;
     STACKNODEPTR sPtr=NULL;
     instruct();
     printf("choose your choice\n");
     scanf("%d",&choice);
     while(choice!=3)
     {
          switch(choice)
          {
               case 1:
               printf("please input an integer!\n");
               scanf("%d",&item);
               //printf("%d\n",item);
               push(&sPtr,item);
               printStack(sPtr);
               break;
               case 2:
               if(!isEmpty(sPtr))
               {
                    printf("deleting element of top stack\n");
                    pop(&sPtr);
                    printStack(sPtr);
               }
               else{
                    printf("no element in the stack\n");
               }
               break;
               default:
                    printf("invalid input,check your input!\n");
                    break;
          }
          printf("pleace choose your choice ");
          instruct();
          scanf("%d",&choice);
     }
}
void instruct()
{
     printf("Following the instruction below:\n"
            "1:insert new elment into the stack\n"
            "2:delete the top element of the stack\n"
            "3:to end of run\n");
}
int isEmpty(STACKNODEPTR sPtr)
{
     return sPtr==NULL;
}
void printStack(STACKNODEPTR sPtr)
{
     if(sPtr==NULL)
     {
          printf("The stack is empty!\n");
     }
     else{
          printf("The elements of the stack:\n");
          while(sPtr!=NULL)
          {
               printf("%d--》",sPtr-》data);
               sPtr=sPtr-》nextPtr;
          }
          printf("NULL\n\n");
     }
}
void push(STACKNODEPTR *topPtr,int value)
{
     STACKNODEPTR newPtr;
     newPtr=malloc(sizeof(STACKNODEPTR));
     if(newPtr!=NULL)
     {
          newPtr-》data=value;
          newPtr-》nextPtr=*topPtr;
          *topPtr=newPtr;
     }
     else
     {
          printf("%d is not inserted into stack.No memory is availiable\n");
     }
}
int pop(STACKNODEPTR *topPtr)
{
     STACKNODEPTR newPtr;
     int topValue;
     newPtr=*topPtr;
     *topPtr=(*topPtr)-》nextPtr;
     free(newPtr);
     topValue=(*topPtr)-》data;
     printf("deleting--- %d\n",topValue);
     return topValue;
}

数据结构：

是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。通常情况下，精心选择的数据结构可以带来更高的运行或者存储效率。数据结构往往同高效的检索算法和索引技术有关。

常用数据结构：

数组 (Array)、栈 (Stack)、队列 (Queue)、链表 (Linked List)、树 (Tree)、图 (Graph)、堆 (Heap)、散列表 (Hash)

c语言 为什么栈的初始化时候栈顶指针要指向-1

这种初始化是用于线性栈的，也就是用一个数组来组成栈，栈顶指针值为当前栈顶元素的下标值。
当有数据入栈时，会先执行栈顶指针自加。
初始化为空栈，
规定空栈的时候指向-1，这样在有第一个元素入栈的时候栈顶指针就可以通过自加指向0元素，从而避免其它判断。