c栈模板
① 求一个c语言标准 栈 的 模板 满意再给分
#include<stdio.h>
#include<stdlib.h>
/*定义常量*/
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define null 0
#define INFEASIBLE -1
#define OVERFLOW -2
/*定义栈初始分配空间及增量*/
#define initSize 100
#define increment 10
typedef int SElemType;
typedef int Status;
/*定义顺序栈类型*/
typedef struct Stack{
SElemType *base;/*栈构造前和销毁后栈底base为null*/
SElemType *top;/*栈顶指针*/
int stackSize;/*以元素为单位分配当前存储空间*/
}Stack;
Status initStack(Stack *S){/*初始化一个空栈并将其返回*/
(*S).base=(SElemType *)malloc(initSize*sizeof(SElemType));
if(!(*S).base) exit(OVERFLOW);
(*S).top=(*S).base;
(*S).stackSize=initSize;
return OK;
}
Status destroyStack(Stack *S){/*销毁栈*/
free((*S).base);
(*S).base=NULL;
(*S).top=NULL;
(*S).stackSize=0;
return OK;
}
Status clearStack(Stack *S){/*清空栈*/
(*S).top=(*S).base;
return OK;
}
Status stackEmpty(Stack S){/*判断栈是否为空*/
return (S.top==S.base);
}
int stackLength(Stack S){ /*用return返回站栈的长度*/
return S.top-S.base;
}
/**************/
Status getTop(Stack S,SElemType *e){
/*用*e以返回栈顶元素至e */
if(S.top>S.base){
*e=*(S.top-1);
return OK;
}
else return ERROR;
}
Status push(Stack *S,SElemType e){
/*将e入栈以成为新栈顶,并将栈返回*/
if((*S).top-(*S).base>=(*S).stackSize){
/*栈满,追加空间*/
(*S).base=(SElemType *)realloc((*S).base,((*S).stackSize+increment)*sizeof(SElemType));
if(!(*S).base) exit(OVERFLOW);
(*S).top=(*S).base+(*S).stackSize;
(*S).stackSize+=increment;
}
*((*S).top)++=e; /*从右向左运算,即:(*S) (*S).top++ 它指向的元素 */
return OK;
}
Status pop(Stack *S,SElemType *e){
/*弹出栈顶,用*e返回其值至e,并将栈返回*/
if((*S).top==(*S).base) return ERROR;
*e=*--(*S).top;
return OK;
}
Status stackTraverse(Stack S,Status(*visit)(SElemType)){
/*遍历元素执行函数visit*/
while(S.top>S.base)
visit(*S.base++);
printf("\n");
return OK;
}
接下来要添加自己的main()方法
② c语言写一个数组栈
#include<stdio.h>
#include<stdlib.h>
#defineSize20
typedefcharElementType;
typedefstruct
{
ElementTypedata[Size];
inttop;
}Stack;
intStackFull(Stack*s)
{
return(s->top==Size-1);
}
voidPushStack(Stack*s,char*buf)
{
if(NULL==s||NULL==buf)
return;
while(*buf!=' '&&*buf!='^'&&!StackFull(s))
{
if(*buf!='')
s->data[++s->top]=*buf;
++buf;
}
}
voidPopStack(Stack*s)
{
if(NULL==s)
return;
while(s->top!=-1)
putchar(s->data[s->top--]);
}
intmain()
{
charstr[Size];
Stack*s=(Stack*)malloc(sizeof(Stack));
s->top=-1;
gets(str);
PushStack(s,str);
PopStack(s);
return0;
}
③ 建立一个堆栈类模板 C++
写完再来贴
++++++++++++++++++++++++++++++++++++++++++++++++++++++++
我觉得链栈没必要初始化，构造函数已经够了，更不必判栈满，所以就没写。
若非要的话，发信给我，再帮你写一个初始化函数
template<class T>
class Stack{
class X{
public:
T e;
X *next;
};
X *base,*top;
public:
Stack();
~Stack();
// void inti();
void Push(T &);
T Pop();
int Empty();
T getTop();
};
template<class T>
Stack<T>::Stack(){
top=base=NULL;
}
template<class T>
Stack<T>::~Stack(){
X *p,*q;
p=top;
if(!p) return;
while(p!=base){
q=p;
p=p->next;
delete q;
}
delete base;
}
template<class T>
T Stack<T>::Pop(){
if(top==NULL){
cout<<"栈已空!\n";
return (T)0;
}
else{
X *p;
p=top;
top=top->next;
T t=p->e;
delete p;
return t;
}
}
template<class T>
T Stack<T>::getTop(){
if(top==NULL){
cout<<"栈已空!\n";
return (T)0;
}
else{
return top->e;
}
}
template<class T>
void Stack<T>::Push(T &t){
if(top==NULL){
top=base=new X;
top->e=t;
top->next=NULL;
}
else{
X *p;
p=new X;
p->e=t;
p->next=top;
top=p;
}
}
template<class T>
int Stack<T>::Empty(){
return(top==NULL)?1:0;
}
void main(){
Stack<int> s;
int i;
for(i=15;i<30;i++){
s.Push(i);
}
while(!s.Empty()){
cout<<s.Pop()<<endl;
}
Stack<float> sf;
for(i=1;i<10;i++){
float t=1.0/i;
sf.Push(t);
}
cout<<sf.getTop();
sf.Pop();
cout<<sf.getTop()<<endl;
while(!sf.Empty()) cout<<sf.Pop()<<endl;
}
④ c++中用类模板来定义顺序栈类
#include <iostream>
using namespace std;
template <class T>
class stack {
public:
stack(T n)
: base(new T[n]), sp(base), size(0), capacity(n)
{ }
T push(T n) {
*sp++ = n;
++size;
return n;
}
T pop() {
return *--sp;
}
void mp() const {
for(T* p = base; p != sp; ++p)
cout << *p << ' ';
cout.put('\n');
}
bool empty() const {
return sp == base;
}
~stack() {
if(capacity != 0)
delete [] base;
}
private:
T* base;
T* sp;
int size;
const int capacity;
};
#define PUSH( s, a, b ) for( i = 0; i < b; ++i ) s.push( a+i );
#define POP( a ) while( !a.empty() ) cout << a.pop() << ' '; cout.put( '\n' );
int main()
{
stack<int> a(10);
stack<char> b(10);
stack<double> c(10);
int i;
PUSH( a, 1, 3 );
PUSH( b, 'a', 5 );
PUSH( c, 1.1, 8 );
a.mp(); b.mp(); c.mp();
POP( a ); POP( b ); POP( c );
return 0;
}
附图：
⑤ C++ 求一个堆栈类模板
就是这个了，望采纳。#ifndef STACK_H#define STACK_Husing namespace std;template<class elemtype>class stack{ public: stack(){head=NULL; n=0;} virtual ~stack(){head=NULL;} int length(){return n;} bool push(elemtype& );//入栈 elemtype pop();//出栈 bool empty(){return head==NULL;} void clear(); protected: int n; struct node{ node *next; elemtype data; }; node *head;};template<class elemtype>void stack<elemtype>::clear(){ node *p,*q; int i=1; p=head; while(i!=n) { q=p; delete q; p=p->next; i++; }}template<class elemtype>bool stack<elemtype>::push(elemtype &e){ node *p,*q; int j=1; if(head==NULL) head=new node; p=head; if(n==0)//表头赋值 {head->data=e; n++; return true;} else //表尾插入 { q=new node; q->data=e; while (j<n) { p=p->next; j++; } p->next=q; q->next=NULL; n++; return true;}
}template<class elemtype>elemtype stack<elemtype>::pop( ){ int j=1; node *p; p=head; while(j<n){ p=p->next; j++; } n--; return p->data;}
#endif // stack_H
⑥ C++里面模板，栈分别是干什么用的
模板: 为了实现同制逻辑下不同参数类型的算法
运算符重载 不会改变运算符的优先级和结合型
如 void operator+(int x,int y);
int a = b+c;
+号重载的时候要这么用 X + X ,不会改变结合性.所有有些感觉比原来的操作少一个参数.
⑦ 用C++语言写一个实现栈功能的模板类 包括pop push 功能
#include <iostream.h>
#include <stdlib.h>
/////////////////////////////////////////////////////////////////////////////////////
#define MAXSIZE 0xFFFF
template<class type>
class SeqStack
{
int top; //栈顶指示
type *stacka; //数组名
int maxsize; //栈最大可容纳元素个数
public:
SeqStack();
SeqStack(int size);
SeqStack(type data[],int size);
virtual ~SeqStack()
{
delete []stacka;
}
void Push(const type &item); //元素item压栈
type Pop(); //数据元素出栈,返回之
type GetTop(); //读栈顶数据元素并返回
int Empty()const
{
return top==-1;
} //判断栈是否为空
int Full()const
{
return top==maxsize-1;
} //判断栈是否为满
void Clear()
{
top=-1;
} //清空栈
};
template<class type>
SeqStack<type>::SeqStack():
top(-1),maxsize(MAXSIZE)
{
stacka=new type[maxsize];
if(stacka==NULL){
cerr<<"动态存储分配失败!"<<endl;
exit(1);
}
}
template<class type>
SeqStack<type>::SeqStack(int size):
top(-1),maxsize(size)
{
stacka=new type[maxsize]; //创建存储栈的数组
if(stacka==NULL){ //分配不成功
cerr<<"动态存储分配失败!"<<endl;
exit(1);
}
}
template<class type>
SeqStack<type>::SeqStack(type data[],int size):
top(-1),maxsize(size)
{
stacka=new type[maxsize]; //创建存储栈的数组
if(stacka==NULL){ //分配不成功
cerr<<"动态存储分配失败!"<<endl;
exit(1);
}
for(int i=0;i<maxsize;i++){
stacka[i]=data[i];
}
top+=maxsize;
}
template<class type>
void SeqStack<type>::Push(const type& item)
{
//若栈已满，出错处理；否则把元素item压栈
if(Full()){
cerr<<"栈已满，不能压栈!"<<endl;
exit(1);
}
//这里我们采用指针先移动，然后再对元素进行操作的方式
top++;
stacka[top]=item;
}
template<class type>
type SeqStack<type>::Pop()
{
if(Empty()){
cerr<<"栈已空!"<<endl;
exit(1);
}
//栈不空，取栈顶元素
type data=stacka[top];
top--;
//返回栈顶元素
return data;
}
template<class type>
type SeqStack<type>::GetTop()
{
//若栈不空，返回栈顶元素的值
if(Empty()){
cerr<<"栈空!"<<endl;
exit(1);
}
//返回栈顶元素的值
return stacka[top];
}
//////////////////////////////////////////////////////////////////////
#include "SeqStack.h"
int main()
{
int data[10]={1,2,3,4,5,6,7,8,9,10};
SeqStack<int> stack(data,10);
while(!stack.Empty()){
cout<<stack.Pop()<<" ";
}
cout<<endl;
return 0;
}
////////////////////////////////////////////////////////////////////////////////////////////
输出结果：
10 9 8 7 6 5 4 3 2 1
Press any key to continue
/////////////////////////////////////////////////////////////////////////////////////////
⑧ 用C++语言编写一个栈的类模板希望能够把要求的都实现出来谢谢。不好意识没财富了哪位好心帮写下下回补上。
template<class T>
class Stack {
public:
Stack(int size) : length(size), tos(0) { stack = new T[length]; }//用户提供栈长进行初始化
~Stack() { delete [] stack; }
void push(T data) {stack[tos++] = data; } //入栈
T pop() { return stack[--tos]; } //出栈
bool empty() { return !tos; } //判断栈是否为空
bool full() { return tos >= length; } //判断栈是否已满
private:
int tos, length;
T* stack;
}; //模板不检测出入栈是否越界，出栈操作需要用户自行判定栈是否为空，入栈需要用户自行判定栈是否已满。
⑨ (C++题目)编写一个栈类模板，
下边都是我自己写的，都是经过编译的，调试用的main函数给注释掉了
不过遗憾是没有写注释，不过函数名字见名知意，希望你会满意。
用数组作为储存结构的顺序栈
#include<iostream>
#include<assert.h>
using namespace std;
const int INCREMENT = 20;
template <class T>
class SeqStack
{
public:
SeqStack(int size = 50);
~SeqStack();
void Push(T x);
bool Pop(T& e);
bool IsEmpty();
bool IsFull();
int Length();
bool getTop(T& x);
void MakeEmpty();
void Output();
private:
T* elements;
int top;
int maxSize;
void overflowProcess();
};
template <class T>
SeqStack<T>::SeqStack(int sz)
{
top = -1;
maxSize = sz;
elements = new T[maxSize];
assert(elements != NULL);
}
template <class T>
SeqStack<T>::~SeqStack()
{
delete []elements;
}
template <class T>
void SeqStack<T>::Push(T x)
{
if(IsFull())
{
overflowProcess();
}
elements[++top] = x;
}
template <class T>
bool SeqStack<T>::Pop(T &e)
{
if(IsEmpty())
{
return false;
}
else
{
e = elements[top--];
return true;
}
}
template <class T>
bool SeqStack<T>::IsEmpty()
{
if(top == -1)
return true;
return false;
}
template <class T>
bool SeqStack<T>::IsFull()
{
if(top == maxSize -1)
{
return true;
}
return false;
}
template <class T>
bool SeqStack<T>::getTop(T &x)
{
if(IsEmpty())
{
return false;
}
x = elements[top];
}
template <class T>
int SeqStack<T>::Length()
{
return (top+1);
}
template <class T>
void SeqStack<T>::MakeEmpty()
{
top = -1;
}
template <class T>
void SeqStack<T>::overflowProcess()
{
T* newElems = new T[maxSize+INCREMENT];
if(newElems == NULL)
{
cerr << "Memory allocate error!" << endl;
exit(1);
}
for(int i=0;i<=top;i++)
{
newElems[i] = elements[i];
}
maxSize = maxSize + INCREMENT;
delete []elements;
elements = newElems;
}
template <class T>
void SeqStack<T>::Output()
{
int i = 0;
if(!IsEmpty())
{
cout << "---top---" << endl;
for(i=top;i>=0;i--)
{
cout << elements[i] << endl;
}
cout << "---base---" << endl;
}
}
/*int main()
{
SeqStack<int> s;
int i=0;
int e;
for(;i<60;i++)
{
s.Push(i*2);
}
cout << "length:" << s.Length() << endl;
s.Output();
return 0;
}*/
用链表作为储存结构的链式栈
#include<iostream>
#include<assert.h>
using namespace std;
const int INCREMENT=20;
template <class T>
class StackNode
{
public:
StackNode(T _data,StackNode<T> *link = NULL)
{
data = _data;
next = link;
}
StackNode(StackNode<T> *link = NULL)
{
next = link;
}
StackNode<T> *next;
T data;
private:
};
template <class T>
class LinkStack
{
public:
LinkStack(){top = NULL;}
~LinkStack(){makeEmpty();}
bool isEmpty(){return (top == NULL);}
bool push(T x);
bool pop(T &x);
int getSize();
bool getTop(T &e);
void outPut();
void makeEmpty();
private:
StackNode<T>* top;
};
template <class T>
void LinkStack<T>::makeEmpty()
{
StackNode<T> *p;
while(top!=NULL)
{
p = top;
top = top->next;
delete p;
}
}
template <class T>
bool LinkStack<T>::push(T x)
{
StackNode<T> *e = new StackNode<T>(x);
if(!e)
{
cerr << "Memory allocate error!" << endl;
return false;
}
e->next = top;
top = e;
return true;
}
template <class T>
bool LinkStack<T>::pop(T &x)
{
if(!isEmpty())
{
x = top->data;
StackNode<T> *e = top;
top = top->next;
delete e;
return true;
}
return false;
}
template <class T>
bool LinkStack<T>::getTop(T &x)
{
if(!isEmpty())
{
x = top->data;
return true;
}
return false;
}
template <class T>
int LinkStack<T>::getSize()
{
StackNode<T> *p = top;
int count = 0;
while(p!=NULL)
{
count++;
p = p->next;
}
return count;
}
template <class T>
void LinkStack<T>::outPut()
{
StackNode<T> *p = top;
cout << "---top---" << endl;
while(p!=NULL)
{
cout << p->data << endl;
p = p->next;
}
cout << "---base---" << endl;
};
/*int main()
{
LinkStack<char> s;
char e;
int a = 65;
for(int i=0;i<5;i++)
{
s.push(char(a+i));
}
s.outPut();
s.makeEmpty();
s.outPut();
for(int i=0;i<6;i++)
{
s.pop(e);
cout << s.getSize()<< endl;
s.outPut();
}
return 0;
}*/
⑩ 用C写栈的源代码
#include <stdio.h>
#include <malloc.h>
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define ERROR -1
#define OK 1
#define TRUE 1
#define FALSE 0
typedef int status;
typedef int ElemType;
typedef struct{
ElemType data;
ElemType *base;
ElemType *top;
int stacksize;
}Stack,*SqStack;
status InitStack(Stack &S){
//构造一个空栈
S.base=(ElemType *)malloc(STACK_INIT_SIZE*sizeof(ElemType));
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}//InitStack
status GetTop(Stack &S,ElemType &e){
//若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR
if(S.top==S.base) return ERROR;
e= * (S.top-1);
return OK;
}//GetTop
status Push(Stack &S,ElemType e){
//插入元素e为新的栈顶元素
if(S.top-S.base>=S.stacksize){
S.base=(ElemType *)realloc(S.base,
(S.stacksize+STACKINCREMENT) * sizeof(ElemType));
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}//Push
status Pop(Stack &S,ElemType &e){
//若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR
if(S.top==S.base) return ERROR;
e= * --S.top;
return OK;
}//Pop