数据结构-栈

通过栈实现浏览器的前进后退
  1. 思路就是利用俩个栈,分别记录前进和后退的网页
  2. 具体实现,准备俩个栈A,B,当浏览器浏览三个网页时,a,b,c,栈一次压入a,b,c,当点击后退c从Az栈出栈进入B栈,点前进时,c从B出栈进入A栈

为什么栈可以实现上述操作呢
  1. 因为他有一个特性,先进后出;比如羽毛球筒,放羽毛球,先放进去的球最后才能拿出;同理,先浏览的网页就压入到栈底,最后浏览的网页在栈顶,这样我们后退就会看到刚刚浏览的网页了
  2. 说到这里,栈其实和数组很像,而且数组比栈更灵活,按为什么不用数组呢?其实栈其实完全可以用数组取代,但是数组过于灵活,所以用栈做一些限制,防止一些不可控的事情发生
  3. 举一个实际例子看出栈入栈,比如说 入栈1 ,2;然后出栈 2,下图是对于栈变化的过程


下面是用代码实现基于数组的栈
 import java.util.Arrays;
/**
 * 数组实现栈
 * @param <T>
 */

//这里使用泛型是为了扩展性,以为这里使用了泛型,但你实际使用时必定会传入实际的类型,比如Integer,那么编译时就会变成Integer,而且也不会要为每一种类型写一遍实现,很方便
class Mystack1<T> {
    //实现栈的数组
    private Object[] stack;
    //数组大小
    private int size;
 
    Mystack1() {
        stack = new Object[10];//初始容量为10
    }
 
    //判断是否为空
    public boolean isEmpty() {
        return size == 0;
    }
 
    //返回栈顶元素
    public T peek() {
        T t = null;
        if (size > 0)
            t = (T) stack[size - 1];
        return t;
    }
    
    public void push(T t) {
        expandCapacity(size + 1);
        stack[size] = t;
        size++;
    }
 
    //出栈
    public T pop() {
        T t = peek();
        if (size > 0) {
            stack[size - 1] = null;
            size--;
        }
        return t;
    }
 
    //扩大容量 这里其实不建议扩容,因为涉及到拷贝之前的数据,还需要重新计算地址,建议初始化时就预估大小
    public void expandCapacity(int size) {
        int len = stack.length;
        if (size > len) {
            size = size * 3 / 2 + 1;//每次扩大50%
            stack = Arrays.copyOf(stack, size);
        }
    }
}
 
public class ArrayStack {
    public static void main(String[] args) {
        Mystack1<String> stack = new Mystack1<>();
        System.out.println(stack.peek());
        System.out.println(stack.isEmpty());
        stack.push("java");
        stack.push("is");
        stack.push("beautiful");
        stack.push("language");
        System.out.println(stack.pop());
        System.out.println(stack.isEmpty());
        System.out.println(stack.peek());
    }
}
栈还有一种比较高级的用法叫递归
  1. 不知道你是否听过斐波那契数列,他的每一次结果都是上俩次的和,F(1)=1,F(2)=1, F(n)=F(n-1)+F(n-2)(n>=3,n∈N*)比如这样一个数列:1、1、2、3、5、8、13、21、34、……;
     实际上呢就是不断吧每次计算的需要的条件压入栈中,直到知道最初的结果;比如f(1) = 1,f(2)=2,之后通过这俩个值依次计算出栈中对应的结果得到最终结果,看一下代码;
  2.递归就是自己调自己,可以看下下面的实例去理解递归和栈
//假设你正在爬楼梯。需要 n 阶你才能到达楼顶。 
//
// 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢? 
//
// 注意:给定 n 是一个正整数。 
//
// 示例 1: 
//
// 输入: 2
//输出: 2
//解释: 有两种方法可以爬到楼顶。
//1.  1 阶 + 1 阶
//2.  2 阶 
//
// 示例 2: 
//
// 输入: 3
//输出: 3
//解释: 有三种方法可以爬到楼顶。
//1.  1 阶 + 1 阶 + 1 阶
//2.  1 阶 + 2 阶
//3.  2 阶 + 1 阶
// 
 public static int climbStairs(int n) {
        if (n <= 1)
            return 1;
        if (n < 3)
            return n;
     //每一次将要计算的公式压入栈中,因为不知道上一次的结果;除非知道上一次计算的结果,比如f(3) = f(2)-f(1)
     //这样的代码理解简单,容易写,但是栈时很耗费内存的,内存有限,如果设计栈或者计算量很大很容易内存溢出
     //这里就是把每次的结果都压入到栈里。可以结合jvm的去想
        return climbStairs(n - 1) + climbStairs(n - 2);
    }


posted @ 2020-08-09 22:48  小傻孩丶儿  阅读(145)  评论(0编辑  收藏  举报