189 8069 5689
和C++里面一样，有入栈，弹栈，查找函数
10年积累的网站建设、做网站经验，可以快速应对客户对网站的新想法和需求。提供各种问题对应的解决方案。让选择我们的客户得到更好、更有力的网络服务。我虽然不认识你，你也不认识我。但先制作网站后付款的网站建设流程，更有右江免费网站建设让你可以放心的选择与我们合作。
import java.util.*;(引入包含栈类的头文件)
相关函数介绍
boolean empty()
测试堆栈是否为空。
E peek()
查看堆栈顶部的对象，但不从堆栈中移除它。
E pop()
移除堆栈顶部的对象，并作为此函数的值返回该对象。
E push(E item)
把项压入堆栈顶部。
int search(Object o)
返回对象在堆栈中的位置，以 1 为基数。
这是我写的栈，你看看
#includestdio.h
#includeiostream
typedef struct node{
int date;
node * next;
}SeqStack ;
SeqStack * init_SeqStack(SeqStack * top){
top=NULL;
return top;
}
int is_Empty(SeqStack * top){
if(top==NULL)return 1;
else return 0;
}
SeqStack * push_Stack(SeqStack * top){
SeqStack * New;
New=(SeqStack *)malloc(sizeof(SeqStack));
printf("请输入要入栈的元素\n");
scanf("%d",New-date);
New-next=top;
top=New;
return top;
}
SeqStack * pop_Stack(SeqStack * top,int m){
SeqStack * p=NULL;
if(!is_Empty(top)){
m=top-date;
p=top;
top=top-next;
free(p);
return top;
}
}
SeqStack * top_Stack(SeqStack * top,int m){
if(!is_Empty(top)){
m= top-date;
return top;
}
}
int main(){
int m=0;
SeqStack * s=NULL;
init_SeqStack(s);
s=push_Stack(s);
s=push_Stack(s);
s=push_Stack(s);
s=push_Stack(s);
s=top_Stack(s,m);
printf("%d\n",m);
s=top_Stack(s,m);
printf("%d\n",m);
s=pop_Stack(s,m);
printf("%d\n",m);
s=top_Stack(s,m);
printf("%d\n",m);
if(is_Empty(s)) printf("栈现在是空了");
system("pause");
return 0;
}
//你明确说一下哪里不明白 注释还可以啊
#includeiostream
using namespace std;
class IntStack{ //整数栈类
public:
virtual void push(int)=0; //入栈
virtual int pop()=0; //出栈并返回出栈元素
virtual int topElement()const=0; //返回栈顶元素，但不出栈
virtual bool isEmpty()const=0; //判断是否栈空
};
class SeqStack: public IntStack{
int data[100]; // 存放栈元素的数组
int top; // 栈顶元素的下标
public:
//**********found**********
SeqStack():top(-1){} // 把top初始化为-1表示栈空
void push(int n){ data[++top]=n; } //下标+1 压入栈 这里没什么难得吧。
//**********found**********
int pop(){ return data[top--]; } //同样 先取栈顶元素，然后下标-1
int topElement()const{ return data[top]; } //取栈顶元素
bool isEmpty()const{ return top==-1; } //判断是否为空
};
struct Node{
int data;
Node *next;
};
class LinkStack: public IntStack{
Node *top;
public:
//**********found**********
LinkStack(): top(NULL){} // 把top初始化为NULL表示栈空
void push(int n){
Node *p=new Node; //new一个新Node
p-data=n; //将n赋值给值域
//**********found**********
p-next=top; //将p的指针域指向top
top=p; //将top指向p 采用的头插法
}
int pop(){
int d=top-data;; //这里先取栈顶的元素
top=top-next; //top指针略过栈顶的元素 下一个元素成为栈顶元素 //这里做法不严谨 需要把节点的内存释放掉
return d;
}
int topElement()const{ return top-data; }
bool isEmpty()const{ return top==NULL; }
};
void pushData(IntStack st){
st.push(8);
st.push(1);
st.push(3);
st.push(6);
st.push(4);
}
void popData(IntStack st){
while(!st.isEmpty()) coutst.pop()' '; //不为空一直pop
}
int main(){
SeqStack st1; pushData(st1); popData(st1); //两个测试函数 把数据压栈 然后出栈。。
coutendl;
LinkStack st2; pushData(st2); popData(st2);
coutendl;
return 0;
}
//这是JDK提供的栈
import java.util.Stack;
public class UsingStack {
public static void main(String[] args) {
//构造栈对象，使用类型限制，只能存储Integer数据
StackInteger s = new StackInteger();
//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);
//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}
//这是我写的顺序结构的栈
import java.util.EmptyStackException;
import java.util.Vector;
public class UsingStack{
public static void main(String[] args){
//构造栈对象，使用类型限制，只能存储Integer数据
MyStackInteger s = new MyStackInteger();
//1、2、3依次入栈
s.push(1);
s.push(2);
s.push(3);
//3、2、1依次出栈
System.out.println(s.pop());
System.out.println(s.pop());
System.out.println(s.pop());
}
}
/**
* 栈类
* @author developer_05
* @param T
*/
class MyStackT extends VectorT{
/**
* 构造方法
*/
public MyStack(){
}
/**
* 入栈方法
* @param item 待入栈的元素
* @return 返回入栈的元素
*/
public T push(T item) {
addElement(item);
return item;
}
/**
* 出栈方法(同步处理)
* @return 返回出栈元素
*/
public synchronized T pop() {
T obj;
int len = size();
if (len == 0)
throw new EmptyStackException();
obj = elementAt(len - 1);
removeElementAt(len - 1);
return obj;
}
/**
* 判断栈是否为空的方法
* @return 返回true(栈空)或false(栈非空)
*/
public boolean empty() {
return size() == 0;
}
private static final long serialVersionUID = 1L;
}
你得明白栈的定义。代码执行的时候是执行一个方法，执行完，返回方法的上一个代码块继续往下执行后面的内容。这样的话是不是就是一个栈结构了？先进后出。方法一边执行，一边往栈里面存数据，等执行完了就取出数据（取出的是返回值，是最后一个存进去的 栈结构是后进先出），然后执行外面的代码。这么说你可能不明白，我给你举个例子。 int sub(int a,int b){ return a+b; } int c = sub(2,3);//注意执行这条语句的时候是不是执行了一个方法？ //那么语句执行的时候是要从左往右执行的对吧，但是事实的逻辑却是先算出来sub（2，3）这个方 //法的返回值，然后再把返回值（5）赋值给 c ，那么这个怎么实现，肯定是一个栈的数据结构，编译的时候先把”int c = “入栈，然后再把 sub（2，3），入栈，执行的时候，从栈里面取，取的第一个肯定是sub（2，3）吧？于是就计算出等于5，继续取，取出了int c =，然后就和5对接上了，就把值赋给c了。这只是一个小例子。道理是这样，但是具体的存取可不是这样的哦。具体的存取应该分的非常细腻，应该是按照java语法的最小单位来往栈里存取的。说白了一句话，程序运行的时候的先后顺序是跟人大脑想问题的顺序一样的，但是代码不是按照这样的顺序写的（从左到右），于是就用栈结构来达到这样的效果。这么说，明白了吗？
public StackX(int maxSize){
maxSize=maxSize;
stackarray=new long[maxSize];
top=-1;
}
不好意思，你犯了一个很傻的错误，这里应该是this.maxSize = maxSize,否则的话，你的实例变量maxSize还是没有被初始化为正确值，而只是默认值0