【链表】
是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。
由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,
但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,
而顺序表相应的时间复杂度分别是O(㏒ n)和O(1)。
【单向链表】
是链表的一种,其特点是链表的链接方向是单向的,对链表的访问要通过顺序读取从头部开始
一个节点包含两个域,一个信息域和一个指针域,指针域指向下一个节点,最后一个节点指向一个空值
单向链表有一个头节点,可以不存储任何信息,包含一个指向第一个节点的指针
特点:
1.访问节点速度慢,需要从头节点一次遍历链表
2.更新节点快,节点不需要移动,更改相应指针即可
单向链表节点类定义如下:
public class Node<AnyType>{
AnyType element;
Node<AnyType> next;
}
要实现单向列表的相关操作,可定义类SingleLinkedList如下:
public class SingleLinkedList<AnyType>{
private static class Node<AnyType>{
AnyType element;
Node<AnyType> next;
public Node(AnyType element){
this.element = element;
}
}
private Node<AnyType> header = new Node<AnyType>(null);
private int size = 0;
public boolean isEmpty(){
return size==0;
}
public void makeEmpty(){
header = null;
}
public int size(){
return size;
}
/**
* Get element by index
* */
public AnyType get(int index){
return getNode(index).element;
}
/**
* Add the element to the end of this list
* */
public void add(AnyType element){
add(new Node<AnyType>(element));
}
/**
* Inserts the specified element at the specified position in this list
* 插入逻辑:
* 1.创建一个新节点
* 2.将原index节点的前一个节点的指针指向新节点
* 3.将新节点的指针指向index节点
* 4.插入后,新节点的位置为index
* */
public void add(int index,AnyType element){
Node<AnyType> newNode = new Node<AnyType>(element);
Node<AnyType> previous = getNode(index-1);
//index节点
Node<AnyType> node = previous.next;
//将原index节点的前一个节点的指针指向newNode
previous.next = newNode;
//将newNode的指针指向index节点
newNode.next = node;
size++;
}
/**
* Inserts the specified element at the specified position in this list
* 删除逻辑:
* 1.获得index节点的前一个节点previousNode
* 2.获得index节点的后一个节点nextNode
* 3.将previousNode的指针指向nextNode
* */
public void remove(int index){
Node<AnyType> previous = getNode(index-1);
Node<AnyType> next = previous.next.next;
previous.next = next;
size--;
}
/**
* 定义此方法是为了便于测试
* */
public List<Integer> getElements(){
if(isEmpty()){
return null;
}else{
List<Integer> elements = new ArrayList<Integer>();
Node<AnyType> node = (Node<AnyType>) header;
while(node.next!=null){
node = node.next;
elements.add(((Element)node.element).getValue());
}
return elements;
}
}
//private methods
private Node<AnyType> getNode(int index){
if(isEmpty()){
throw new RuntimeException("List is empty");
}
int i = 0;
Node<AnyType> node = header;
while(i<=index){
node = node.next;
i++;
}
return node;
}
private void add(Node<AnyType> newNode){
Node<AnyType> node = header;
while(node.next!=null){
node = node.next;
}
node.next = newNode;
size++;
}
}
如何实现链表反向:
/**
* 链表反向
* */
public void reverse(){
if(!isEmpty()){
reverse(header.next,header.next.next);
}
}
private void reverse(Node<AnyType> node,Node<AnyType> nextNode){
if(nextNode.next!=null){
reverse(nextNode,nextNode.next);
}else{
//如果该节点是表尾,那么用头节点指向此节点
header.next = nextNode;
}
//该节点的指针指向前一个节点P,并将节点P的指针设置为空
nextNode.next = node;
node.next = null;
}