链表（Linked List）

链表是有序的列表

1. 链表分两种，带头节点的链表和没有带头节点的链表，根据实际需求来确定
2. 链表是以节点的方式来存储的，是链式存储
3. 每个节点包括data域，next域，指向下一个节点
4. 如图：发现链表的各个节点不一定是连续存放的

​ 在内存中的实际结构

​ 逻辑结构

单链表的应用实例：

使用带head头的单向链表实现–水浒英雄排行榜的管理

1. 完成对英雄人物的增删改查操作

2. 第一种方法在添加英雄时，直接添加到链表的尾部

3. 第二种方法在添加英雄时，根据排名将英雄插入到指定位置
（如果有这个排名，则添加失败，并且给出提示）

思路分析：

添加：
1.创建一个head头节点，表示单链表的头
2.每添加一个节点，就直接加入到链表的最后遍历
3.判断遍历结果，如果next为空，那么就跳出循环，把添加进去的数据设置成这个节点对象的next（新节点）
4.如果不为空，那么把next（新节点）的值设置给节点，继续遍历新节点

package com.ry.linkedlist;

public class singleLinkendDemo {
public static void main(String[] args) {
//进行测试
//先创建一个节点
heroNode her01 = new heroNode(1, "宋江", "及时雨");
heroNode her02 = new heroNode(2, "卢俊义", "玉麒麟");
heroNode her03 = new heroNode(3, "吴用", "智多星");
heroNode her04 = new heroNode(4, "林冲", "豹子头");
//创建一个链表
glLinkedList list = new glLinkedList();
list.add(her01);
list.add(her02);
//        list.add(her03);
//        list.add(her04);
//显示
list.list();
}
}

//定义管理类
class glLinkedList{
//实例化一个固定的头节点，要保证它不能动
private  heroNode herd= new heroNode(0,"","");
//添加节点到单向链表
/*
* 思路：当不考虑编号序列时候
* 1.找到当前链表的最后节点
* 2.最后将这个节点的next指向新的节点
* */

public void  add(heroNode heronode){

heroNode temp=herd;
//遍历链表找到链表的最后
while(true){
//如果找到了链表的最后
if (temp.next==null){
break;
}
//如果没有找到最后，将temp后移
temp=temp.next;
}
//当退出while循环的时候，temp就指向了链表的最后
//最后将这个节点的next指向新的节点
temp.next=heronode;
}

//显示链表【遍历】
public void list(){
//判断链表是否为空
if(herd.next==null){
System.out.println("链表为空");
return;
}
//因为头节点不能动，因此我们需要一个辅助变量来遍历
heroNode temp=herd.next;
while(true){
//判断是否到链表最后
if (temp==null){
break;
}
//输出节点的信息
System.out.println(temp);
//将temp后移
temp=temp.next;
}

}

}
//定义一个英雄对象类
class heroNode{
public int no;//编号
public String name;//姓名
public String nickname;//昵称
public heroNode next;//指向下一个节点
//创建构造器
public heroNode(int no, String name, String nickname) {
this.no = no;
this.name = name;
this.nickname = nickname;
}

@Override
public String toString() {
return "heroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
", next=" + next +
'}';
}
}

单链表按顺序来插入节点

需要按照编号的顺序添加

1.首先找到新添加的节点的位置，是通过辅助变量（指针），通过遍历来搞定

2.新的节点的.next=temp.next

3.将temp.next=新的节点

public void addByOrder (heroNode heronode){
//因为头节点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
//因为单链表，因为我们要找的temp是位于添加位置的前一个节点，否则插入不了
heroNode temp=herd;
boolean flag=false;
while(true){
if (temp.next==null){
break;
}
if (temp.next.no>heronode.no){
break;
}else if(temp.next.no==heronode.no){
//说明想要添加的值已经才能在
flag=true;
break;
}

temp=temp.next;
}
if (flag){
System.out.println("要插入的节点"+heronode.no+"已经存在");
}else {
heronode.next=temp.next;
temp.next=heronode;
}
}

单链表节点的修改，根据编号来修改即编号不能修改

public void update(heroNode newheronode){
//判断节点的next是否为空
if(herd.next==null){
System.out.println("链表为空");
return;
}
//如果不为空
//找到需要修改的节点，根据编号
//定义一个辅助变量
heroNode temp=herd.next;
boolean flag=false;
while(true){
if (temp==null){
break;//已经遍历完列表了
}
if (temp.no==newheronode.no){
//找到了
flag=true;
break;
}
//如果当前节点未找到，把指针后移一位
temp=temp.next;
}
//根据flag判断是否找到要修改的节点
if(flag){
//根据已经找到节点返回的flag，把编号相同的节点的值name和nickname修改
temp.name=newheronode.name;
temp.nickname=newheronode.nickname;
}else{
System.out.println("没有找到编号"+newheronode.no+"不能修改");
}
}

从单链表中删除一个节点的思路

1.我们先找到需要删除的这个节点的前一个节点temp
2.temp.next=temp.next.next
3.被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

//删除节点
//1.head不能动，因此我们需要一个temp辅助节点找到待删除的节点
//2.我们在比较时，是temp.next.no和需要删除的节点的no进行比较
public void del(int no){
heroNode temp=herd;
boolean flag=false;
while(true){
if (temp.next==null){
break;
}
if (temp.next.no==no){
//找到待删除
// 节点的前一个节点temp
flag=true;
break;
}
temp=temp.next;
}
//判断flag
if (flag){
temp.next=temp.next.next;
}else{
System.out.println("要删除的"+no+"节点不存在");
}
}