資料結構 陣列實現線性表

通過陣列實現了一個簡單的線性表

功能:

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. 存取元素需要對陣列進行元素移動或者複製陣列,資料大的時候效率低