玩转数据结构<一> 数组

GankGintama
252 阅读6分钟

数组

  • 数组最大的优点： 快速查询

  • 数组最好应用于"索引有语意"的情况

  • 但并非所有有语意的索引都适用于数组

  • 数组也可以处理“索引没有语意”的情况

  • 封装数组

public class Array{
    private int[] data;
    private int size;
    //构造函数，传入数组的容量capacity 构造函数
    public Array(int capacity){
        data = new int[capacity];
        size = 0;
    }
    //无参数的构造函数，默认数组的容量capacity = 10
    public Array(){
        this(10);
    }

    //获取数组中的元素个数
    public int getSize(){
        return size;
    }

    //获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    //判断数组是否为空
    public boolean isEmpty(){
        return size == 0 ;
    }

    public void addLast(int e){
        add(size,e);
    }

    public void addFirst(int e){
        add(0,e);
    }

    //在第index个位置插入一个新元素e
    public void add(int index, int e){
        if(size == data.length){
            throw new IllegalArgumentException("Add failed. Array is full.");
        }
        

        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0 and index < size.");
        }

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

    //获取index索引位置的元素为e
    int get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        return data[index];
    }
    
    //修改index索引位置的元素为e
    void set(int index, int e){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        data[index] = e;
    }
    
    //查找数组中是否有元素e
    public boolean contains(int e){
        for(int i = 0 ; i < size; i ++){
            if(data[i] == e){
                return true;
            }
        }
        return false;
    }
    
    //查找数组中元素e所在的索引，如果不存在元素e,则返回-1
    public int find(int e){
    for(int i = 0 ; i < size; i ++){
            if(data[i] == e){
                return i;
            }
        }
        return -  1;  
    }
    
    //从数组删除index位置的元素，返回删除的元素
    public int remove(int index){
          if(index < 0 || index >= size){
          throw new IllegalArgumentException("Get failed. Index is illegal.");
      } 
      
      int ret = data[index];
      for(int i = index + 1; i < size; i++){
          data[i - 1] = data[i];
      }
      size --;
      return ret;
    }
    
    //从数组中删除最后一个元素，返回删除的元素
    public int removeFirst(){
        return remove(0);
    }    
    
    //从数组中删除最后一个元素，返回删除的元素
    public int removeLast(){
        return remove(size - 1);
    }
    
    // 从数组中删除元素e
    public void removeElement(int e){
        int index = find(e);
        if(index != -1){
            remove(index);
        }
    }
    
    
   
  @Override
    public String toString(){

        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i++ ){
            res.append(data[i]);
            if(i != size - 1){
                res.append(",");
            }
        }
        res.append(']');
        return res.toString();
    }
}
  • 调用封装数组
public static void mai(String[] args){
Array arr = new Array(20);
 
}

泛型

  • 让我们的数据结构可以放置“任何”数据类型

  • 不可以是基本数据类型，只能是类对象 （boolean,byte,char,short,int,long,float,double）

  • 每个基本数据类型都有对应的包装类 （Boolean,Byte,Char,Short,Int,Long,Float,Double）

  • 泛型封装数组

public class Array<E>{
    private E[] data;
    private int size;
    //构造函数，传入数组的容量capacity 构造函数
    public Array(int capacity){
        data = (E[])new Object[capacity];
        size = 0;
    }
    //无参数的构造函数，默认数组的容量capacity = 10
    public Array(){
        this(10);
    }

    //获取数组中的元素个数
    public int getSize(){
        return size;
    }

    //获取数组的容量
    public int getCapacity(){
        return data.length;
    }

    //判断数组是否为空
    public boolean isEmpty(){
        return size == 0 ;
    }

    public void addLast(E e){
        add(size,e);
    }

    public void addFirst(E e){
        add(0,e);
    }

    public void add(int index, E e){

        if(index < 0 || index > size){
            throw new IllegalArgumentException("Add failed. Require index >= 0  and index < size.");
        }

        //进行扩容 实现动态数组
        if(size == data.length){
            resize(2*data.length);
        }

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

    //获取index索引位置的元素为e
    public E get(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        return data[index];
    }

    //修改index索引位置的元素为e
    void set(int index, E e){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }
        data[index] = e;
    }

