求一个栈的C语言实现代码

[wilfred]

编程一直就是弱项 这次开了C语言课 实在是有些云里雾里
马上要交作业了 请大家帮这次忙 谢谢


要求用C语言模拟推栈的管理 要求有四个函数 分别是
1. 建栈（用户可自定义栈名） 检查是否重名 或者是否达到栈的最大数目（4个栈）
2. 销毁栈（根据输入的栈名）
3. 整数元素进栈（输入元素值和要进入的栈名） 检查是否达到该栈最大数目（每个栈5个整数）
4. 元素出栈

源代码分成3个文件 proto.h biblio.h itry.c
然后还要写一个UNIX环境下的make文件进行编译

[jp1984]

/*
best love to lqp
and it is a simple one ,once u know the algorithm ,
it takes no time to write it out....
*/
#include <stdio.h>
struct bstack
{
int* top;
int size;
} s;
struct bstack init()
{
s.top = (int*) malloc(1);
if(s.top == NULL)
printf("Allocation Error\n");
s.size = 0;
return s;
}
void push(int* value)
{
s.top++;
s.top = value;
(s.size)++;
}
void pop()
{
int item = *(s.top);
s.size--;
s.top--;
printf("poping...%d\n",item);
}
void destroy()
{
free(s.top);
s.size = 0;
}
int main()
{
int item = 1;
init();
push(&item);
pop();
return 0;
}

[cn_dragron]

选择最简单的最好！！

[wilfred]

谢谢大家 等我逐个调试后就来给分
但是还有一个重要问题是要在UNIX环境下用make命令进行编译
请问有谁知道怎么写这个make file吗？

[pandengzhe]

没有，up

[goodluckyxl]

偶只会写c++的 栈

c语言没有

[Squall1009]

用数组写？

[ocpbase]

接收不同类型参数的栈
malloc
realloc
stackitem 块结构
stackitem的块空间
int init();
int push(void*,char type);
int pop();
int isfull();
int isempty();

[jitian81411]

自己用就用STL，作业就找本数据结构的书，照上边的来就可以了！

[jitian81411]

一般数据结构上边都有的

[jitian81411]

我写了一个队列的你可以参考：
//定义一个队列
#include<iostream.h>
#include<stdlib.h>
class Node{
public:
int data;
Node *next;
Node(int ,Node *);

};
Node::Node(int el,Node *ptr=0)
{ data=el;
next=ptr;
}
class Queue
{Node *front;
Node *rear;
public:
Queue(); //声明构造函数
bool empty(); //判断是否为空
void insertvalue(int); //进队列
void deletevalue(); //出队列
void clear(); //清空队列
void display(); // 显示队列

};
//成员函数定义

Queue::Queue()
{front=rear=0;}

bool Queue::empty()
{ return front==0;}

void Queue::insertvalue(int value)
{ if(empty())
{front=new Node(value);
rear=front;
}
else {
rear->next=new Node(value);
rear=rear->next;
}
}

