栈的实现及应用学习笔记--Java实现

1.定义

栈（Stack）是限定仅在表尾进行插入或删除操作的线性表。因此。表尾端有其特殊含义，称为栈顶（top)，相应地，表头端称为栈低。一般来说，栈主要有两个操作：一个是进栈（PUSH），另一个是出栈（POP)。

2. 栈的表示和实现

1） 顺序栈，即栈的顺序存储结构，利用一组地址连续的存储单元依次存放自栈低到栈顶的数据元素。

–java实现

public class ArrayStack<T> implements Serializable {
    private static final long serialVersionUID = 74027006708386243L;
    private Object[] elementData; // 定义一个数组用于保存顺序栈的元素
    private int size = 0; // 保存顺序栈中元素的当前个数
    private int capacity; // 当前数组的长度

    public ArrayStack() {
        elementData = new Object[10]; // 默认长度为10的栈
    }

    public ArrayStack(int initSize) {
        elementData = new Object[initSize]; // 设置栈的长度
    }

    public ArrayStack(T element) {
        this();
        elementData[0] = element;
        size++;
    }

    public ArrayStack(T element, int initSize) {
        this.capacity = initSize;
        elementData = new Object[capacity];
        elementData[0] = equals(element);
        size++;
    }

    /*
     * @Description: 栈长度
     */
    public int size() {
        return size;
    }

    /**
     * @description:入栈
     */
    public void push(T element) {
        // TODO Auto-generated method stub
        ensureCapacity(size + 1);
        elementData[size++] = element;
    }

    // 如果数组的原有长度小于目前所需的长度 ，进行扩容
    private void ensureCapacity(int capacity) {
        // TODO Auto-generated method stub
        int oldcapacity = elementData.length;
        if (capacity > oldcapacity) {
            int newCapacity = (oldcapacity * 3) / 2 + 1;
            if (newCapacity < capacity) {
                newCapacity = capacity;
            }
            // minCapacity is usually close to size
            elementData = Arrays.copyOf(elementData, newCapacity);
        }
    }

    /**
     * @description: 出栈
     */
    public T pop() {
        if (!isEmpty()) {
            T lastValue = (T) elementData[size - 1];
            // 释放栈顶元素
            elementData[--size] = null;
            return lastValue;
        } else {
            return null;
        }
    }

    /**
     * @Description: 返回栈顶元素，但不删除栈顶元素
     */
    public T peek() {
        if (!isEmpty()) {
            return (T) elementData[size - 1];
        } else {
            throw new IndexOutOfBoundsException("空栈异常");
        }
    }

    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size == 0;
    }

    /**
     * @Description: 清空顺序栈
     */
    public void clear() {
        // 将底层数组所有元素赋为null
        Arrays.fill(elementData, null);
        size = 0;
    }

    public String toString() {
        if (size == 0) {
            return "[]";
        } else {
            StringBuilder sbBuilder = new StringBuilder("[");
            for (int i = size -1 ; i >= 0; i--) {
                sbBuilder.append(elementData[i].toString() + ",");
            }
        int len = sbBuilder.length();
        return sbBuilder.delete(len - 1, len).append("]").toString();
        }
    }
}

2）栈的链表表示

–java 实现

import java.io.Serializable;

public class LinkStack<T> implements Serializable {
    private static final long serialVersionUID = -4378447264374701299L;

    private class Node {
        private T data; // 保存节点的数据
        private Node next;

        public Node() {
            // TODO Auto-generated constructor stub
        }

        public Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }

    private Node top; // 保存该链表栈的栈顶元素
    private int size = 0; // 保存该链栈中已包含的节点数，即栈的长度

    public LinkStack() {
        // TODO Auto-generated constructor stub
        top = null;
    }

    public LinkStack(T element) {
        top = new Node(element, null);
        size++;
    }

    /**
     * @Description: 栈的长度
     */
    public int size() {
        return size;
    }

    /**
     * @despriction: 入栈
     **/
    public void push(T element) {
        top = new Node(element, top);
        size++;
    }

    /**
     * @Description: 出栈
     **/
    public T pop() {
        Node oldTop = top;
        top = top.next;
        oldTop.next = null;
        size--;
        return oldTop.data;
    }

    /**
     * @Description: 访问栈顶元素
     */
    public T peek() {
        return top.data;
    }

    /**
     * @Description: 判断顺序栈是否为空栈
     */
    public boolean isEmpty() {
        return size == 0;
    }

    /**
     * @Description: 清空顺序栈
     */
    public void clear() {
        top = null;// 将栈所有元素赋为null
        size = 0;
    }

