其他分享
首页 > 其他分享> > 0033数组结构之数组

0033数组结构之数组

作者:互联网

数组中只能存放同一种类型的数据

数组定义:1、只设定长度 2、不设定长度,但是直接给数组赋值

int[] arr = new int[10];

int[] scores = new int[]{100,99,98};

 

1、  定义数组类Array

2、  向数组中添加元素,最后位置添加和指定位置 添加、起始位置添加

3、  查询数组中的元素和修改元素

先重写toString()方法,main方法中测试该方法

4、  数组中的包含、搜索和删除指定索引、删除数组第一个元素、删除数组最后一个元素、删除指定元素(按元素值删除,之前的都是按索引位置删除)

package array;

//定义数组类
public class Array {
    //存放数组数据
   
private int[] data;
    //数组中存放的元素个数,且需要明白size总是指向的待添加元素的位置
   
private int size;

    //定义数组的容量
   
public Array(int capacity){
        data = new int[capacity];
        //初始的元素个数为0
       
size = 0;
    }

    //如果未定义容量,则使用默认容量
   
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){
        /*//如果数组元素个数等于数组长度,则不能再增加,抛异常,后期会讲解扩容
        if(size == data.length){
            throw new IllegalArgumentException("add failed! Array is full.");
        }
        data[size] = e;
        size++;*/
        //
由上边的写法改为复用add方法
       
add(size,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! Required index>=0 and index<=size.");
        }
        //向后移动元素、指定位置插入元素、size++
       
for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index] = e;
        size++;
    }

    //向数组开头加入元素
   
public void addFirst(int e){
        add(0,e);
    }

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

    //更改索引位置的元素为指定元素
   
public void set(int index,int e){
        if (index<0 || index >=size){
            throw new IllegalArgumentException("get failed!index is illegal.");
        }
        data[index] = e;
    }

    //判断数组中是否包含指定元素
   
public boolean contains(int e){
        for(int i=0;i<size;i++){
            if(data[i] == e){
                return true;
            }
        }
        return false;
    }
    //查找元素在数组中的位置
   
public int find(int e){
        for(int i=0;i<size;i++){
            if(data[i] == e){
                return i;
            }
        }
        //如果元素在数组中不存在,返回-1
       
return -1;
    }

    //删除指定索引位置的元素,并返回该元素值
   
public int remove(int index){
        //判断索引位置是否合法、保存删除位置的元素值做为返回值,元素前移、size--、返回元素
       
if (index<0 || index >=size){
            throw new IllegalArgumentException("remove 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);
    }

    //删除数组中U最后一个元素
   
public int removeLast(){
        return remove(size-1);
    }

    //根据元素值删除数组中的元素
   
public void removeElement(int e){
        int index = find(e);
        //元素在数组中存在才进行删除操作
       
if(index != -1){
            remove(index);
        }
    }


    //删除数组中第一个位置的元素
   
//删除数组中最后一个位置的元素
    
//根据元素值删除元素

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

 

package array;

public class Main {
    public static void main(String[] args) {
        //测试自定义Array类的addLasttoString方法
       
Array arr = new Array(20);
        for(int i=0;i<10;i++){
            arr.addLast(i);
        }
        System.out.println(arr.toString());
        //测试add方法
       
arr.add(1,200);
        System.out.println(arr.toString());
        //测试addFirst方法
       
arr.addFirst(-1);
        System.out.println(arr.toString());

        boolean flag = arr.contains(8);
        System.out.println("测试是否包含8"+flag);
        arr.remove(5);
        System.out.println(arr.toString());
        arr.removeFirst();
        System.out.println(arr.toString());
        arr.removeLast();
        System.out.println(arr.toString());
        arr.removeElement(200);
        System.out.println(arr.toString());

    }
}

 

 

5、  泛型在数组中的应用

以上设计的数组最大的问题,就是只能存放int类型的数据,而实际中数组做为容器应该能够存放任意类型的数据

改为泛型时需要注意事项:

1)  创建数组对象的方式

2)  contains()、find等方法中做比较的时候,不应该再用==引用比较,而应该使用equals进行值比较

3)  删除指定位置元素时,由于后边的元素前移,且size—后,最后size所指向的位置,实际上还保留着之前的最后一个元素,导致无法进行垃圾回收,应该手动将该值设置为null;

改后的Array类编码如下:

package array;