void Queue::deletevalue()
{if(!empty())
{Node *ptr=front;
front=front->next;
delete ptr;
}

void Queue::display()
{ Node *q=front;
while(q!=0);
{cout<<q->data<<" ";q=q->next;}

}

void Queue::clear()
{if(front) deletevalue();
else cout<<"queue is empty!"<<endl;}


//测试程序
void main()
{Queue stu;
stu.insertvalue(5);
stu.insertvalue(8);
stu.insertvalue(6);
stu.display();
stu.deletevalue();
stu.display();
stu.deletevalue();
stu.display();
stu.deletevalue();
}

[zwzzj]

用数组很简单的了。
typedef struct stack{
int len[100];
int top;
}S;
S s;
void Initstack(){
s.top=-1;
}

S push(S *s,int i ){
s->len[++s->top]=i;
}
int pop(S* s){
return s->len[s->top--];
}

[goodluckyxl]

结构体就用自己的模板到是会写
template <class T>
class Node
{
public:
Node<T>(): next(NULL){}
Node<T>(T node): item(node),next(NULL){}
~Node<T>() { delete next; }
public:
T item;
Node<T> *next;
};

template <class T>
class List
{
public:
List():pLast(0),m_nNodeNum(0){ pHead = pLast; };
virtual ~List() {delete pHead;}
void push( T item ); //压入结点从后 可以是结点重量
void push( Node<T> node ); //重载可以是 Node对象
void push_head( T item ); //压入头，模拟队列，和栈 可以用这个接口压入
void push_head( Node<T> node );
bool insert( int iPos, T item ); //插入
bool insert( int iPos, Node<T> node );
Node<T>* pop(); //弹出头 模拟栈操作
Node<T>* pop(int ipos); //弹出某个位置 模拟队列用这个接口掸出
bool erase(int iPos); //定点删除对象 如果需要和vector之类容器类似 自己返回当前对象 不要delete就ok了
void clear(); //清除所有对象 堆上对象 已经办你处理
int GetNodeNum() {return m_nNodeNum;}
private:
bool IsEmpty() {return m_nNodeNum==0;}
Node<T>* GetNodePos(int iPos);
public:
Node<T> *pHead;
Node<T> *pLast;
private:
int m_nNodeNum;
};

template <class T>
void List<T>::push(T item)
{
if(IsEmpty())
{
pLast = new Node<T>(item);
pHead = pLast;
}
else
{
Node<T>* pNode = new Node<T>(item);
pLast->next = pNode;
pLast = pNode;
}
m_nNodeNum++;
}

template <class T>
void List<T>::push(Node<T> node)
{
if(IsEmpty())
{
pLast = new Node<T>(item);
pHead = pLast;
}
else
{
Node<T>* pNode = new Node<T>(item);
pLast->next = pNode;
pLast = pNode;
}
m_nNodeNum++;
}

template<class T>
void List<T>::push_head( T item )
{
Node<T>* pNode = new Node<T>(item);
pNode->next = pHead;
pHead = pNode;
m_nNodeNum++;
}

template<class T>
void List<T>::push_head( Node<T> node )
{
Node<T>* pNode = new Node<T>(node);
pNode->next = pHead;
pHead = pNode;
m_nNodeNum++;
}
template<class T>
Node<T>* List<T>::GetNodePos(int iPos)
{
Node<T>* pNode = pHead;
while (iPos>1)
{
pNode = pHead->next;
iPos--;
}
return pNode;
}
template<class T>
bool List<T>::insert( int iPos, T item )
{
if( GetNodeNum() < iPos )
return false;
if( iPos == 0 )
push_head(item);
else
{
Node<T>* pTemp = GetNodePos(iPos);
Node<T>* pNode = new Node<T>(item);
pNode->next = pTemp->next;
pTemp->next = pNode;
m_nNodeNum++;
}


return true;
}

template<class T>
bool List<T>::insert( int iPos, Node<T> node )
{
if( GetNodeNum() < iPos )
return false;
if( iPos == 0 )
push_head(node);
else
{
Node<T>* pTemp = GetNodePos(iPos);
Node<T>* pNode = new Node<T>(node);
pNode->next = pTemp->next;
pTemp->next = pNode;
m_nNodeNum++;
}


return true;
}

template<class T>
Node<T>* List<T>::pop()
{
if(IsEmpty())
return NULL;
Node<T>* pNode = pHead;
pHead = pHead->next;
m_nNodeNum--;

return pNode;
}

template<class T>
Node<T>* List<T>::pop(int iPos)
{
if(IsEmpty() || GetNodeNum() < iPos)
return NULL;
Node<T>* pTemp = GetNodePos(iPos-1);
Node<T>* pNode = pTemp->next;
pNode!=NULL? pTemp->next = pNode->next:pTemp->next = pNode;
m_nNodeNum--;
return pNode;
}

template<class T>
bool List<T>::erase(int ipos)
{
Node<T>* pNode = pop(ipos);
if( pNode != NULL )
{
pNode->next = NULL;
delete pNode; //手动删除的话就去掉这句
return true;
}
return false;
}

template<class T>
void List<T>::clear()
{
Node<T>* pNode = 0;
while (!IsEmpty())
{
pNode = pop();
pNode->next = 0;
delete pNode;
}
}

[qingyuan18]

....
typedef struct stack {
int a[MAX];
int top;
}stack;

int isEmpty(stack *mystack)
{
if (mystack->top ==-1)
{
return 1;
}
else
{
return 0;
}
}

void push(stack *mystack int a)
{
mystack->top++;
mystack->a[mystack->top] = a;
}

int pop(stack *mystack)
{
int i = mystack->top;
if(!isEmpty(mystack))
{
return mystack->a[i];
mystack->top--;
}
else
{
return -1;
}
}
......
unix下的make是啥意思？

[avalonBBS]

应楼主，用纯C写的栈，而且支持多种数据类型哦：））
=========================================================================================
======================================================================
#ifndef AVALON_STACK_H
#define AVALON_STACK_H
#include <stdio.h>
#include <string.h>
#include <assert.h>

#ifndef AVALON_BOOL
#define AVALON_BOOL
#define TRUE 1
#define FALSE 0
typedef int BOOL;/*自定义的BOOL型*/
#endif

/*定义一个栈结构*/
#define DECLARE_NODE(type,name) \
typedef struct type##NODE\
{\
type data;\
struct type##NODE *prior;\
}NODE##name;

#define DECLARE_STACK(type,name) \
struct type##STACK\
{\
int size;\
struct type##NODE *base;\
struct type##NODE *top;\
}STACK##name;
/*泛类型栈定义*/
#define DECLARE(type,name) \
DECLARE_NODE(type,name); \
DECLARE_STACK(type,name);

/****************************************************/
/*初始化栈,name为新声明的栈名字的地址 */
#define INIT(name) \
do{\
STACK##name.base=STACK##name.top=NULL;\
STACK##name.size=0;\
}while(0)
/*********** 不破坏栈顶元素取值*************************/
#define GET(name,elem) \
do{\
if(STACK##name.size != 0){\
elem=STACK##name.top->data; \
}\
}while(0)
/************** 压入元素elem **************************/
#define PUSH(name,elem) \
do{\
NODE##name *temp=(NODE##name *)malloc(sizeof(NODE##name));\
assert(temp);\
temp->data=elem ;\
(STACK##name.size)++; \
if(1 != STACK##name.size ){ \
temp->prior=STACK##name.top;\
STACK##name.top=temp;\
}\
else{\
temp->prior=NULL;\
STACK##name.top=STACK##name.base=temp;\
}\
}while(0)
/********** 栈顶元素赋值给elem,并弹出 ***********/
#define POP(name,elem) \
do{\
NODE##name * temp=STACK##name.top;\
if(STACK##name.size !=0 ){ \
*elem =STACK##name.top->data; \
if( STACK##name.size !=1){ \
STACK##name.top =temp->prior; \
free(temp);\
}\
else \
STACK##name.top=STACK##name.base=NULL;\
(STACK##name.size)--;\
}\
}while(0)
/************** 清空栈 ************************/
#define CLEAR(name) \
do{\
NODE##name * temp;\
while( STACK##name.size-- !=0){\
temp=STACK##name.top;\
STACK##name.top=STACK##name.top->prior;\
free(temp);\
}\
STACK##name.size=0;\
STACK##name.base=STACK##name.top=NULL;\
}while(0)
/****************栈空???? ************************/
#define EMPTY(name) ( STACK##name.size == 0 )
/*****************长度 ************************/
#define LENGTH(name) (1 ? STACK##name.size : 0)
#endif


这个是测试程序:
=======================================================================
#include "stack.h"
#include <stdio.h>
#include <stdlib.h>

int main(void)
{
DECLARE(int,A);
DECLARE(double,B);
double b;
int a;
INIT(A);
INIT(B);
printf("%d ",LENGTH(A));
for(a=1;a<=10000 ;a++){
PUSH(A,a);
PUSH(A,a);
PUSH(A,a);
}
printf("%d ",LENGTH(A));
for(b=1;b<=10000;b++){
PUSH(B,b);
}
while( ! EMPTY(A)){
POP(A,&a);
if( ! EMPTY(B)){
POP(B,&b);
}
}
CLEAR(A);
system("PAUSE");
return 0;
}

[robin97]

给分

[jokeyoung]

要求用C语言模拟推栈的管理 要求有四个函数 分别是
#include<stdio.h>
typefef MAX 4
typedef struct node {
int a[MAX];
int top;
}stack;
top=-1;
stack s;

void Istack(){
s.top=-1;
}

S push( ){s *h
h->len[h->top]=i;
h->top++;
}
int pop(S* s){ top--;
return s->a[s->top];
}


2. 销毁栈（根据输入的栈名）
3. 整数元素进栈（输入元素值和要进入的栈名） 检查是否达到该栈最大数目（每个栈5个整数）
4. 元素出栈

[wilfred]

很遗憾的是我没有能够调试通过两位用C语言编程的朋友的程序
我编译环境是用的DEV C＋＋ 4.9.9.0
不知道原因何在 不过还是感谢你们的帮助
另外两位C++代码的朋友 也一并谢过了！