复杂度分析、动态数组

课程大纲

复杂度分析

• 算法是解决特定问题的一些列执行步骤
• 使用不同算法，解决同一个问题，相率可能相差较大

以斐波那契额数列为例，fib2()的效率要比fib1()高。

package _01复杂度;

public class Main {
  /*
  0 1 1 2 3 5 ...
   */

    public static int fib1(int n){
        if(n <= 1){
            return n;
        }
        return fib1(n - 1) + fib1(n - 2);
    }

    public static int fib2(int n){
        if(n <= 1){
            return n;
        }
        int first = 0;
        int second = 1;
        for (int i = 0; i < n - 1; i++) {
            int sum = first + second;
            first = second;
            second = sum;
        }
        return second;
    }
    public static void main(String[] args) {
        System.out.println(fib1(10));
        System.out.println(fib2(10));
    }
}

控制台输出

55
55

如何评判一个算法的好坏

• 正确性
• 可读性
• 健壮性
• 时间复杂度
• 空间复杂度

Array（数组）：实现ArrayList

什么是数据结构

线性表

• 数组是一种顺序存储结构的线性表

int[] arr = new int[]{11, 22, 33}

• 内存结构：new出来的内容都是在堆空间
• 很多编程语言都有一个致命的缺点，无法动态修改容量，但是在实际开发中，我们希望可以动态修改数组的容量

动态数组（Dynamic Array）接口设计

public class ArrayList<E> {
    private int size;
    private E[] elements;

    // 元素的数量
    int size(); 
    // 是否为空
    boolean isEmpty();
    // 是否包含某个元素
    boolean contains(E element); 
    // 添加元素到最后面
    void add(E element); 
    // 返回index位置对应的元素
    E get(int index); 
    // 设置index位置的元素
    E set(int index, E element); 
    // 往index位置添加元素
    void add(int index, E element); 
    // 删除index位置对应的元素 
    E remove(int index); 
    // 查看元素的位置
    int indexOf(E element); 
    // 清除所有元素
    void clear(); 
}

成员变量和构造方法

 /**
     * 元素的数量
     */
    private int size;

    /**
     * 存放元素的数组
     */
    private int[] elements;

    /**
     * 默认开辟空间大小
     */
    private static final int DEFAULT_CAPACITY = 10;

    /**
     * 不存在返回-1
     */
    private static final int ELEMENT_NOT_FOUND = -1;

    /**构造函数（有参和无参）
     *
     */
    public ArrayList(int capaticy){
        capaticy = Math.max(capaticy, DEFAULT_CAPACITY);
        elements = new int[capaticy];// 开辟相应容量的内存
    }
    public ArrayList(){
        this(DEFAULT_CAPACITY);// 无参构造函数调用有参构造函数
    }

清除元素

/**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
    }

返回元素数量

 /**
     * 元素的数量
     * @return
     */
    public int size(){
        return size;
    }

判断是否为空

/**
     * 判断是否为空
     * @param size
     * @return
     */
    public boolean isEmpty(int size){
        return size == 0;
    }

查看元素的索引

