算法笔记整理

线性结构

顺序存储

线性表

线性表是零个或多个元素的有限序列,a(i-1)是ai的直接前驱,a (i+1)是ai的直接后继,线性表长度是线性表的有效个数,size抽象类里面所有的方法都没有实现，都是抽象的，可以把这个抽象类写成接口,还可以防止代码冗余

list接口定义代码

import java.util.Comparator;
//线性表接口定义
public interface List<E> extends Iterable<E>  {
    //默认在表尾添加一个元素
    public void add(E element);
    //在指定角标处添加元素
    public void add(int index, E element);
    //删除指定元素
    public void remove(E element);
    //删除指定角标处的元素 并返回原先的值
    public E remove(int index);
    //获取指定角标处的元素
    public E get(int index);
    //修改指定角标index处的值为element 并返回原先的值
    public E set(int index, E element);
    //获取线性表中的元素个数
    public int size();
    //查看元素第一次出现的角标位置（从左到右）
    public int indexOf(E element);
    //判断是否包含元素
    public boolean contains(E element);
    //判断线性表是否为空
    public boolean isEmpty();
    //清空线性表
    public void clear();
    //按照比较器的内容进行排序
    public void sort(Comparator<E> c);
    //获取子线性表 原线性表中[fromIndex, toIndex]这个部分
    public List<E> subList(int fromIndex, int toIndex);
}

ArrayList的实现

import p1.List;

import java.util.Comparator;
import java.util.Iterator;

//自定义的线性表的顺序存储方式
public class ArrayList<E> implements List<E> {

    //数组的容器 data.length 指的就是当前数组的容量
    private E[] data;

    //元素的个数 size == 0 线性表为空 size == data.length 线性表满了
    //size 新元素默认尾部添加时要去的角标
    private int size;

    //默认容量
    private static int DEFAULT_CAPACITY = 10;

