数据结构第一课——复杂度的简单分析

简单的复杂度分析

• O(1),O(n),O(lgn),O(nlogn),O(n^2)

• 大O描述的是算法的运行时间和输入数据之间的关系

• 为什么要用大O，叫做O(n)？ —忽略常数

    T = 2*n+2						O(n)
    T = 2000 *n + 10000			O(n)
    T = 1*n*n+0					O(n^2)
  

• 对以下代码进行复杂度分析

	/**
     * 在第index位置为data数组添加一个元素
     * 时间复杂度为O(n)
     * */
    public void add(int index, E e){
        if(index<0 || index>size){
            throw new IllegalArgumentException("你输入的位置不合法！！！");
        }
        if(size == data.length){
            //扩容操作
            resize(data.length * 2);
        }
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        data[index] = e;
        size++;
    }
	/**
     * 从data数组中删除index位置的元素，并且返回删除位置的元素
     * 时间复杂度为0(n)
     * @param index
     * @return
     */
    public E remove(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("你输入的索引不合法");
        }

        E result = data[index];

        for (int i = index+1; i < size; i++) {
            data[i-1] = data[i];
        }
        size--;
        data[size] = null;

        if(size == data.length/2 && data.length/2!=0){
            resize(data.length/2);
        }
        return result;
    }

    /**
     * data数组扩容
     * @param newCapacity
     */
    private void resize(int newCapacity){
        E[] newData = (E[])new Object[newCapacity];
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

上述代码有一种特殊的情况，那就是给数组的最后一个位置添加(删除)元素，此时不需要再遍历数组，可以直接添加(删除)，时间复杂度变为O(1)，但我们计算时间复杂度的时间总是考虑最坏的情况，而这种情况出现的几率比较小，所以复杂度还是记为O(n)

均摊复杂度

假设给一个长度为8的数组添加元素，每次都是给数组的最后一个位置添加元素(记为addList)，此时执行9此添加操作才会执行一次resize（扩容）操作，总共进行了17此基本操作
平均每次addList()操作，进行2次基本操作

假设数组容量为n，执行n+1次addLast，执行resize，总共进行了2n+1次基本操作
平均每次addLast操作，进行2次基本操作
这样均摊计算，时间复杂度是O(1)的
在这个例子里，这样均摊计算，比计算最坏情况有意义
删除数组最后位置的元素(removeLast)操作同理

复杂度的震荡

当数组空间已经装满，此时再添加元素(addLast)，需要先进行扩容操作，时间复杂度变为O(n)
元素添加后，再删除最后位置的元素(removeLast)，此时数组的元素数量为数组大小的一半，进行缩容操作，时间复杂度变为O(n)
重复进行这两次操作时，时间复杂度一直都为O(n),如何解决？
解决办法：
扩容操作不变，缩容操作时，当数组元素个数变为数组容量大小的1/4时，在进行缩容操作

public E remove(int index){
        if(index<0 || index>=size){
            throw new IllegalArgumentException("你输入的索引不合法");
        }

        E result = data[index];

        for (int i = index+1; i < size; i++) {
            data[i-1] = data[i];
        }
        size--;
        data[size] = null;

        if(size == data.length/4 && data.length/2!=0){
            resize(data.length/2);
        }
        return result;
    }