【数据结构】【二】数组实现的线性表(线性表的顺序存储结构)

数据结构 数组实现线性表

通过数组实现了一个简单的线性表

功能:

1. 在数组尾部添加元素
2. 在数组指定位置添加元素
3. 根据下标获取元素
4. 根据下标删除元素
5. 根据元素删除元素
6. 获取当前数组长度
7. 判断当前数组是否为空
8. 打印数组元素

public class ArrayListTest {

	private Object[] elements;//存储数据

	private  static final Object[] EMPTY_ARRAY = {};//空数组

	/**
	 * 创建一个空数组
	 */
	public ArrayListTest(){
	    this.elements = EMPTY_ARRAY;
	}
	

	/**
	 * 在数组尾部添加元素
	 */
	public void add(Object element){
	    //因为添加数据,所以创建一个长度比原数组多一个元素的数组
	    Object[] newArr = new Object[elements.length + 1];
	    //复制数组
	    for(int i = 0; i< elements.length; i++){
	    	newArr[i] = elements[i];
	    }
	    //在新数组尾部添加元素
	    newArr[elements.length] = element;
	    //将新数组重新赋值给原数组
	    this.elements = newArr;
	}
	
	/**
	 * 在数组指定位置添加元素
	 */
	public void insert(int index, Object element){
	    //判断数组下标越界
	    if(index < 0 || index >= elements.length){
	    	throw new RuntimeException("数组下标越界");
	    }
	    //因为添加数据,所以创建一个长度比原数组多一个元素的数组
	    Object[] newArr = new Object[elements.length + 1];
	    //复制数组
	    for(int i = 0; i< newArr.length; i++){
		if(i < index){
	       	    //index之前的全部复制
		    newArr[i] = elements[i];
		}else if(index == i){
		    //index这个下标赋值为element
	       	    newArr[i] = element;
		}else{
		    //index之后的全部赋值为原数组下标-1的元素
		    newArr[i] = elements[i - 1];
		}
	    }
	    //将新数组重新赋值给原数组
	    this.elements = newArr;
	}
	
	/**
	 * 根据下标获取元素
	 */
	public Object get(int index){
	    //判断数组下标越界
	    if(index < 0 || index >= elements.length){
		throw new RuntimeException("数组下标越界");
	    }
	    return elements[index];
	}
	
	/**
	 * 根据下标删除元素
	 */
	public void delete(int index){
	    //判断数组下标越界
	    if(index < 0 || index >= elements.length){
		throw new RuntimeException("数组下标越界");
	    }
	    //因为删除数据,所以创建一个长度比原数组少一个元素的数组
	    Object[] newArr = new Object[elements.length - 1];
	    //复制数组
	    for(int i = 0; i< newArr.length; i++){
	    	if(i < index){
		    //index之前的全部复制
		    newArr[i] = elements[i];
		}else{
		    //跳过index这个下标复制
		    newArr[i] = elements[i + 1];
		}
	    }
	    //将新数组重新赋值给原数组
	    elements = newArr;
	}
	
	/**
	 * 根据元素删除元素
	 */
	public void deleteElement(Object object){
	    Integer index = null;
	    //找出原数组中第一次出现object元素的位置
	    for(int i = 0; i< elements.length; i++){
		if(object.equals(elements[i])){
		    index = i;
		    break;
		}
	    }
	    if(index != null){
		delete(index);
	    }else{
		System.out.println("数组中没有这个元素");
	    }
	}
	
	/**
         * 获取当前数组长度
         */
	public int size(){
	    return elements.length;
	}
	
        /**
         * 判断当前数组是否为空
         */
        public boolean isEmpty(){
            return elements.length == 0;
        }
    
        /**
         * 打印数组
         */
	public void show(ArrayListTest arrayTest){
	    System.out.println(Arrays.toString(arrayTest.elements));
	}
	
	public static void main(String[] args) {
	    ArrayListTest arrays = new ArrayListTest();
	    arrays.add(1);
	    arrays.add(2);
	    arrays.add(3);
	    arrays.show(arrays);//[1, 2, 3]
		
	    arrays.insert(1, 0);
	    arrays.show(arrays);//[1, 0, 2, 3]
		
	    Object arrObj = arrays.get(1);
	    System.out.println(arrObj);//0
		
	    arrays.delete(2);
	    arrays.show(arrays);//[1, 0, 3]
		
	    arrays.deleteElement(3);
	    arrays.show(arrays);//[1, 0]
		
	    System.out.println(arrays.size());//2
	    System.out.println(arrays.isEmpty());//false

	}
}

优点:

1. 底层是数组,可以根据索引查询,查询效率高
2. 结构是随机存取结构,可以随时取出线性表中任意元素,存取时间复杂度为O(1)

缺点:

1. 存取元素需要对数组进行元素移动或者复制数组,数据大的时候效率低