    public String toString() {
        if (isEmpty()) {
            return "[]";
        } else {
            StringBuilder sb = new StringBuilder("[");
            for (Node current = top; current != null; current = current.next) {
                sb.append(current.data.toString() + ", ");
            }
            int len = sb.length();
            return sb.delete(len - 2, len).append("]").toString();
        }
    }

}

3. 栈的应用

1） 进制转换
通过求余法可以将十进制转换为其他进制，比如要转为8 进制，则将原是进制除以8，记录余数，然后继续将商除以8，一直到商为 0为止，最后将余数倒序写出来即可。

–java实现

public class Conversion {
     /** 
       * @Title: conversion      
       * @Description: 将10进制正整数num转换为n进制     
       * @param num: 10进制正整数 
       * @param n: n进制 
       * @return 转换后的值 
       */
    public String Conversion(int num, int n){
        ArrayStack<Integer> myStack = new ArrayStack<Integer>();
        Integer result = num;
        while(true){
            //将余数存入栈
            myStack.push(result % n);
            result = result / n;
            if (result == 0) {
                break;
            }
        }
        StringBuilder sBuilder = new StringBuilder();
        //按栈的 顺序倒序输出即可
        while ((result = myStack.pop()) != null) {
            sBuilder.append(result);
        }
        return sBuilder.toString();
    }
}

2） 括号匹配检验
一般编程语言中括号都是成对出现的，比如：[]，()，{}
凡是遇到括号的前半部分，即为入栈符号（PUSH)；凡是遇到括号后半部分，就比对是否与栈顶元素相匹配（PEEK），如果相匹配，则出栈（POP）,否者就匹配出错。

–Java实现

public class symbol_match {
    public boolean isMatch(String str) {
    ArrayStack<Character> myStack = new ArrayStack<Character>();
        char[] arr = str.toCharArray();
        for (char c : arr) {
            Character temp = myStack.pop();
            // 栈为空时只将c入栈
            if (temp == null) {
                myStack.push(c);
            }
            // 配对时c不入栈
            else if (temp == '[' && c == ']') {
            }
            // 配对时c不入栈
            else if (temp == '(' && c == ')') {
            }
            else {
                myStack.push(temp);
                myStack.push(c);
            }
        }
        return myStack.isEmpty();
    }
}

3）行编辑
–java实现

/** 
 * @ClassName: LineEdit 
 * @Description: 行编辑: 输入行中字符'#'表示退格, '@'表示之前的输入全都无效. 
 */  
public class lineEdit {
    public String lineEdit(String input) {
    ArrayStack<Character> myStack = new ArrayStack<Character>();
        char[] arr = input.toCharArray();
        for (char c : arr) {
            if (c == '#') {
                myStack.pop();
            } else if (c == '@') {
                myStack.clear();
            }else {
                myStack.push(c);
            }
        }
        StringBuilder sBuilder = new StringBuilder();
        Character temp = null;
        while((temp = myStack.pop()) != null){
            sBuilder.append(temp);
        }
        sBuilder.reverse();
        return sBuilder.toString();
    }   
}

4）汉诺塔游戏，递归实现
汉诺塔问题的描述如下：有A、B和C 3跟柱子，在A上从下往上按照从小到大的顺序放着 n 个圆盘，以B为中介，把盘子全部移动到C上。移动过程中，要求任意盘子的下面要么没有盘子，要么只能有比它大的盘子。本实例将演示如何求解3阶汉诺塔问题。
思路解析
为了将N个盘子从A移动到C,需要先将第N个盘子上面的N-1个盘子移动到B上，这样才能将第N个盘子移动到C上。同理，为了将第N-1个盘子从B移动到C上，需要将N-2个盘子移动到A上，这样才能将第N-1个盘子移动到C上。通过递归就可以实现汉诺塔问题的求解。

–java实现

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class hanoi {

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub
        int n;
        BufferedReader buf = new BufferedReader(new        InputStreamReader(System.in));
        System.out.println("请输入盘子数：");
        n = Integer.parseInt(buf.readLine());
        move(n, 'A','B','C');
    }

    private static  void move(int n, char a, char b, char c) {
        // TODO Auto-generated method stub
        if (n == 1) {
        System.out.println("盘 " + n + " 由 " + a + " 移至 " + c);
        }else{
            move(n-1, a, c, b);
        System.out.println("盘 " + n + " 由 " + a + " 移至 " + c);
            move(n-1, b, a, c);
        }
    }

}

运行输出

请输入盘子数：
3
盘 1 由 A 移至 C
盘 2 由 A 移至 B
盘 1 由 C 移至 B
盘 3 由 A 移至 C
盘 1 由 B 移至 A
盘 2 由 B 移至 C
盘 1 由 A 移至 C