//定义数组类
public class Array<E> {
    //存放数组数据
   
private E[] data;
    //数组中存放的元素个数,且需要明白size总是指向的待添加元素的位置
   
private int size;

    //定义数组的容量
   
public Array(int capacity){
        //data = new E[capacity]; 这种写法语法上是不对的,应该写成如下写法
       
data = (E[])new Object[capacity];
        //初始的元素个数为0
       
size = 0;
    }

    //如果未定义容量,则使用默认容量
   
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){
        /*//如果数组元素个数等于数组长度,则不能再增加,抛异常,后期会讲解扩容
        if(size == data.length){
            throw new IllegalArgumentException("add failed! Array is full.");
        }
        data[size] = e;
        size++;*/
        //
由上边的写法改为复用add方法
       
add(size,e);
    }

    //向数组任意位置加入元素
   
public void add(int index,E e){
        //如果数组元素个数等于数组长度,则不能再增加,抛异常,后期会讲解扩容
        
if(size == data.length){
            throw new IllegalArgumentException("add failed! Array is full.");
        }
        //判断欲插入的元素的下标位置是否正确
       
if(index<0 || index > size){
            throw new IllegalArgumentException("add failed! Required index>=0 and index<=size.");
        }
        //向后移动元素、指定位置插入元素、size++
       
for(int i=size-1;i>=index;i--){
            data[i+1]=data[i];
        }
        data[index] = e;
        size++;
    }

    //向数组开头加入元素
   
public void addFirst(E e){
        add(0,e);
    }

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

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

    //判断数组中是否包含指定元素
   
public boolean contains(E e){
        for(int i=0;i<size;i++){
            if(data[i].equals(e)){
                return true;
            }
        }
        return false;
    }
    //查找元素在数组中的位置
   
public int find(E e){
        for(int i=0;i<size;i++){
            if(data[i].equals(e)){
                return i;
            }
        }
        //如果元素在数组中不存在,返回-1
       
return -1;
    }

    //删除指定索引位置的元素,并返回该元素值
   
public E remove(int index){
        //判断索引位置是否合法、保存删除位置的元素值做为返回值,元素前移、size--、返回元素
       
if (index<0 || index >=size){
            throw new IllegalArgumentException("remove failed!index is illegal.");
        }
        E ret = data[index];
        for(int i=index+1;i<size;i++){
            data[i-1] = data[i];
        }
        size--;
        data[size] = null;
        return ret;
    }

    //删除数组中的第一个元素
   
public E removeFirst(){
        return remove(0);
    }

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

    //根据元素值删除数组中的元素
   
public void removeElement(E e){
        int index = find(e);
        //元素在数组中存在才进行删除操作
       
if(index != -1){
            remove(index);
        }
    }

    //删除数组中第一个位置的元素
   
//删除数组中最后一个位置的元素
   
//根据元素值删除元素

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

}

 

4)  在测试的时候,即在使用Array类创建对象的时候,需要用<>指定存放的具体数据类型,其他内容都不用动

//也可以写成Array<Integer> arr = new Array(20);
Array<Integer> arr = new Array<Integer>(20);

 

5)  编写自定义类,并测试Array类中存储自定义类

package array;

public class Employee {
    private String name;
    private int age;

    public Employee(String name,int age){
        this.name=name;
        this.age=age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

    public static void main(String[] args) {
        //不指定长度,Array类中定义的默认10
       
Array<Employee> emps = new Array<>();
        emps.addLast(new Employee("zhangsan",18));
        emps.addLast(new Employee("lisi",20));
        emps.addLast(new Employee("wangwu",35));
        System.out.println(emps);
    }
}

 

6、  动态数组

以上定义的代码使用的是静态数组,而我们实际工作中,有些时候是不能预估数组需要存放数据的多少的,因此使用动态数组解决该问题

1)  定义私有的扩容方法resize(int newCapacity)

思想:定义新的数组,将旧数组的内容循环遍历拷贝进新的数组,原数组的声明变量指向新的数组

2)  新增元素和删除元素的方法中增加判断的方法,新增时当元素个数达到数组的长度(容量)时,调用resize方法进行扩容;删除元素时,当元素个数为数组容量的一半时,调用resize方法进行缩容

精髓就是定义新的数组,使原有数组指向新的数组,同时会放弃原有数组的引用

resize方法如下:

