【概念】
一种物理存储结构上的非连续存储结构，数据元素的逻辑顺序是通过链表中的引用链接次序来实现的
也就是说，链表是由一个一个的节点组织起来的，如车厢一般，整体就叫做链表
【链表结构】
节点可以理解为”节点对象“，它有两个域，一个val域，用于存储数据，一个next域，用于存储下一个节点的地址
【单向，不带头，非循环链表】
一般定义一个"head"对象作为链表的头节点
这是最常见的链表类型
【单向，带头，非循环链表】
head这个节点可以认为是一个标志，其val域存储的值不具备实际意义
【单向，带/不带头，循环链表】
【链表的实现】
链表由若干节点构成，这个节点又是一个完整的结构，那么就可以把节点定义为一个”内部类”
public class MySingleLinkedList
{
class ListNode // 这就是一个内部类
{
public int val;
public ListNode next; // next域中存放节点的地址，因此next的数据类型是ListNode
public ListNode(int val) //构造方法
{
this.val = val;
}
}
public ListNode head;//代表链表的头节点
public void createList()
{
ListNode node1 = new ListNode(12);
ListNode node2 = new ListNode(23);
ListNode node3 = new ListNode(34);
ListNode node4 = new ListNode(45);
ListNode node5 = new ListNode(56);
}
}
我们需要让第一个节点和第二个节点之间关联，以此类推
因此使用该代码
通过node1去访问next域，而node2这个引用，引用的是一个完整对象，node2中存放的就是这个对象的地址“0x35”，所以node1中的next域的值被修改为了0x35
所以我们认为，它的指向关系已经有了
因此可写出如下代码
public void createList()
{
ListNode node1 = new ListNode(12);
ListNode node2 = new ListNode(23);
ListNode node3 = new ListNode(34);
ListNode node4 = new ListNode(45);
ListNode node5 = new ListNode(56);
node1.next = node2;
node2.next = node3;
node3.next = node4;
node4.next = node5;
this.head = node1;//将node1视为头节点
}
【遍历每个节点的值，并打印】
public void display()//遍历每个节点的值并打印
{
ListNode cur = head;//定义cur，让cur遍历，若让head遍历那只能遍历一次，head无法回归最开始的位置
while(cur != null)
{
System.out.println(cur.val + " ");
cur = cur.next;
}
System.out.println();
}【计算链表大小】
public int size()//计算链表大小
{
int count = 0;
ListNode cur = head;
while(cur != null)
{
count++;
cur = cur.next;
}
return count;
}【头插法】
头插法要修改两个地方，第一个是新节点的next域，第二个是head的指向
需要使用这两行代码
public void addFirst(int val)
{
ListNode node = new ListNode(val);
node.next = head;
head = node;
}这两行代码的顺序不可改变，如果首先执行head=node，那么node.next=head会变成：
它自己指向了自己，后面的节点丢了
总结：插入节点时一般首先绑后边
【尾插法】
首先找到链表的尾巴（cur一直遍历，当cur.next==null时，cur指向了尾巴），然后让cur的next域的值被设置为node的地址（cur.next = node）
public void addLast(int val)
{
ListNode node = new ListNode(val);
if(head == null) //整个是空链表时，直接插即可
{
head = node;
return;
}
ListNode cur = head;
while(cur.next != null)
{
cur = cur.next;
}
cur.next = node;
}【任意位置插入】
1.让cur走index-1步，找到要插入的前一个位置
2.“node的next域”被设置为“cur的next域中所存放的地址”(node.next = cur.next)
3.cur的next域被设置为node的地址（cur.next = node）
当index为0，使用头插法，index等于最大长度，使用尾插法，index不合法，抛异常
public void addLast(int val)
{
ListNode node = new ListNode(val);
if(head == null) //整个是空链表时，直接插即可
{
head = node;
return;
}
ListNode cur = head;
while(cur.next != null)
{
cur = cur.next;
}
cur.next = node;
}
public void addIndex(int index, int val)
{
//1.判断index的合法性
try {
checkIndex(index);
} catch (InterruptedException e) {
e.printStackTrace();
}
//2.index == 0 || index == size()
if(index == 0)
{
addFirst(val);
return;
}
if(index == size())
{
addLast(val);
return;
}
//3.找到index的前一个位置
ListNode cur = findIndexSubOne(index);
//4.进行链接
ListNode node = new ListNode(val);
node.next = cur.next;
cur.next = node;
}
private ListNode findIndexSubOne(int index)//找到index - 1位置
{
int count = 0;
ListNode cur = head;
if(count != index - 1)
{
cur = cur.next;
count++;
}
return cur;
}
private void checkIndex(int index) throws InterruptedException//检查index是否合法
{
if(index < 0 || index > size())
{
throw new IndexNotLegalException("index不合法");
}
}
}public class IndexNotLegalException extends RuntimeException
{
public IndexNotLegalException()
{
}
public IndexNotLegalException(String msg)
{
super(msg);
}
}public class IndexNotLegalException extends RuntimeException
{
public IndexNotLegalException()
{
}
public IndexNotLegalException(String msg)
{
super(msg);
}
}
【删除第一次出现关键字为key的节点】
设关键字key为34
1.先找到34的前一个，cur
当cur的next域中所存放地址节点的val域值与关键字相等时，成功找到（cur.next.val = val）
2.找到cur后，定义cur的下一个节点del（ListNode del = cur.next）,随后进行删除，cur的next域被设置为del的next域中所存放的地址(cur.next = del.next)
或者不去定义del，将cur的next域设置为cur下一个节点的next域所存放的地址（cur,next = cur.next.next）
public void remove(int val)
{
//1.找到需要删除的关键字的前一个
ListNode cur = head;
while(cur.next != null)
{
if(cur.next.val == val)
{
ListNode del = cur.next;
cur.next = del.next;
return;
}
cur = cur.next;
}
}【删除所有关键字key】
设要删除的key为45
1.定义两个节点，cur代表当前需要删除的节点，prev代表当前需要删除节点cur的前驱节点
2.
当cur的val域和要删除的key相符时
将prev的next域设置为cur的next域中存放的地址（prev.next = cur.next）,随后让cur继续往后走（cur = cur.next）
当cur的val域和要删除的key不相符时
prev指向cur(prev = cur)（或者prev指向prev的next域中存放的地址（prev = prev.next））
随后让cur继续往后走（cur = cur.next）
3.如果head的值和要删除的val相符，让headr往后走（head = head.next）
public void removeAllKey(int val)
{
//1，判空
if(head == null)
{
return;
}
//2.定义prev和cur
ListNode prev = head;
ListNode cur = head.next;
//3.开始判断并删除
while(cur != null)
{
if(cur.val == val)
{
prev.next = cur.next;
cur = cur.next;
}else
{
prev = cur; //prev = prev.next;
cur = cur.next;
}
}
//4.处理头节点
if(head.val == val)
{
head = head.next;
}
}【清空链表】
public void clear()
{
ListNode cur = head;
while(cur != null)
{
ListNode curN = cur.next;
cur.next = null;
cur = curN;
}
head = null;
}