/**
     * 查看元素的索引
     * @param element
     * @return
     */
    public int indexOf(int element){
        for (int i = 0; i < size; i++) {
            if (elements[i] == element){
                return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

是否包含某元素

 /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    public boolean contains(int element){
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

获取指定idex的元素

/**
     * 获取index位置的元素
     * @param index
     * @return
     */
    public int get(int index){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:" + index + ", Size" + size);
        }
        return elements[index];
    }

设置index位置的元素

/**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return 原来的元素
     */
    public int set(int index, int element){
        if(index < 0 || index >= size){
            throw new IndexOutOfBoundsException("Index:" + index + ", Size" + size);
        }
        int old = elements[index];
        elements[index] = element;
        return element;
    }

添加元素

如何添加元素到最后，就是size的位置放新的元素

 /**
     * 添加元素到尾部
     * @param element
     */
    public void add(int element){
        elements[size] = element;
        size++;
    }

打印数组

打印java中的一个对象的时候，默认调用toString()方法

• 重写toString()方法
• 在toString()方法中将元素拼接为字符串
• 字符串拼接建议使用StringBuilder,更加高效

  @Override
    public String toString() {
        //size = [99, 88, 77]
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            if(i != 0){
                string.append(", ");
            }
            string.append(elements[i]);

        }
        string.append("]");

        return string.toString();
    }

删除元素-remove(int index)

删除下标为3的元素：将下标为4以后得元素，依次向前移动一格（下标小的先移动），最后将size--，最后一个空格不用处理。

 /**
     *删除下标为index的元素
     * @param index
     * @return
     */
    public int remove(int index){
        int res = elements[index];
        for(int i = index; i < size() - 1; i ++){
            elements[i] = elements[i + 1];
        }
        size --;
        return res;
    }

添加元素-add(int index, E element)

将新的元素插入到下标为2的位置：将下标4到下标2的元素依次往后移动一位（下标大的先移动），再将新元素添加到下标为2的地方。

将越界情况单独写成函数，提高代码的复用性

/**
     * 在index位置插入一个元素
     * @param index
     * @param element
     */
    public void add(int index, int element){
        rangeCheckForAdd(index);
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;
    }
    private void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index:" + index + ", Size" + size);
    }
    private void rangeCheck(int index){
        if(index < 0 || index >= size){
            outOfBounds(index);
        }
    }
    private void rangeCheckForAdd(int index){
        if(index < 0 || index > size){
            outOfBounds(index);
        }
    }

接口测试

有以下方法

• 自己打印输出结果看是否符合预期
• 和预期结果进行比对，不符合直接抛出异常
• 使用单元测试工具

动态扩容

使用new申请内存，地址是随机的，不一定就是在你需要的那个位置进行拓展。那怎么做呢，就是申请一个更大的数组，将原来的复制过去， 然后更改内存指向，指向更大的内存，原来的内存会自动被释放掉

  /**
     * 在index位置插入一个元素
     * @param index
     * @param element
     */
    public void add(int index, int element){
        rangeCheckForAdd(index);
        //动态扩容
        ensureCapacity(size + 1);// 至少添加一个元素
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;
    }
 /**
     ** 保证要有capacity的容量
     * @param capacity
     */
    private void ensureCapacity(int capacity) {
    	int oldCapacity = elements.length;
    	if(oldCapacity > capacity) {
    		return;
    	}
    	//新容量为旧容量的1。5倍
    	int newCapacity = oldCapacity + (oldCapacity >> 1);
    	int[] newElements = new int[newCapacity];
    	for(int i = 0; i < size; i ++) {
    		newElements[i] = elements[i];
    	}
    	//改变指向
    	elements = newElements;
    	System.out.println(oldCapacity + "扩容为" + newCapacity);
	}

修改默认内存为2.

泛型

需求分析：目前添加元素的类型是int类型，是应为编写add()函数的时候，规定添加的元素是int（）类型，如果我希望添加其他类型就不行了，这一点非常局限，如何优化呢？可以使用泛型

泛型介绍

使用泛型技术可以让动态数组更加通用，可以存放仍以数据类型

使用方式，再类名后面使用尖括号，尖括号里面的名称随便取，这样类中用到该名称，就表示类型任意。

修改后的代码

package _1_Array_List;

public class ArrayList <E>{
    public static final StringBuilder STRING = new StringBuilder();
    /**
     * 元素的数量
     */
    private int size;

    /**
     * 存放元素的数组
     */
    private E[] elements;

    /**
     * 默认开辟空间大小
     */
    private static final int DEFAULT_CAPACITY = 2;

    /**
     * 不存在返回-1
     */
    private static final int ELEMENT_NOT_FOUND = -1;

    /**构造函数（有参和无参）
     *
     */
    public ArrayList(int capaticy){
        capaticy = Math.max(capaticy, DEFAULT_CAPACITY);
        elements = (E[]) new Object[capaticy];// 开辟相应容量的内存
    }
    public ArrayList(){
        this(DEFAULT_CAPACITY);// 无参构造函数调用有参构造函数
    }
    /**
     * 清除所有元素
     */
    public void clear(){
        size = 0;
    }

    /**
     * 元素的数量
     * @return
     */
    public int size(){
        return size;
    }

    /**
     * 判断是否为空
     * @param size
     * @return
     */
    public boolean isEmpty(int size){
        return size == 0;
    }

    /**
     * 是否包含某个元素
     * @param element
     * @return
     */
    public boolean contains(E element){
        return indexOf(element) != ELEMENT_NOT_FOUND;
    }

    /**
     * 添加元素到尾部
     * @param element
     */
    public void add(E element){
        add(size, element);
    }

    /**
     * 获取index位置的元素
     * @param index
     * @return
     */
    public E get(int index){
        rangeCheck(index);
        return elements[index];
    }

    /**
     * 设置index位置的元素
     * @param index
     * @param element
     * @return 原来的元素
     */
    public E set(int index, E element){
        rangeCheck(index);
        E old = elements[index];
        elements[index] = element;
        return element;
    }

    /**
     * 查看元素的索引
     * @param element
     * @return
     */
    public int indexOf(E element){
        for (int i = 0; i < size; i++) {
            if (elements[i] == element){
                return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

    @Override
    public String toString() {
        //size = [99, 88, 77]
        StringBuilder string = new StringBuilder();
        string.append("size=").append(size).append(", [");
        for (int i = 0; i < size; i++) {
            if(i != 0){
                string.append(", ");
            }
            string.append(elements[i]);

        }
        string.append("]");

        return string.toString();
    }

    /**
     *删除下标为index的元素
     * @param index
     * @return
     */
    public E remove(int index){
        E res = elements[index];
        for(int i = index; i < size() - 1; i ++){
            elements[i] = elements[i + 1];
        }
        size --;
        return res;
    }

    /**
     * 在index位置插入一个元素
     * @param index
     * @param element
     */
    public void add(int index, E element){
        rangeCheckForAdd(index);
        //动态扩容
        ensureCapacity(size + 1);// 至少添加一个元素
        for (int i = size - 1; i >= index; i--) {
            elements[i + 1] = elements[i];
        }
        elements[index] = element;
        size++;
    }
    private void outOfBounds(int index){
        throw new IndexOutOfBoundsException("Index:" + index + ", Size" + size);
    }
    private void rangeCheck(int index){
        if(index < 0 || index >= size){
            outOfBounds(index);
        }
    }
    private void rangeCheckForAdd(int index){
        if(index < 0 || index > size){
            outOfBounds(index);
        }

    }

    //
    /**
     ** 保证要有capacity的容量
     * @param capacity
     */
    private void ensureCapacity(int capacity) {
        int oldCapacity = elements.length;
        if(oldCapacity > capacity) {
            return;
        }
        //新容量为旧容量的1。5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        E[] newElements = (E[]) new Object[newCapacity]; //强制转换
        for(int i = 0; i < size; i ++) {
            newElements[i] = elements[i];
        }
        //改变指向
        elements = newElements;
        System.out.println(oldCapacity + "扩容为" + newCapacity);
    }
}

编写主函数进行测试

public class Main {
    public static void main(String[] args) {
        ArrayList<Integer> list = new ArrayList();
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        System.out.println(list.toString());
    }
}

对象数组

引入泛型之后，会出现内存问题。实际上，创建Object对象数组的时候，存储的实际上是地址，这样做的好处是节省空间

clear细节

如何销毁数组中的对象呢，只需要将数组元素赋值为null，这样地址指向对象的连线就会断开，对象内存就会被回收。这样原来写的clear（）函数就存在问题，令size = 0， 对象内存仍然存在。我需要要数组里面指向的对象挂掉。

/**
     * 清除所有元素
     */
    public void clear(){
        for (int i = 0; i < size; i++) {
            elements[i] = null;
        }
        size = 0;
    }

验证对象内存被回收
Person类中添加finalize()方法，当内存销毁的时候，会输出指定的内容

package _1_Array_List;

public class Person {
    private int age;
    private String name;
    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person [age=" + age + ", name=" + name + "]";
    }

    //内存销毁的时候，输出内容的函数
    @Override
    protected void finalize() throws Throwable {
        super.finalize();
        System.out.println("Person - finalized");
    }
}

可以通过gc（）函数，提醒jvm进行垃圾回收。

equal

java中判断相等的两种方法的比较：

• ==：判断两者内存地址是否相同，相同为真，不同为假
• equals()：判断两者值是否相同，相同为真，不同为假

优化indexof()函数
重写Person中的内存地址值

@Override
    public boolean equals(Object obj) {
        Person person = (Person) obj;
        return this.age == person.age;
    }

/**
     * 查看元素的索引
     * @param element
     * @return
     */
    public int indexOf(E element){
        for (int i = 0; i < size; i++) {
            if (elements[i].equals(element)){
                return i;
            }
        }
        return ELEMENT_NOT_FOUND;
    }

null的处理

null可以被存储，优化idexof（）函数，因为element[i]可能为null

 /**
     * 查看元素的索引
     * @param element
     * @return
     */
    public int indexOf(E element){
        if(element == null){
            for (int i = 0; i < size; i++) {
                if(elements[i] == null){
                    return i;
                }
            }
        }else{
            for (int i = 0; i < size; i++) {
                if (element.equals(elements[i])){
                    return i;
                }
            }
        }

        return ELEMENT_NOT_FOUND;
    }

ArrayList源码分析

 /**
     * This helper method split out from add(E) to keep method
     * bytecode size under 35 (the -XX:MaxInlineSize default value),
     * which helps when add(E) is called in a C1-compiled loop.
     */
    private void add(E e, Object[] elementData, int s) {
        if (s == elementData.length)
            elementData = grow();
        elementData[s] = e;
        size = s + 1;
    }

/**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        modCount++;
        final int s;
        Object[] elementData;
        if ((s = size) == (elementData = this.elementData).length)
            elementData = grow();
        System.arraycopy(elementData, index,
                         elementData, index + 1,
                         s - index);
        elementData[index] = element;
        size = s + 1;
    }

总结

参考资料

恋上数据结构与算法