//数组动态扩容
public void resize(int newCapacity){
    E[] newData = (E[])new Object[newCapacity];
    for(int i=0;i<size;i++){
        newData[i] = data[i];
    }
    //使data数组指向新的引用
   
data = newData;
}

add方法如下:

//向数组任意位置加入元素
public void add(int index,E e){
    //判断欲插入的元素的下标位置是否正确
   
if(index<0 || index > size){
        throw new IllegalArgumentException("add failed! Required index>=0 and index<=size.");
    }
    //如果数组元素个数等于数组长度,则进行动态扩容,但是扩容涉及到数组中元素的循环复制,要考虑效率
   
if(size == data.length){
        resize(2 * data.length);
    }

    //向后移动元素、指定位置插入元素、size++
   
for(int i=size-1;i>=index;i--){
        data[i+1]=data[i];
    }
    data[index] = e;
    size++;
}

remove方法如下:

//删除指定索引位置的元素,并返回该元素值
public E remove(int index){
    //判断索引位置是否合法、保存删除位置的元素值做为返回值,元素前移、size--、返回元素
   
if (index<0 || index >=size){
        throw new IllegalArgumentException("remove failed!index is illegal.");
    }
    E ret = data[index];
    for(int i=index+1;i<size;i++){
        data[i-1] = data[i];
    }
    size--;
    data[size] = null;
    //当元素个数为数组容量的一半时进行动态缩容
   
if(size == data.length/2){
        resize(data.length/2);
    }
    return ret;
}

 

 

7、  时间复杂度分析

O(1)、O(n)、O(lgn)、O(nlogn)、O(n^2)

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

为什么要用大O,叫做O(n):忽略常数,实际时间T=c1*n+c2

如T=2*n+3 和T=10000*n + 20000时间复杂度都是O(n),都是线性时间的算法

T=2*n*n+3 和T=1*n*n +300*n +20的时间复杂度都是O(n^2)

addLast(e): O(1)

addFirst(e):O(n)

add(index,e):O(n/2)=O(n),1/2是常数,所以O(n/2)=O(n)

所以添加添加整体上是O(n)的时间复杂度,即算法分析,我们主要关心的是最坏的情况下的时间复杂度。

删除操作时间复杂度O(n)

修改操作时间负责度O(1)

查找:get(index)时间复杂度O(1),contains(e)时间复杂度O(n),find(e)时间复杂度O(n)

总结:

增加时间复杂度O(n),

删除时间复杂度O(n),

修改:已知索引时间复杂度O(1),未知索引时间复杂度O(n)

查询:已知索引时间复杂度O(1),未知索引时间复杂度O(n)

 

8、  均摊复杂度和防止复杂度震荡

增加最后一个元素和删除最后一个元素,简单看是O(1)的,但是如果考虑到resize,而resize是需要复制一个数组的元素给另外一个数组的,所以是O(n)级别的,但是这种情况使用最坏的时间复杂度分析是不合理的,因为必须满足扩容或者缩容的情况下才会进行resize,这种概率是极低的,不应该用这种分析,而是用均摊时间复杂度,n次操作导致一次resize,而一次resize会移动n次并插入1次,相当于插入n次共做了2n+1次基本操作,相当于做一次插入需要2次的基本操作,所以addLast(e)与数组中元素的个数n并无关系,所以实际上还是O(1)时间复杂度的。

复杂度震荡:达到扩容的条件,进行添加,会进行扩容,而添加完又进行删除,此时会进行缩容,即在扩容缩容临界点反复进行增加和删除,每次都会的时间复杂度都是O(n)

解决办法:不要过于着急的缩容,即不是在数组中元素个数为容量的1/2时就进行缩容,而是等到数组中元素个数为容量的1/4时再进行缩容,且缩容为数组容量的1/2,留出空闲空间给新增元素时使用,防止新增就扩容

         修改remove(index)方法中缩容部分的代码为如下:

 //当元素个数为数组容量的一半时进行动态缩容
/*if(size == data.length/2){
    resize(data.length/2);
}*/
//
由元素个数为1/2容量时就进行缩容,改为元素个数为1/4容量时才进行缩容,
//且需要保证1/2容量时数组容量不等于0,因为创建数组的长度是不能为0
if(size == data.length/4 && data.length/2!=0){
    resize(data.length/2);
}

如有理解不到之处,望沟通指正!

标签:index,int,元素,0033,数组,结构,data,size
来源: https://www.cnblogs.com/xiao1572662/p/12090869.html