一、链表linked list
1.定义
链表是数据元素的线性集合，其每个元素都指向下一个元素，元素存储上并不连续,链表逻辑连续。
2.分类
①单向链表：每个元素只知道其下一个元素是谁
②双向链表: 每个元素知道其上一个元素和下一个元素
③循环链表
3.哨兵节点
不存储数据，用作头尾，用来简化边界判断
4.链表性能
①随机访问（读取）
根据index查找，时间复杂O(n)。
根据索引查找元素的时候，要从头节点挨个查找
②插入或删除
起始位置：O（1）
结束位置：已知尾节点是O（1），不知道尾结点是O（n）
中间位置：根据index查找时间+O(1)
二、单向链表，不带哨兵
1.代码实现
①定义节点
public class SinglyLinkedList{
/**
* 节点类
* 数据域和地址域
*/
private static class Node {
int value;// 值
Node next;// 指向下一个节点，因为节点的类型是Node
public Node() {
}
public Node(int value, Node next) {
this.value = value;
this.next = next;
}
}
private Node head; //头指针
}②头部添加：每次是往表头依次添加，把新节点指向此时的head。然后让head再指向新节点。
如果head是null，就是head = new Node(value,null)
public void addFirst(int value) {
// 1.链表为空时，head是null 相当于head = new Node(value,null)
// 2.链表不为空时，new Node(value,head) 然后把新节点当为头结点head = new Node(value,head)
// 3.优化如下
head = new Node(value, head);
}②尾部添加：先找到最后一个节点的地址 while（p.next != null），如果链表为空，返回null
public Node findLast() {
// 判断是否为空
if (head == null) {
return null;
}
// 链表不为空
Node p = head;
while (p.next != null) {
p = p.next;
}
return p;
}返回的是最后一个节点地址last.next=new Node(value, null);如果返回的是null，那么就表头添加。
public void addLast(int value) {
Node last = findLast();
if (last == null) {
addFirst(value);
return;
}
// 找到尾巴节点
last.next = new Node(value, null);
}
③遍历节点1：定义一个辅助节点p指向头结点，条件是while(p!=null)，一直到链表为空
/**
* 2.遍历节点1
*/
public void loop1() {
Node p = head;
while (p != null) {
System.out.println(p.value);
p = p.next;
}
}
/**
* 遍历节点2
*/
public void loop2() {
for (Node p = head; p != null; p = p.next) {
System.out.println(p.value);
}
}也可以用增强for循环，重写iterator()
public class SinglyLinkedList implements Iterable<Integer> {
....
@Override
public Iterator<Integer> iterator() {
return new Iterator<Integer>() {
Node p = head;
// 是否有下一个元素
@Override
public boolean hasNext() {
return p != null;
}
// 返回当前元素，指向下一个元素
@Override
public Integer next() {
int value = p.value;
p = p.next;
return value;
}
};
}
}测试用这个
Iterator<Integer> iterator = singlyLinkedList.iterator();
for (Integer integer:singlyLinkedList){
System.out.println(integer);
}④根据索引查找get(i) 0,1,2,3...，先查找这个索引的节点。没有找到返回null，找到的话返回当前节点
public Node findNode(int index) {
Node p = head;
int i = 0;
while (p != null) {
// 找到了
if (index == i) {
return p;
}
i++;
p = p.next;//指向下一个节点
}
// 没找到
return null;
}如果为null，说明此时不合法
public int get(int index){
Node node = findNode(index);
if (node == null){
throw new IllegalArgumentException(
String.format("inndex[%d]不合法%n",index)
);
}
return node.value;
}⑤插入到索引位置，先定义辅助节点p指向索引的前一个地址，先让新节点的地址指向p的地址，再让p节点指向新节点的地址。如果p为空，插入失败。如果索引为0，那么调用头部添加的方法
/**
* 4.insert(int index)
* 根据索引插入,插在索引的位置，所以找索引前面的节点
*/
public void insert(int index,int value){
if (index == 0){
// 插入头位置
addFirst(value);
System.out.println("插入成功");
return;
}
Node p = findNode(index-1); // 找到索引的前一个节点
if (p == null){
// 链表为空，或者索引超出了范围
System.out.println("插入失败");
return;
}
// 找到索引的前一个节点
Node newNode = new Node(value,p.next);
p.next = newNode;
System.out.println("插入成功");
}⑥：按照索引删除节点，先实现删除头结点，让head指向head.next
public void removeFirst(){
if (head == null){
System.out.println("链表为空，删除失败");
return;
}
head = head.next; //
}// 删除节点
/**
* 删除节点：按照索引
*/
public void removeIndex(int index){
if (index == 0){
// 删除头结点
removeFirst();
return;
}
Node prev= findNode(index - 1);
// 如果为空
if (prev == null){
// 链表为空或者超过了索引范围
System.out.println("删除失败");
return;
}
// 此时node是删除索引的前一个节点
Node removed = prev.next;
if (removed == null ){
System.out.println("删除失败");
}
prev.next=removed.next;// 索引的前一个节点，指向索引的后一个节点
System.out.println("删除成功");
}