栈java实现

Posted 2020-09-02 i廖海

　　这几天，过得挺充实的，每天都在不停的上课，早上很早就起来去跑步，晚上到图书馆看书。一边紧张的学习，一边在默默的备战软考。最近还接手了一个公司官网的建设。这是我在川信最后的一个完整学期了，每件事我都要认真去做。就算会有失落，会有失败，会有不甘，也不轻言放弃。

　　刚刚下去跑了几圈，吹着夜晚的冷风，在操场狂奔。汗水湿透了全身，滴在镜片上，我快看不清了远方。想起很多事来，来川信的两年，参加了两次运动会，这是第三次，且每次都是长跑，我享受着这种超越自己的感觉。长跑远没有结束，我一直在这条路上。

　　对于时间的安排，我的重点还是软考下午的5道大题，算法数据结构，设计模式，数据流图，数据库设计，uml例图，项目设计等。经过这几天努力，用java实现了常用的几种数据结构，画了很多的图，其中真是奥妙无穷。下一步，是算法设计，然后设计模式等。因为高中学了2年的计算机基础和网络知识，所以上午的一知半解。准备通过反复做题和百度练习。将下午的复习完毕之后，将进入全面复习阶段。通过真题训练，反复看书，做题，看代码，写代码。希望通过这次的复习，能够吸收这些知识转换为自己的思想，而不是死记硬背，应付考试。

　　下面是栈的顺序存储结构和链式存储实现：

　　

 1 package stack;
 2 
 3 public interface IStack<E> {
 4     //1.判断空栈
 5     public boolean isEmpty();
 6     
 7     //2.判断栈满
 8     public boolean isMax();
 9     
10     //3.入栈
11     public boolean push(E e);
12     
13     //4.出栈
14     public E pop();
15     
16     //5.返回栈顶
17     public E peek();
18     
19     //6.返回元素在栈中的位置
20     public int getIndex(E e);
21     
22     //7.返回栈的实际长度
23     public int size();
24     
25     //8.返回栈容量
26     public int getStackSize();
27     
28     //9.打印栈
29     public void display();
30     
31     
32 
33 }

//顺序栈

  1 package stack;
  2 
  3 //我的栈数据结构
  4 public class MyStack<E> implements IStack<E>{
  5     private Object[] data = null; //数据域
  6     private int top = -1;           //栈顶指针初始化为-1
  7     private int maxSize = 0;      //栈最大容量
  8     
  9     //默认设置栈容量为10
 10     MyStack(){
 11         this(10);
 12     }
 13     
 14     public MyStack(int initialSize){
 15         if(initialSize >= 0){
 16             this.data = new Object[initialSize]; //初始化数组
 17             this.maxSize = initialSize; //设置栈最大容量
 18             this.top = -1;
 19         }
 20     }
 21     
 22     public boolean isEmpty() {
 23         return top == -1 ? true : false; //根据栈顶值判断,如果栈顶指针没有更新，则为空栈
 24     }
 25 
 26     public boolean isMax() {
 27         return top >= maxSize-1 ? true : false; //根据栈顶值判断，如果栈顶指针大于最大容量，则为满栈
 28     }
 29 
 30     public boolean push(E e) {
 31         if(isMax()){
 32             System.err.println("对不起,栈已满,无法入栈");
 33             return false;
 34         }
 35         top ++; //更新栈顶下标
 36         data[top] = e; //将元素添加到表中
 37 //        System.out.println("添加" + e + "成功");
 38         return true;
 39     }
 40 
 41     @SuppressWarnings("unchecked")
 42     public E pop() {
 43         if(isEmpty()){
 44             System.err.println("对不起，目前是空栈，没有元素可以出栈");
 45             return null;
 46         }
 47         E e = (E) data[top]; //返回当前的栈顶元素
 48         top--; //更新栈顶
 49         return e;
 50     }
 51 
 52     @SuppressWarnings("unchecked")
 53     public E peek() {
 54         if(isEmpty()){
 55             System.err.println("对不起，目前是空栈，无法返回栈顶元素");
 56             return null;
 57         }
 58         return (E) data[top]; //返回栈顶元素
 59     }
 60 
 61     public int getIndex(E e) {
 62         //根据栈顶和栈底(-1)遍历栈
 63         while(top != -1){
 64             //peek()返回当前栈顶
 65             if(peek().equals(e)){
 66                 return top;
 67             }
 68             top --;
 69         }
 70         
 71         return -1;
 72     }
 73 
 74     public int size() {
 75         return this.top+1; //栈顶值+1，为栈元素的实际个数
 76     }
 77 
 78     public int getStackSize() {
 79         return this.maxSize; //返回栈实际长度
 80     }
 81 
 82     public void display() {
 83         //根据栈顶和栈底(-1)遍历
 84         while(top != -1){
 85             System.out.println(top);
 86             top --;
 87         }
 88     }
 89     
 90     public static void main(String[] args) {
 91         MyStack<Integer> stack = new MyStack<Integer>();
 92         //入栈
 93         for (int i = 0; i < 10; i++) {
 94             stack.push(i); 
 95         }
 96         //出栈
 97 //        stack.pop();
 98         //返回栈顶
 99 //        System.out.println(stack.peek());
100         //求长
101 //        System.out.println(stack.size());
102         
103     }
104     
105 }

