(一)概念
线性表在内存中是一块连续的存储空间。
只要知道第一个元素在内存中的位置,其他元素的位置就不难知道。
访问第N个元素的时间是o(1),但是要在数组中查找指定的数据则时间复杂度为O(N),当向数组中插入或者删除某个数据时的事件复杂度为O(n),因为插入或者删除任意元素后面的元素都要做出相应的移动。、
(二)特性
(1)同一性。保存的是同一类型的元素
(2)序偶性。除了第一个元素,其他元素有且仅有唯一一个直接前驱,除了最后一个元素,其他元素有且仅有唯一一个直接后继;
(3)索引性。元素的下标唯一确定了该元素在表中的位置;
(三)与链表的区别
链表是在非连续的内存空间中保存数据,当查找某个数据的时候,事件复杂度为O(N),因为链表中保存的是数据以及指向下一元素的链接信息。
但是插入和删除操作的事件复杂度是O(1)
因为只要改变相应位置的指针信息,而不用移动位置。
(四)线性表的实现
(1)数组实现线性表
/**
* 自己用数组实现的线性表
*/
public class ArrayList<E> {
Object[] data = null;// 用来保存此队列中内容的数组
int current;// 保存当前为第几个元素的指标
int capacity;// 表示数组大小的指标
/**
* 如果初始化时,未声明大小,则默认为10
*/
public ArrayList() {
this(10);
}
/**
* 初始化线性表,并且声明保存内容的数组大小
* @param initalSize
*/
public ArrayList(int initalSize) {
if (initalSize < 0) {
throw new RuntimeException("数组大小错误:" + initalSize);
} else {
this.data = new Object[initalSize];
this.current = 0;
capacity = initalSize;
}
}
/**
* 添加元素的方法 添加前,先确认是否已经满了
* @param e
* @return
*/
public boolean add(E e) {
ensureCapacity(current);// 确认容量
this.data[current] = e;
current++;
return true;
}
/**
* 确认系统当前容量是否满足需要,如果满足,则不执行操作 如果不满足,增加容量
* @param cur 当前个数
*/
private void ensureCapacity(int cur) {
if (cur == capacity) {
// 如果达到容量极限,增加10的容量,复制当前数组
this.capacity = this.capacity + 10;
Object[] newdata = new Object[capacity];
for (int i = 0; i < cur; i++) {
newdata[i] = this.data[i];
}
this.data = newdata;
}
}
/**
* 得到指定下标的数据
* @param index
* @return
*/
public E get(int index) {
validateIndex(index);
return (E) this.data[index];
}
/**
* 返回当前队列大小
* @return
*/
public int size() {
return this.current;
}
/**
* 更改指定下标元素的数据为e
* @param index
* @param e
* @return
*/
public boolean set(int index, E e) {
validateIndex(index);
this.data[index] = e;
return true;
}
/**
* 验证当前下标是否合法,如果不合法,抛出运行时异常
* @param index 下标
*/
private void validateIndex(int index) {
if (index < 0 || index > current) {
throw new RuntimeException("数组index错误:" + index);
}
}
/**
* 在指定下标位置处插入数据e
* @param index 下标
* @param e 需要插入的数据
* @return
*/
public boolean insert(int index, E e) {
validateIndex(index);
Object[] tem = new Object[capacity];// 用一个临时数组作为备份
//开始备份数组
for (int i = 0; i < current; i++) {
if (i < index) {
tem[i] = this.data[i];
}else if(i==index){
tem[i]=e;
}else if(i>index){
tem[i]=this.data[i-1];
}
}
this.data=tem;
return true;
}
<br><br>/**<br> * 删除指定下标出的数据<br> * @param index<br> * @return<br> */<br> public boolean delete(int index){<br> validateIndex(index);<br> Object[] tem = new Object[capacity];// 用一个临时数组作为备份<br> //开始备份数组<br> for (int i = 0; i < current; i++) {<br> if (i < index) {<br> tem[i] = this.data[i];<br> }else if(i==index){<br> tem[i]=this.data[i+1];<br> }else if(i>index){<br> tem[i]=this.data[i+1];<br> }<br> }<br> this.data=tem;<br> return true;<br> }<br><br>}
(2)链表的实现
思路:1.链表采用链式存储结构,在内部只需要将一个一个结点链接起来。(每个结点中有关于此结点下一个结点的引用)
链表操作优点:1.,因为每个结点记录下个结点的引用,则在进行插入和删除操作时,只需要改变对应下标下结点的引用即可
缺点:1.要得到某个下标的数据,不能通过下标直接得到,需要遍历整个链表。
/**
* 自己用链式存储实现的线性表
*/
public class LinkedList<E> {
private Node<E> header = null;// 头结点
int size = 0;// 表示数组大小的指标
public LinkedList() {
this.header = new Node<E>();
}
public boolean add(E e) {
if (size == 0) {
header.e = e;
} else {
// 根据需要添加的内容,封装为结点
Node<E> newNode = new Node<E>(e);
// 得到当前最后一个结点
Node<E> last = getNode(size-1);
// 在最后一个结点后加上新结点
last.addNext(newNode);
}
size++;// 当前大小自增加1
return true;
}
public boolean insert(int index, E e) {
Node<E> newNode = new Node<E>(e);
// 得到第N个结点
Node<E> cNode = getNode(index);
newNode.next = cNode.next;
cNode.next = newNode;
size++;
return true;
}
/**
* 遍历当前链表,取得当前索引对应的元素
*
* @return
*/
private Node<E> getNode(int index) {
// 先判断索引正确性
if (index > size || index < 0) {
throw new RuntimeException("索引值有错:" + index);
}
Node<E> tem = new Node<E>();
tem = header;
int count = 0;
while (count != index) {
tem = tem.next;
count++;
}
return tem;
}
/**
* 根据索引,取得该索引下的数据
*
* @param index
* @return
*/
public E get(int index) {
// 先判断索引正确性
if (index >= size || index < 0) {
throw new RuntimeException("索引值有错:" + index);
}
Node<E> tem = new Node<E>();
tem = header;
int count = 0;
while (count != index) {
tem = tem.next;
count++;
}
E e = tem.e;
return e;
}
public int size() {
return size;
}
/**
* 设置第N个结点的值
*
* @param x
* @param e
* @return
*/
public boolean set(int index, E e) {
// 先判断索引正确性
if (index > size || index < 0) {
throw new RuntimeException("索引值有错:" + index);
}
Node<E> newNode = new Node<E>(e);
// 得到第x个结点
Node<E> cNode = getNode(index);
cNode.e = e;
return true;
}
/**
* 用来存放数据的结点型内部类
*/
class Node<e> {
private E e;// 结点中存放的数据
Node() {
}
Node(E e) {
this.e = e;
}
Node<E> next;// 用来指向该结点的下一个结点
// 在此结点后加一个结点
void addNext(Node<E> node) {
next = node;
}
}
}