    //创建一个默认容量为10的线性表
    public ArrayList() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    //创建一个指定容量的线性表
    public ArrayList(int capacity) {
        if (capacity <= 0) {
            throw new IllegalArgumentException("capacity must > 0");
        }
        DEFAULT_CAPACITY = capacity;
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    //传入一个数组 将该数组封装成为一个线性表
    public ArrayList(E[] arr) {
        if (arr == null || arr.length == 0) {
            throw new IllegalArgumentException("arr can not be null");
        }
        data = (E[]) new Object[DEFAULT_CAPACITY];
        for (int i = 0; i < arr.length; i++) {
            add(arr[i]);
        }
    }

    @Override
    public void add(E element) {
        add(size, element);
    }

    @Override
    public void add(int index, E element) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("add index out of range");
        }
        //判断线性表是否是满状态
        if (size == data.length) {
            resize(2 * data.length);
        }
        //向后移动元素
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        //将新元素插入到指定位置
        data[index] = element;
        size++;
    }

    //扩容/缩容 操作 不应该向外界提供
    private void resize(int newLen) {
        E[] newData = (E[]) new Object[newLen];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    @Override
    public void remove(E element) { //删除指定元素 只删除一次 && 删除所有的指定元素
        int index = indexOf(element);
        if (index != -1) {
            remove(index);
        }
    }

    @Override
    public E remove(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("remove index out of range");
        }
        //先保存要删除的值
        E ret = data[index];

        //移动元素
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;

        //什么时候缩容
        //1.有效元素是容量的1/4
        //2.当前容量不得小于等于默认容量
        if (size == data.length / 4 && data.length > DEFAULT_CAPACITY) {
            resize(data.length / 2);
        }
        return ret;
    }

    @Override
    public E get(int index) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("get index out of range");
        }
        return data[index];
    }

    @Override
    public E set(int index, E element) {
        if (index < 0 || index >= size) {
            throw new IllegalArgumentException("set index out of range");
        }
        E ret = data[index];
        data[index] = element;
        return ret;
    }

    @Override
    public int size() {
        return size;
    }

    //额外添加一个函数 获取线性表中那个数组的容量
    private int getCapacity() {
        return data.length;
    }

    @Override
    public int indexOf(E element) {
        /*
        == 比的是啥？主要看等号的两边是啥
        == 两边是基本数据类型的话 比的是值
            byte short int long
            float double
            char boolean
        == 两边是引用数据类型的话 比的是地址
            数组 字符串 其他的类对象
        */
        for (int i = 0; i < size; i++) {
            if (data[i].equals(element)) {
                return i;
            }
        }
        return -1;
    }

    @Override
    public boolean contains(E element) {
        return indexOf(element) != -1;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public void clear() {
        data = (E[]) new Object[DEFAULT_CAPACITY];
        size = 0;
    }

    @Override
    public void sort(Comparator<E> c) {
        if (c == null) {
            throw new IllegalArgumentException("comparator can not be null");
        }
        for (int i = 1; i < size; i++) {
            E e = data[i];
            int j = 0;
            for (j = i; j > 0 && c.compare(data[j - 1], e) > 0; j--) {
                data[j] = data[j - 1];
            }
            data[j] = e;
        }
    }

    @Override
    public List<E> subList(int fromIndex, int toIndex) {
        if (fromIndex < 0 || toIndex >= size || fromIndex > toIndex) {
            throw new IllegalArgumentException("must 0 <= fromIndex <= toIndex <= size - 1");
        }
        ArrayList<E> list = new ArrayList<>();
        for (int i = fromIndex; i <= toIndex; i++) {
            list.add(data[i]);
        }
        return list;
    }

    @Override
    public boolean equals(Object o) {
        //1.判空
        if (o == null) {
            return false;
        }
        //2.判自己
        if (this == o) {
            return true;
        }
        //3.判类型
        if (o instanceof ArrayList) {
            //4.按照自己的逻辑进行比较
            ArrayList<E> other = (ArrayList<E>) o;
            //5.先比有效元素的个数
            if (size != other.size) {
                return false;
            }
            //6.有效元素个数相等的情况下 逐个比较元素
            for (int i = 0; i < size; i++) {
                if (!data[i].equals(other.data[i])) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
    /*
    [1, 2, 3, 4, 5, 6]
    []
    Arrays.toString(arr);
    */
    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append('[');
        if (isEmpty()) {
            sb.append(']');
        } else {
            for (int i = 0; i < size; i++) {
                sb.append(data[i]);
                if (i == size - 1) {
                    sb.append(']');
                } else {
                    sb.append(',');
                    sb.append(' ');
                }
            }
        }
        return sb.toString();
    }

    //获取当前这个数据结构/容器 的 迭代器
    //通过迭代器对象 更方便挨个取出每一个元素
    //同时 实现了Iterable 可以让当前的数据结构/容器 被foreach循环遍历
    @Override
    public Iterator<E> iterator() {
        return new ArrayListIterator();
    }

    //创建一个属于ArrayList的迭代器
    class ArrayListIterator implements Iterator<E> {
        private int cur = 0;

        @Override
        public boolean hasNext() {//判断是否有下一个元素
            return cur < size;
        }

        @Override
        public E next() {//如果有下一个元素 则把当前元素返回 并移至到下一个元素
            return data[cur++];
        }
    }
}

TestArrayList(测试)

import p2.ArrayList;

import java.util.Comparator;
import java.util.Iterator;
import java.util.Random;

public class TestArrayList {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList<>();
        System.out.println(list);
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            list.add(random.nextInt(100));
        }
        System.out.println(list);

        for (int i = 0; i < 10; i++) {
            list.add(0, i);
        }
        System.out.println(list);

        list.sort(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });
        System.out.println(list);

        for (Integer num : list) {
            System.out.println(num);
        }

        Iterator<Integer> it = list.iterator();
        while (it.hasNext()) {
            System.out.print(it.next() + " ");
        }

        System.out.println();
        ArrayList<Integer> l1 = new ArrayList<>();
        ArrayList<Integer> l2 = new ArrayList<>(8);
        for (int i = 0; i < 5; i++) {
            l1.add(i);
            l2.add(i);
        }
        System.out.println(l1);
        System.out.println(l2);
        System.out.println(l1.equals(l2));
    }
}

栈

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈的接口

public interface Stack<E> extends Iterable<E> {
    public int size();
    public boolean isEmpty();
    //入栈 进栈一个元素 在线性表的表尾添加一个元素
    public void push(E element);
    //出栈 弹出一个元素 在线性表的表尾删除一个元素
    public E pop();
    //查看当前栈顶元素 并不是移除 查看线性表中最后一个元素
    public E peek();
    public void clear();
}

栈的实现ArrayStack

import p1.Stack;

import java.util.Iterator;

public class ArrayStack<E> implements Stack<E> {
    private ArrayList<E> list;

