栈集锦

/*
1、顺序栈
2、双栈
3、链栈
4、顺序栈cpp

*/

//
//顺序栈
//Stack.h
#define INFINITY 65535
#define MAXSIZE 100
typedef int ElemType;
typedef struct
{
	ElemType data[MAXSIZE]; //栈的大小  
	int top; //栈顶的游标 
}Stack;

void InitStack(Stack *s);
bool IsEmpty(Stack *s);
ElemType Top(Stack *s); //返回栈顶的元素  
ElemType Pop(Stack *s); //返回并删除栈顶的元素  
void Push(Stack *s, ElemType e); 
void Print(Stack *s);
void Clear(Stack *s);

/
//method.cpp
#include "stdafx.h"
#include "Stack.h"
#include <stdio.h>

void InitStack(Stack *s)
{
	s->top = -1;
}

bool IsEmpty(Stack *s)
{
	if (s->top == -1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

ElemType Top(Stack *s)
{
	if (!IsEmpty(s))
	{
		return s->data[s->top];
	}
	else
	{
		return INFINITY;
	}
}

ElemType Pop(Stack *s)
{
	if (!IsEmpty(s))
	{
		return s->data[s->top--];
	}
	else
	{
		return INFINITY;
	}
}

void Push(Stack *s, ElemType e)
{
	if (s->top >= MAXSIZE - 1)
	{
		return;
	}

	s->top++;
	s->data[s->top] = e;
}

void Clear(Stack *s)
{
	s->top = -1;
}

void Print(Stack *s)
{
	int i;
	for (i = 0; i <= s->top; ++i)
	{
		printf("%d ",s->data[i]);
	}

	printf("\n");
}

/
//main.cpp
#include "stdafx.h"
#include "Stack.h"
#include <stdio.h>
int main()
{
	Stack s;
	InitStack(&s);

	int i;
	for (i = 1; i < 20; i += 2)
	{
		Push(&s, i);
	}

	Print(&s);

	printf("栈顶的元素为:\n");  
    int k = Top(&s);  
    printf("%d\n",k);

	Clear(&s);

	if (IsEmpty(&s))
	{
		printf("栈为空\n");
	}
	else
	{
		printf("栈不为空\n"); 
	}

	return 0;
}

/
//双栈
//DoubleStack.h
/*	两顺序栈共享一个地址连续的存储单元,一个栈的栈底为起始位置
	一个栈的栈底为末尾,压入数据时从两边向中间推进,如果指示栈
	顶的指针top1 + 1 等于另一个栈顶的指针top2时两栈已满,
	如果top1 == -1,top2 == MAXSIZE两栈为空					*/

#ifndef DOUBLESTACK_H
#define DOUBLESTACK_H
#define INFINITY 65535  //β值表标无限大
#define MAXSIZE 1000  //存储单元的最大值
typedef int ElemType; //栈的数据类型
typedef struct {
	ElemType data[MAXSIZE];  //存储单元
	int top1;
	int top2;
}DoubleStack;

void InitStack(DoubleStack *s); //初始化两个栈

void Push(DoubleStack *s,int i,ElemType e); //将数据e压栈,参数i为栈的序号1或2

ElemType Top(DoubleStack *s,int i); //参数i为栈的序号,返回栈顶的元素

ElemType Pop(DoubleStack *s,int i); //参数i为栈的序号,返回并删除栈顶的元素

bool IsEmpty(DoubleStack *s);  //判断栈是否为空

void Clear(DoubleStack *s);		//清空两栈

void Print(DoubleStack *s,int i); //打印栈底到栈顶的数据,i为栈的序号
#endif //DOUBLESTACK_H


//method.cpp
#include "DoubleStack.h"
#include <stdio.h>
void InitStack(DoubleStack *s)  //初始化两栈
{
	s->top1 = -1;
	s->top2 = MAXSIZE;
}
void Push(DoubleStack *s,int i,ElemType e) //将数据元素e压栈,i为栈的序号
{
	if(i == 1)
	{
		if(s->top1 + 1 == s->top2)
			return;
		s->data[++s->top1] = e;
	}
	else if(i == 2)
	{
		if(s->top2 - 1 == s->top1)
			return;
		s->data[--s->top2] = e;
	}
}

ElemType Top(DoubleStack *s,int i) //i为栈的序号,返回栈顶的元素
{
	if(i == 1)
	{
		if(s->top1 == -1)
			return INFINITY;
		return s->data[s->top1];
	}
	else if(i == 2)
	{
		if(s->top2 == MAXSIZE)
			return INFINITY;
		return s->data[s->top2];
	}
}

ElemType Pop(DoubleStack *s,int i) //i为栈的序号,返回并删除栈顶的元素
{
	if(i == 1)
	{
		if(s->top1 == -1)
			return INFINITY;
		return s->data[s->top1--];
	}
	else if(i == 2)
	{
		if(s->top2 == MAXSIZE)
			return INFINITY;
		return s->data[s->top2++];
	}
}

bool IsEmpty(DoubleStack *s) //判断栈是否为空
{
	if(s->top1 == -1 && s->top2 == MAXSIZE)
		return true;
	return false;
}

void Clear(DoubleStack *s) //清空栈
{
	s->top1 = -1;
	s->top2 = MAXSIZE;
}
void Print(DoubleStack *s,int i) //打印栈底到栈顶的元素,i为栈的序列
{
	if(i == 1)
	{
		for(int j = 0;j <= s->top1;++j)
			printf("%d ",s->data[j]);
		printf("\n");
	}
	else if(i == 2)
	{
		for(int j = MAXSIZE - 1;j >= s->top2;--j)
			printf("%d ",s->data[j]);
		printf("\n");
	}
}

/
//main.cpp
#include "DoubleStack.h"
#include <stdio.h>
int main()
{
	DoubleStack s;
	InitStack(&s);
	int k,i;
	printf("请输入要压入的栈的序号(1或2)及元素:\n");
	while((scanf("%d%d",&i,&k)) != EOF)
	{
		Push(&s,i,k);
		fflush(stdin);
	}
	Print(&s,1);
	Print(&s,2);
	int top1 = Top(&s,1);
	printf("第一个栈顶的元素:%d\n",top1);
	int top2 = Top(&s,2);
	printf("第二个栈顶的元素:%d\n",top2);
	return 0;
}

///
//链栈
#include<iostream>
using namespace std;
template<typename T>struct node{
T data;
node<T> *next;
};
template<typename T>class stack{
private :
	node<T> *top;
	int length;
public:
	stack()
	{
		top=new node<T>;
		top=NULL;
		length=0;
	}
	~stack()
	{
		clearStack();
	}
	void clearStack()
	{
		node<T> *p=top;
		node<T> *q;
		while(p!=NULL)
		{
			q=p->next;
			delete p;
			p=q;
			length--;
		}
		top=NULL;
	}
	int getLength()
	{
		node<T> *p=top;
		int n=0;
		while(p!=NULL)
		{
			p=p->next;
			n++;
		}
		return n;
	}
	void push(T e)
	{
		node<T> *p=new node<T>;
		p->data=e;
		p->next=top;
		length++;
		top=p;
	}
	bool pop(T &e)
	{
		if(NULL==top)
			return false;
		node<T> *p=top;
		e=p->data;
		top=p->next;
			length--;
	}
	void print()
	{
		node<T> *p=top;
		while(NULL!=p)
		{
			cout<<p->data<<" ";
			p=p->next;
		}
		cout<<endl;
	}
};
int main()
{	
	stack <int> La;
	cout<<La.getLength();
	for(int i=1;i<5;i++)
		La.push(i);
	cout<<La.getLength()<<",";
	La.print();
	int e;
	for(int i=1;i<5;i++)
	{
		La.pop(e);
		La.print();
	}
	for(int i=1;i<5;i++)
		La.push(i);
	La.print();
	La.clearStack();
	cout<<La.getLength();
	return 0;
}

/
//顺序栈cpp
#include<iostream>
using namespace std;
template<typename T>struct node{
T data;
node<T> *next;
};
template<typename T>class stack{
private :
	node<T> *top;
	int length;
public:
	stack()
	{
		top=new node<T>;
		top=NULL;
		length=0;
	}
	~stack()
	{
		clearStack();
	}
	void clearStack()
	{
		node<T> *p=top;
		node<T> *q;
		while(p!=NULL)
		{
			q=p->next;
			delete p;
			p=q;
			length--;
		}
		top=NULL;
	}
	int getLength()
	{
		node<T> *p=top;
		int n=0;
		while(p!=NULL)
		{
			p=p->next;
			n++;
		}
		return n;
	}
	void push(T e)
	{
		node<T> *p=new node<T>;
		p->data=e;
		p->next=top;
		length++;
		top=p;
	}
	bool pop(T &e)
	{
		if(NULL==top)
			return false;
		node<T> *p=top;
		e=p->data;
		top=p->next;
			length--;
	}
	void print()
	{
		node<T> *p=top;
		while(NULL!=p)
		{
			cout<<p->data<<" ";
			p=p->next;
		}
		cout<<endl;
	}
};
int main()
{	
	stack <int> La;
	cout<<La.getLength();
	for(int i=1;i<5;i++)
		La.push(i);
	cout<<La.getLength()<<",";
	La.print();
	int e;
	for(int i=1;i<5;i++)
	{
		La.pop(e);
		La.print();
	}
	for(int i=1;i<5;i++)
		La.push(i);
	La.print();
	La.clearStack();
	cout<<La.getLength();
	return 0;
}

/