杠上数据结构 - 线性表
Posted 星火燎原2016
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了杠上数据结构 - 线性表相关的知识，希望对你有一定的参考价值。
介绍
线性表 : 是由零个或多个数据元素组成的有限序列。
线性表有两种实现方式:
- 顺序结构存储 : 指的是一段地址连续的存储单元依次存储表中的数据元素。
- 链式结构存储 : 指的是各个元素存储的位置不是连续的, 他们之间通过指针域进行关联。
线性表顺序存储
线性表的顺序存储一般使用 数组 实现, 通过分配一块地址连续的内存空间来存储数据元素。
为方便和链式存储结构实现相同的操作，现将对表的操作抽取为接口中：
// List.java
public interface List<E>
/**
* 添加元素
*
* @param element
*/
void add(E element);
/**
* 添加一个线性表
*
* @param list
*/
void addAll(List<E> list);
/**
* 在指定位置上插入元素
*
* @param index
* @param element
*/
void insert(int index, E element);
/**
* 删除指定位置上元素
*
* @param index
*/
E remove(int index);
/**
* 删除元素
*
* @param element
*/
void remove(E element);
/**
* 替换元素
*
* @param target
* @param replace
*/
void replace(E target, E replace);
/**
* 获取指定位置上的元素
*
* @param index
* @return
*/
E get(int index);
/**
* 清空线性表
*/
void clear();
/**
* 判断线性表是否为空
*
* @return
*/
boolean isEmpty();
/**
* 获取线性表长度
*
* @return
*/
int size();
/**
* 返回某个元素第一次出现的位置
*
* @return
*/
int indexOf(E element);
/**
* 返回某个元素最后一次出现的位置
*
* @param element
* @return
*/
int lastIndexOf(E element);
/**
* 转换成数组
*
* @return
*/
Object[] toArray();
线性表顺序存储实现 ：
public class ArrayList<E> implements List<E>
/**
* 默认容器大小
*/
private int defaultCapacity = 10;
/**
* 存储容器
*/
private Object[] elements;
/**
* 元素个数
*/
private int size;
/**
* 默认容量的构造器
*/
public ArrayList()
elements = new Object[defaultCapacity];
/**
* 指定容器大小构造器
*
* @param capacity
*/
public ArrayList(int capacity)
elements = new Object[capacity];
/**
* 使用已有线性表创建新的线性表
*
* @param list
*/
public ArrayList(List<E> list)
this();
addAll(list);
/**
* 确保容器大小是否可用，是否扩容
*
* @param newSize
*/
public void ensureCapacity(int newSize)
if (newSize > elements.length)
increaseCapacity(newSize);
/**
* 扩大容器大小, 1.5 倍扩容
*/
private void increaseCapacity(int newSize)
int increasedSize = newSize;
increasedSize = increasedSize + increasedSize >> 1;
try
elements = Arrays.copyOf(elements, increasedSize);
catch (OutOfMemoryError error)
// 扩容失败
error.printStackTrace();
@Override
public void add(E element)
ensureCapacity(size + 1);
// size 增加 1
elements[size] = element;
size++;
@Override
public void addAll(List<E> list)
if (list == null)
return;
ensureCapacity(list.size() + size);
System.arraycopy(list.toArray(), 0, elements, size, list.size());
size += list.size();
@Override
public void insert(int index, E element)
if (index < 0 || index > size)
throw new IllegalArgumentException("index ");
ensureCapacity(size + 1);
System.arraycopy(elements, index, elements, index + 1, size - index);
elements[index] = element;
size++;
@Override
public E remove(int index)
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
E element = (E) elements[index];
System.arraycopy(elements, index + 1, elements, index, size - index - 1);
size--;
return element;
@Override
public void remove(E element)
@Override
public void replace(E target, E replace)
if (target == null)
for (int i = 0; i < elements.length; i++)
if (elements[i] == null)
elements[i] = replace;
else
for (int i = 0; i < elements.length; i++)
if (elements[i] == target)
elements[i] = replace;
@Override
public E get(int index)
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
return (E) elements[index];
@Override
public void clear()
elements = new Object[defaultCapacity];
size = 0;
@Override
public boolean isEmpty()
return size == 0;
@Override
public int size()
return size;
@Override
public int indexOf(E element)
if (element == null)
for (int i = 0; i < size; i++)
if (elements[i] == null)
return i;
else
for (int i = 0; i < size; i++)
if (elements[i].equals(element))
return i;
return -1;
@Override
public int lastIndexOf(E element)
if (element == null)
for (int i = size - 1; i >= 0; i++)
if (elements[i] == null)
return i;
else
for (int i = size - 1; i >= 0; i++)
if (elements[i].equals(element))
return i;
return -1;
private String outOfBoundsMsg(int index)
return "Index: " + index + ", Size: " + size;
public Object[] toArray()
return Arrays.copyOf(elements, size);
线性表顺序存储优缺点
优点 :
- 可以随机访问, 查找时间短 O(1) , 存储密度高;
- 逻辑上相邻的元素,物理上也相邻;
- 无需为表中的元素之间的逻辑关系而增加额外的存储空间;
缺点 :
- 插入, 删除操作时需要移动大量元素;
- 当线性表长度变化较大时,难以确定存储空间的容量;
- 当存储元素的个数小于申请的内存空间长度时,造成空间的浪费;
线性表链式存储
前面讲完了线性表中的顺序存储, 现在来一探究竟线性表的链式存储。线性表的链式存储是用一组任意的存储单元存储表中的数据元素，这组存储单元可以是连续的，也可以是不连续的，也就是说这些元素可以存在内存中未被占用的任意位置。
存储单元由两部分组成： 数据域 和 指针域 ，我们把这中存储单元称之为 节点 。
其中 数据域 存储元素数据，而指针域 存储后一个节点的 地址， 通常把前后与之相邻的两个节点称之为 前驱节点 和 后继节点。
节点使用 Java 描述：
/**
* 描述链表中的节点
*
* @param <E>
*/
public class Node<E>
/**
* 节点数据域中的数据
*/
public E data;
/**
* 节点指针域中指向下一个节点的指针
*/
public Node<E> next;
public Node()
public Node(E data)
this.data = data;
线性表链式存储的实现(增加，删除，获取元素)：
public class LinkedList<E> implements List<E>
/**
* 头节点
*/
private Node<E> head;
/**
* 元素个数
*/
private int size;
public LinkedList()
head = new Node<>();
public LinkedList(List<E> list)
this();
addAll(list);
@Override
public void add(E element)
Node<E> node = new Node<>(element);
Node<E> iterator = head;
// 从头节点开始依次遍历
while (iterator.next != null)
iterator = iterator.next;
iterator.next = node;
size++;
@Override
public void addAll(List<E> list)
if (list == null || list.size() == 0)
return;
Node<E> iterator = head.next;
while (iterator.next != null)
iterator = iterator.next;
Node<E> addNodeHead = new Node<>();
Node<E> addIterator = addNodeHead;
E[] elements = (E[]) list.toArray();
for (int i = 0; i < elements.length; i++)
E data = elements[i];
Node<E> node = new Node<>(data);
addIterator.next = node;
addIterator = node;
iterator.next = addNodeHead.next;
size += list.size();
addNodeHead = null;
@Override
public void insert(int index, E element)
check(index);
Node<E> preNode = getNode(index - 1);
Node<E> insertNode = new Node<>(element);
insertNode.next = preNode.next;
preNode.next = insertNode;
size++;
@Override
public E remove(int index)
check(index);
Node<E> preNode = getNode(index - 1);
// 要删除的节点
Node<E> removeNode = preNode.next;
preNode.next = removeNode.next;
E data = removeNode.data;
removeNode.data = null;
removeNode.next = null;
removeNode = null;
size--;
return data;
@Override
public void remove(E element)
Node<E> iterator = head.next;
Node<E> preNode = head;
if (element == null)
while (iterator != null)
if (iterator.data == null)
preNode.next = iterator.next;
iterator.next = null;
iterator = preNode.next;
size--;
continue;
preNode = preNode.next;
iterator = iterator.next;
else
while (iterator != null)
if (iterator.data.equals(element))
preNode.next = iterator.next;
iterator.next = null;
iterator = preNode.next;
size--;
continue;
preNode = preNode.next;
iterator = iterator.next;
@Override
public void replace(E target, E replace)
Node<E> iterator = head.next;
if (target == null)
while (iterator != null)
if (iterator.data == null)
iterator.data = replace;
iterator = iterator.next;
else
while (iterator != null)
if (iterator.data != null && target.equals(iterator.data))
iterator.data = replace;
iterator = iterator.next;
@Override
public E get(int index)
Node<E> node = getNode(index);
return node.data;
@Override
public void clear()
for (Node<E> iterator = head; iterator != null; )
Node<E> nextNode = iterator.next;
nextNode.data = null;
nextNode.next = null;
iterator = nextNode;
size = 0;
@Override
public boolean isEmpty()
return size == 0;
@Override
public int size()
return size;
@Override
public int indexOf(E element)
Node<E> iterator = head.next;
for (int i = 0; i <<以上是关于杠上数据结构 - 线性表的主要内容，如果未能解决你的问题，请参考以下文章