数据结构~栈入门

栈

一：栈的介绍

1. 栈的英文名为：stack
2. 栈是一个先入后出的有序列表
3. 栈是限制性表，表中的元素只能够在线性表的一端进行插入，获取元素，这一端为允许变化的一端，成为栈顶（Top）,另一端则称为栈底。
4. 根据栈的定义可以知道，最先放入栈中的数据是在栈的最底层，最后放的元素则是在栈顶，因此每次对元素进行操作，只能从栈顶开始，删除，获取等操作，栈不支持随机访问。
5. 将数据放到栈中叫做压栈（push），将元素从栈中取出称为将元素从栈中弹出（pop）

使用数据实现栈：

package cn.littleworm.Array.pojo;
  /*
        创建一个栈的思路（使用数组实现）
            1、定义一个栈顶指针，初始化为-1
            2、将数据压入栈pop
            3、将数据弹出栈
            4、显示栈中的数据
            5、判断栈是否为空或栈满

     */

public class ArrayStarck {
    //定义全局属性：栈顶指针
    private int top = -1;
    private int maxsize;
    private int[] stack;

    //创建构造器
    public ArrayStarck(int maxsize){    //maxsize是数组的长度

        this.maxsize = maxsize;
        //创建数组
        stack = new int[this.maxsize];
    }

    //判断栈是否为空
    public boolean isEmpty(){
        return top == -1;
    }

    //判断栈是否已满
    public boolean isFull(){
        return top == maxsize-1;
    }

    //压栈
    public void push(int value){
        //判断是否已满
        if (isFull()){
            System.out.println("栈已满");
            return;
        }
        top++;
        stack[top] = value;
    }

    //弹栈
    public int pop(){
        //判读是否为空
        if (isEmpty()){
            //抛出异常
            System.out.println("栈为空，请先输入数据");
            return 0;
        }
        //用来接收数据
        int value;
        value = stack[top];
        //将top减一
        top--;
        return value;
    }

    //显示栈中数据
    public void showList(){
        //判断栈中是否有数据
        if (isEmpty()){
            System.out.println("栈为空，请先输入数据");
            return;
        }
        //循环遍历
        for (int i=top;i>=0;i--){
            System.out.println(stack[i]);
        }

    }

}

测试

package cn.littleworm.Array.pojo;

import java.util.Scanner;

public class ArrayStrackDemo {

    public static void main(String[] args) {

        ArrayStarck arrayStarck = new ArrayStarck(4);

        String key ;
        boolean flag = true;
        Scanner scanner = new Scanner(System.in);

        while (flag){
            System.out.println("show:表示显示栈中数据");
            System.out.println("pop:表示向栈中添加数据");
            System.out.println("pulsh:表示从栈中弹出一个数据");
            System.out.println("exit:退出程序");
            System.out.print("请输入你的选择：");
            key = scanner.next();

            switch (key){
                case "show":
                    arrayStarck.showList();
                    break;
                case "pop":
                        int pop = arrayStarck.pop();
                        System.out.println("弹出数据是："+pop);
                        break;
                case "pulsh":
                    System.out.println("请输入数据：");
                    int i = scanner.nextInt();
                    arrayStarck.push(i);
                    break;
                case "exit":
                    scanner.close();
                    flag = false;
            }
        }
    }
}

使用单链表实现栈

package cn.littleworm.list.pojo;

public class Node {


    private int data;
    public Node next;

    //构造器
    public Node(int data){
        this.data = data;
    }

    //空参构造
    public Node(){}

    //toString方法

    @Override
    public String toString() {
        return
                "data=" + data;
    }

    public int getData() {
        return data;
    }

    public void setData(int data) {
        this.data = data;
    }
}

package cn.littleworm.list.pojo;

public class ListStrack {
    /*
    思路：
        1、每次添加就按照倒序进行插入
        2、进行删除，删除head后面的结点
        3、展示，遍历倒序后的链表
     */
    private Node head = new Node(0);

    //插入
    public void push(int data){
        //创建一个结点
        Node newNode = new Node(data);
        if (head.next == null){
            head.next = newNode;
        }else {
            newNode.next = head.next;
            head.next = newNode;
        }
    }

    //删除
    public void pop() {
        //判断
        if (head.next == null) {
            System.out.println("栈为空，请先输入数据");
            return;
        }
       head.next = head.next.next;
    }

    //展示
    public void showList(){
        //判读
        if (head.next == null){
            System.out.println("栈为空，请先输入数据");
            return;
        }
        //定义一个辅助指针
        Node f = head.next;
        while (true){
            System.out.println(f.getData());
            if (f.next==null){
                break;
            }
            f = f.next;
        }
    }
}

package cn.littleworm.list.pojo;


import java.util.Scanner;

public class Test {
    public static void main(String[] args) {

        ListStrack listStrack = new ListStrack();

        boolean flag = true;
        String key;
        Scanner scanner = new Scanner(System.in);

        while (flag){
            System.out.println("push:向栈中压数据");
            System.out.println("pop:将栈中的数据弹出");
            System.out.println("show:显示栈中的数据");
            System.out.println("exit:退出程序");
            System.out.println("请选项：");
            key = scanner.next();

            switch (key){
                case "push":
                    System.out.println("请输入要压如的数据：");
                    int data = scanner.nextInt();
                    listStrack.push(data);
                    break;
                case "pop":listStrack.pop();break;
                case "show":listStrack.showList();break;
                case  "exit":scanner.close();flag = false;
            }
        }

    }
}