線性表
定義
將具有線性關係的資料儲存到計算機中所使用的儲存結構稱為線性表。
線性，是指資料在邏輯結構上具有線性關係。
分類
邏輯結構上相鄰的資料在物理結構儲存分兩種形式：
- 資料在記憶體中集中儲存，採用順序表示結構，稱為"順序儲存"；
- 資料在記憶體中分散儲存，採用鏈式表示結構，稱為"鏈式儲存"；
順序表
定義
邏輯上具有線性關係的資料按照前後的次序全部儲存在一整塊連續的記憶體空間中，之間不存在空隙，這樣的儲存結構稱為順序儲存結構。
使用線性表的順序儲存結構生成的表，稱為順序表。
實現
順序表的存放資料的特點和陣列一樣，所以我們這裡採用陣列來實現，這裡我們來用陣列來簡單實現Java中常用的ArrayList。
介面定義：
package one.wangwei.algorithms.datastructures.list;
/**
* List Interface
*
* @param <T>
* @author https://wangwei.one/
* @date 2018/04/27
*/
public interface IList<T> {
/**
* add element
*
* @param element
* @return
*/
public boolean add(T element);
/**
* add element at index
*
* @param index
* @param element
* @return
*/
public boolean add(int index, T element);
/**
* remove element
*
* @param element
* @return
*/
public boolean remove(T element);
/**
* remove element by index
*
* @param index
* @return
*/
public T remove(int index);
/**
* set element by index
*
* @param index
* @param element
* @return old element
*/
public T set(int index, T element);
/**
* get element by index
*
* @param index
* @return
*/
public T get(int index);
/**
* clear list
*/
public void clear();
/**
* contain certain element
*
* @param element
* @return
*/
public boolean contains(T element);
/**
* get list size
*
* @return
*/
public int size();
}
複製程式碼介面實現：
package one.wangwei.algorithms.datastructures.list.impl;
import one.wangwei.algorithms.datastructures.list.IList;
import java.util.Arrays;
/**
* Array List
*
* @param <T>
* @author https://wangwei.one
* @date 2018/04/27
*/
public class MyArrayList<T> implements IList<T> {
/**
* default array size
*/
private final int DEFAULT_SIZE = 10;
/**
* array size
*/
private int size = 0;
/**
* array
*/
private T[] array = (T[]) new Object[DEFAULT_SIZE];
/**
* add element
*
* @param element
* @return
*/
@Override
public boolean add(T element) {
return add(size, element);
}
/**
* add element at index
*
* @param index
* @param element
* @return
*/
@Override
public boolean add(int index, T element) {
if (index < 0 || index > size) {
throw new ArrayIndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
// need grow
if (size >= array.length) {
grow();
}
// copy array element
if (index < size) {
System.arraycopy(array, index, array, index + 1, size - index);
}
array[index] = element;
size++;
return true;
}
/**
* grow 50%
*/
private void grow() {
int growSize = size + (size >> 1);
array = Arrays.copyOf(array, growSize);
}
/**
* remove element
*
* @param element
* @return
*/
@Override
public boolean remove(T element) {
for (int i = 0; i < size; i++) {
if (element == null) {
if (array[i] == null) {
remove(i);
return true;
}
} else {
if (array[i].equals(element)) {
remove(i);
return true;
}
}
}
return false;
}
/**
* remove element by index
*
* @param index
* @return
*/
@Override
public T remove(int index) {
checkPositionIndex(index);
T oldElement = array[index];
// need copy element
if (index != (size - 1)) {
System.arraycopy(array, index + 1, array, index, size - index - 1);
}
--size;
array[size] = null;
// shrink 25%
int shrinkSize = size - (size >> 2);
if (shrinkSize >= DEFAULT_SIZE && shrinkSize > size) {
shrink();
}
return oldElement;
}
/**
* shrink 25%
*/
private void shrink() {
int shrinkSize = size - (size >> 2);
array = Arrays.copyOf(array, shrinkSize);
}
/**
* set element by index
*
* @param index
* @param element
* @return
*/
@Override
public T set(int index, T element) {
checkPositionIndex(index);
T oldElement = array[index];
array[index] = element;
return oldElement;
}
/**
* get element by index
*
* @param index
* @return
*/
@Override
public T get(int index) {
checkPositionIndex(index);
return array[index];
}
/**
* check index
*
* @param index
*/
private void checkPositionIndex(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
}
/**
* clear list
*/
@Override
public void clear() {
for (int i = 0; i < size; i++) {
array[i] = null;
}
size = 0;
}
/**
* contain certain element
*
* @param element
*/
@Override
public boolean contains(T element) {
for (int i = 0; i < size; i++) {
if (element == null) {
if (array[i] == null) {
return true;
}
} else {
if (array[i].equals(element)) {
return true;
}
}
}
return false;
}
/**
* get list size
*
* @return
*/
@Override
public int size() {
return size;
}
}
複製程式碼主要注意以下幾點：
- 新增元素時 ，判斷是否需要對Array進行擴容；
- 刪除元素時，判斷是否需要對Array進行收縮；
- remove與contains介面，注意element為null的情況；
特點
- 對資料進行遍歷的時候，資料在連續的物理空間中進行存放，CPU的內部快取結構會快取連續的記憶體片段，可以大幅降低讀取記憶體的效能開銷，所以查詢比較快；
- 刪除線性表中的元素的時候，後面的元素會整體向前移動，所以刪除的效率較低，插入類似，時間複雜度為O(n)；