    public ArrayStack() {
        list = new ArrayList<>();
    }

    public ArrayStack(int capacity) {
        list = new ArrayList<>(capacity);
    }

    @Override
    public int size() {
        return list.size();
    }

    @Override
    public boolean isEmpty() {
        return list.isEmpty();
    }

    @Override
    public void push(E element) {
        list.add(element);
    }

    @Override
    public E pop() {
        return list.remove(list.size() - 1);
    }

    @Override
    public E peek() {
        return list.get(list.size() - 1);
    }

    @Override
    public void clear() {
        list.clear();
    }

    @Override
    public Iterator<E> iterator() {
        return list.iterator();
    }

    @Override
    public String toString() {
        return list.toString();
    }

    @Override
    public boolean equals(Object o) {
        if (o == null) {
            return false;
        }
        if (this == o) {
            return true;
        }
        if (o instanceof ArrayStack) {
            ArrayStack other = (ArrayStack) o;
            return this.list.equals(other.list);
        }
        return false;
    }
}

栈的测试TestArrayStack

import p2.ArrayStack;

public class TestArrayStack {
    public static void main(String[] args) {
        ArrayStack<Integer> stack01 = new ArrayStack<>();
        ArrayStack<Integer> stack02 = new ArrayStack<>(15);
        for (int i = 1; i <= 12; i++) {
            stack01.push(i);
            stack02.push(i);
        }
        System.out.println(stack01);
        System.out.println(stack02);
        System.out.println(stack01.equals(stack02));

        System.out.println(stack01.pop());
        System.out.println(stack01);
        System.out.println(stack01.peek());
    }
}

中缀表达式

public class InfixCalculator {
    public static void main(String[] args) {
        String equation = "(10+20/2*3)/2+8";
        int result = calculate(equation);
        System.out.println(result);
    }


    private static int calculate(String equation) {
        equation = FormatString(equation);
        ArrayStack<Character> OperatorStack = new ArrayStack<>();
        ArrayStack<Integer> NumberStack = new ArrayStack<>();

        String mid[] = equation.split(" ");
        for (String theMid : mid) {
            if (theMid.length() == 0) {
                continue;
            } else if (theMid.equals("+") || theMid.equals("-")) {
                while ( !OperatorStack.isEmpty() && (OperatorStack.peek() == '+' || OperatorStack.peek() == '-' || OperatorStack.peek() == '*' || OperatorStack.peek() == '/')  ) {
                    BranchCalculate(OperatorStack, NumberStack);
                }
                OperatorStack.push(theMid.charAt(0));
            } else if (theMid.equals("*") || theMid.equals("/")) {
                while (!OperatorStack.isEmpty() && (OperatorStack.peek() == '*' || OperatorStack.peek() == '/')) {
                    BranchCalculate(OperatorStack, NumberStack);
                }
                OperatorStack.push(theMid.charAt(0));

            } else if (theMid.equals("(")) {
                OperatorStack.push(theMid.charAt(0));

            } else if (theMid.equals(")")) {
                while (OperatorStack.peek() != '(') {
                    BranchCalculate(OperatorStack, NumberStack);
                }
                OperatorStack.pop();

            } else {
                NumberStack.push(new Integer(theMid));

            }
        }
        while (!OperatorStack.isEmpty()) {
            BranchCalculate(OperatorStack, NumberStack);
        }
        return NumberStack.pop();
    }

    private static void BranchCalculate(ArrayStack<Character> OperatorStack, ArrayStack<Integer> NumberStack) {
        char op = OperatorStack.pop();
        int num1 = NumberStack.pop();
        int num2 = NumberStack.pop();
        if (op == '+') {
            NumberStack.push(num1 + num2);
        } else if (op == '-') {
            NumberStack.push(num2 - num1);
        } else if (op == '*') {
            NumberStack.push(num1 * num2);
        } else {
            NumberStack.push(num2 / num1);
        }
    }


    private static String FormatString(String equation) {
        StringBuilder temporary = new StringBuilder();
        for (int i = 0; i < equation.length(); i++) {
            char a = equation.charAt(i);
            if (a == '(' || a == ')' || a == '+' || a == '_' || a == '*' || a == '/') {
                temporary.append(" ");
                temporary.append(a);
                temporary.append(" ");
            } else {
                temporary.append(a);
            }

        }
        return temporary.toString();
    }
}