距离上次写数组的增删查改已经过去了很久了，我承认是我懒了，闲话不多说，进入今天的主题。
链表(linked list)是一种在物理上非连续、非顺序的数据结构，由若干的节点(node)组成。
下面是链表和数组的特点的对比：
| 数组 | 链表 | |
| 访问方式 | 随机访问 | 顺序访问 |
| 存储方式 | 顺序存储 |
随机存储 |
| 适用场景 | 读多、写少 | 读少、写多 |
数组可以随机访问，链表只能按顺序访问。
数组在内存中的存储方式是顺序存储，链表则是随机存储。
数组适合读操作多，写操作少的场景。链表适合读操作少，写操作多的场景。
下面是节点的代码：
class Node{
int data;
Node next;
Node(int data){
this.data = data;
}
}
如果我们在Node的定义中再添加一个Node pre; 那么这个链表就是双向链表，即链表中的一个节点即知道它的上家也知道它的下家。
如果是双向链表，我们就可以从两头开始遍历，比如我们要找倒数第二个节点，就可以从尾部开始遍历，会快一些；
但是我们这里给出的是单向链表，即链表中的一个节点只知道它的下家。
不过这里都要除开头节点和尾节点，毕竟头节点没有上家，尾节点没有下家了。
下面给出了所有的代码。
package datastructure.linkedlist;
public class MyLinkedList{
//单向链表
//定义一个内部的Node节点以及构造方法
private static class Node{
int data;
Node next;
Node(int data){
this.data = data;
}
}
//头指针节点
private Node head;
//尾指针节点
private Node last;
//链表实际长度
private int size;
//下面依次是链表的查，改，增，删，打印操作
/**
* 链表的查询操作
* @param index 要找的元素的位置(顺序)
* @return 返回位置(顺序)为index的那个节点
* @throws Exception
*/
public Node get(int index) throws Exception{
//如果要查找的元素不在范围内,则抛出一个数组越界异常
if(index < 0 || index >= size){
throw new IndexOutOfBoundsException("超出链表的节点范围！");
}
//定义一个temp节点,从head头节点开始,然后遍历链表,直到找到那个元素
Node temp = head;
for(int i = 0; i < index; i++){
temp = temp.next;
}
//遍历完毕,返回现在的temp,就是要找的那个节点
return temp;
}
/**
* 链表的更改值操作
* @param index 要更改的值的位置(顺序)
* @param data 新值,用来替换旧值
* @throws Exception
*/
public void set(int index,int data) throws Exception{
if(index < 0 || index >= size){
throw new IndexOutOfBoundsException("超出链表的节点范围!");
}
get(index).data = data;
}
/**
* 链表的插入操作
* @param index 要插入的节点的位置
* @param data 要插入的节点的值
* @throws Exception
*/
public void insert(int index,int data) throws Exception{
if(index < 0 || index > size){
throw new IndexOutOfBoundsException("超出链表的节点范围!");
}
//构造一个新的节点
Node insertNode = new Node(data);
if(size == 0){
//如果是空链表的话,就让头指针和尾指针指向插入的这个节点
head = insertNode;
last = insertNode;
}else if(index == 0){
//如果在头部插入
insertNode.next = head;
head = insertNode;
}else if(index == size){
//如果在尾部插入
last.next = insertNode;
last = insertNode;
}else{
//如果插入位置在中间
Node preNode = get(index - 1);
insertNode.next = preNode.next;
preNode.next = insertNode;
}
//修改链表的长度
size++;
}
/**
* 链表的删除操作
* @param index 要删除节点的位置(顺序)
* @return 要删除的节点
* @throws Exception
*/
public Node remove(int index) throws Exception{
if(index < 0 || index >= size){
throw new IndexOutOfBoundsException("超出链表节点范围!");
}
Node removeNode = null;
if(index == 0){
//如果删除的是头节点
removeNode = head;
head = head.next;
}else if(index == size){
//如果删除的是尾节点
removeNode = last;
Node preNode = get(index - 1);
preNode.next = null;
last = preNode;
}else{
//如果删除的是中间元素
Node preNode = get(index - 1);
removeNode = preNode.next;
preNode.next = preNode.next.next;
}
size--;
return removeNode;
}
/**
* 链表的打印操作
*/
public void output(){
Node temp = head;
while(temp != null){
System.out.print(temp.data + "、");
temp = temp.next;
}
System.out.println();
}
/**
* 返回链表的长度
*/
public int getSize(){
return this.size;
}
public static void main(String[] args) throws Exception{
MyLinkedList mll = new MyLinkedList();
mll.insert(0, 3);
mll.insert(1, 19);
mll.insert(2, 79);
mll.insert(3, 44);
mll.insert(4, 77);
mll.output();
mll.set(0, 100);
mll.output();
mll.insert(2, 171);
System.out.println(mll.get(2).data);
mll.output();
mll.insert(0, 99);
mll.output();
mll.remove(3);
mll.output();
System.out.println(mll.getSize());
}
}
我们再来看看数组和链表的增删改查操作的时间复杂度。
| 增 | 删 | 查 | 改 | |
| 数组 | O(n) | O(n) | O(1) | O(1) |
| 链表 | O(1) | O(1) | O(n) | O(1) |
注意：这里链表的增删改都没有考虑之前的查找过程，只考虑纯粹的增删改操作。
今天的内容就到这里了。下期再见，谢谢大家的收看。