//链栈

 1 package stack;
 2 
 3 //链栈是栈的链式存储结构，由多个节点组成。在链栈中的栈顶为头节点，节点由数据域和指针域组成
 4 //对链栈的操作都是间接的通过栈顶(头节点)完成。
 5 //顺序栈是一种特殊的顺序表
 6 //链栈是一种特殊链表
 7 public class LinkedStack{
 8     //定义节点类
 9     private class Node{
10         public Object data = null; //数据域
11         public Node next = null;   //指针域
12         
13         //构造函数初始化
14         @SuppressWarnings("unused")
15         public Node(){}
16         
17         public Node(Object data, Node next){
18             this.data = data;
19             this.next = next;
20         }
21 
22         @Override
23         public String toString() {
24             return "Node [data=" + data + ", next=" + next + "]";
25         }
26     }/*Node*/
27     
28     private Node top = null; //定义栈顶
29     private int size = 0;    //定义栈节点数量
30     
31     //判断栈空
32     public boolean isEmpty(){
33         return size == 0 ? true : false;
34     }
35         
36     //压栈
37     public boolean push(Object obj){
38         //更新头节点，让新节点指向原来的头节点
39         System.out.println("压栈成功:" + obj + "指向->" + top);
40         top = new Node(obj, top); //压栈是将节点插入到栈顶之前。也就是更新头节点。改变指针指向
41         size ++; //栈长度++
42         return true;
43     }
44     
45     //出栈
46     public Object pop(){
47         if(isEmpty()){
48             System.out.println("对不起，目前是空栈，不能出栈");
49             return null;
50         }
51         Node temp = top;     //头节点引用
52         top = top.next;        //更新头节点
53         temp.next = null;     //释放引用,删除指针指向
54         size-- ;             //栈节点数量-1
55         return temp.data;   //出栈
56     }
57     
58     //返回栈顶元素，但不弹出栈
59     public Object peek(){
60         return this.top.data; //直接返回栈顶元素
61     }
62     
63     //遍历栈并打印
64     public void display(){
65         //从栈顶节点开始到栈底节点null遍历
66         while(top != null){
67             System.out.println(top.data);
68             top = top.next;
69         }
70     }
71     
72     //返回元素在栈中的位置
73     public int getIndex(Object obj){
74         int i = 0;
75         while(top != null){
76             if(peek().equals(obj)){
77                 return i; 
78             }
79             top = top.next;
80             i++;
81         }
82         return -1;
83     }
84     
85     //返回栈的长度
86     public int getSize(){
87         return this.size;
88     }
89     
90     public static void main(String[] args) {
91         LinkedStack stack = new LinkedStack();
92         for (int i = 0; i < 10; i++) {
93             stack.push(i);
94         }
95 //        stack.display();
96         System.out.println(stack.getIndex(9));
97     }
98     
99 }

明天更新队列和树，然后是图的深度优先，广度优先，各种算法。