栈

栈

特点：先进后出

用数组实现

public class MyStack{
    private T[] stack;
    private int size;
    public static final int INIT_SIZE = 5;

    public MyStack(){
        stack = (T[]) new Object[INIT_SIZE];// 注意泛型数组的使用
    }

    public void push(T element){
        ensureCapacityHelper(size + 1);
        stack[size++] = element;
    }

    private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity > stack.length) {
            grow(minCapacity);
        }
    }

    private void grow(int minCapacity) {
        int newLength = (int) (stack.length * 1.5);
        stack = Arrays.copyOf(stack,newLength);
    }

    public T pop(){
        T element = peek();
        if(size > 0){
            stack[size - 1] = null;
            size--;
        }
        return element;
    }

    public boolean isEmpty(){
        return this.size == 0;
    }

    public T peek(){
        if(size > 0){
            return stack[size - 1];
        } else{
            return null;
        }
    }

}

用链表实现

public class MyStack{

    private Node head;

    class Node{
        private T data;
        private Node next;

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

    public MyStack(){

    }

    public void push(T element){
        if (element == null) {
            return;
        }
        if (this.head == null) {// 栈为空
            Node node = new Node(element, null);
            head = node;
        } else {
            Node node = new Node(element, null);
            node.next = head;

            head = node;
        }
    }

    public T pop(){
        T element = peek();
        if(head != null){
            head = head.next;
        }
        return element;
    }

    public boolean isEmpty(){
        return this.head == null;
    }

    public T peek(){
        if(head != null){
            return head.data;
        } else{
            return null;
        }
    }

}

逆波兰表达式

a * 2 // 需要6个指令集
a << 1 // 只需要1个指令集

标准四则运算表达式——中缀表达式
9+(3 - 1) * 3 + 10/ 2
计算机采用——后缀表达式
9 3 1 - 3 * + 10 2 / +

递归

大问题分解成小问题，都可以用递归

/**
     * 输入3，输出为：3，2，1，0，-1，0，1，2，3
     *
     * 实参与形参的传递
     * @param n
     */
    public void recursionDemo(int n){
        System.out.println(n);
        if (n < 0) {
            return;
        } else {
            recursionDemo(n-1);
            System.out.println(n);
        }
    }

斐波那契数列

    /**
     * 有一对兔子，从出生后3个月，每个月生一对兔子，小兔子长到三个月又生一对兔子，
     * 假如兔子不死，问第二十个月兔子对数
     * 第一个月兔子1对，第二个月1对，第三个月2对，第四个月3对，第五个月5对，第六个月8对
     * 从第三个月开始，兔子对数是前两个月之和（斐波那契数列）
     * @param n
     */
    public int fibonacci(int n){
        if (n < 0) {
            return -1;
        }
        if (n == 0) {
            return 0;
        }
        if (n == 1 || n == 2) {
            return 1;
        } else {
            return fibonacci(n-1) + fibonacci(n-2);
        }
    }

汉诺塔问题

 public void hanoi(int n,char from,char temp,char to){
    if(n == 1){// 一个盘子的情况
        System.out.println(n+" "+from+" ---> "+to);
    } else{
        //  首先 ，把上面的n-1个盘子移动到中间的柱子temp上
        hanoi(n-1,from,to,temp);
        //  然后，把 第n个 盘子移动到最终的柱子to上
        System.out.println(n+" "+from+" ---> "+to);
        //  最后，把temp上的n-1个盘子从temp借助最开始的柱子from全部移动到to上
        hanoi(n-1,temp,from,to);
    }
 }