    //查找数组中是否有元素e
    public boolean contains(E e){
        for(int i = 0 ; i < size; i ++){
            if(data[i].equals(e)){
                return true;
            }
        }
        return false;
    }

    //查找数组中元素e所在的索引，如果不存在元素e,则返回-1
    public int find(E e){
        for(int i = 0 ; i < size; i ++){
            if(data[i].equals(e)){
                return i;
            }
        }
        return -  1;
    }

    //从数组删除index位置的元素，返回删除的元素
    public E remove(int index){
        if(index < 0 || index >= size){
            throw new IllegalArgumentException("Get failed. Index is illegal.");
        }

        E ret = data[index];
        for(int i = index + 1; i < size; i++){
            data[i - 1] = data[i];
        }
        size --;
        //此时size--后，size还是指向一个对象，需要java回收机制回收此对象，释放资源 loitering objects != memory leak
        data[size] = null;

        //layz 惰性缩减容量
        if(size == data.length / 4 && data.length /2 != 0){
            resize(data.length / 2);
        }
        return ret;
    }

    //从数组中删除最后一个元素，返回删除的元素
    public E removeFirst(){
        return remove(0);
    }

    //从数组中删除最后一个元素，返回删除的元素
    public E removeLast(){
        return remove(size - 1);
    }

    // 从数组中删除元素e
    public void removeElement(E e){
        int index = find(e);
        if(index != -1){
            remove(index);
        }
    }

    public E getLast(){
        return get(size - 1);

    }
    public E getFirst(){
        return get(0);

    }

    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i++ ){
            res.append(data[i]);
            if(i != size - 1){
                res.append(",");
            }
        }
        res.append(']');
        return res.toString();
    }

    private void resize(int newCapacity){
        E[] newData = (E[]) new Object[newCapacity];
        for(int i = 0 ; i < size ; i++){
            newData[i] = data[i];
        }
        //data指向newData
        data = newData;
    }

}
  • 调用泛型封装数组
public static void mai(String[] args){
Array<Integer> arr = new Array<>(20);
 
}

动态数组

简单复杂度分析

  • O(1) ,O(n),O(nlogn),O(n^2)
  • 大O简单描述的是算法的运行时间和输入数据之间的关系

*O(n) n是nums中的元素个数 算法和n呈线性关系 *为什么要用大O,叫做O(n)? 忽略常数。实际时间 T=c1 * n+c2

  • 渐进时间复杂度 描述n趋近于无穷的情况
public static int sum(int [] nums){
    int sum = 0;
    for(int num: nums){
        sum += num;
        return num;
    }
}

  • 添加操作

  • addLast(e) O(1)

  • addFirst(e) O(n)

  • add(index,e) O(n/2) = O(n)

  • resize O(n)

  • 总体而言 添加操作是O(n) 严格计算出是需要一些概率论知识

  • 删除操作

  • removeLast(e) O(1)

  • removFirst(e) O(n)

  • remove(index,e) O(n/2) = O(n)

  • resize O(n)

  • 总体而言 删除操作是O(n)

  • 修改操作

  • set(index,e) O(1n)

  • 查找操作

  • get(index) O(1)

  • contains(e) O(n)

  • find(e) O(n)

均摊复杂度和防止复杂度的震荡

均摊复杂度

  • 假设当前capacity = 8,并且每一次添加操作都使用addLast,9次addLast操作，触发resize，总共进行了17次基本操作
  • 平均，每次addLast,进行2次基本操作
  • 假设capacity = n,n+1次addLast,触发resize,总共进行2n+1次基本操作，平均，每次addLast操作，进行2次基本操作
  • 这样均摊计算，时间复杂度是O(1)
  • 同样，removeLast操作，时间复杂度也是O(1)

复杂度震荡

  • 进行addLast之后接着进行removeLast操作，使操作进行扩容，缩容，每次操作都是O(n)
  • 问题原因: removeLast时 resize过于着急（Eager）
  • 解决方案： Lazy
  • 当size == capacity /4时，才将capacity减半
avatar
文章
阅读
粉丝