单向链表的定义及顺序插入，删改方法

定义

链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的，

• 1. 链表是以节点的方式来存储
• 2. 每个节点包含data域用于存储元素本身的数据信息， next域: 指向下一个节点地址.
• 3. 链表的各个节点不一定是连续存储.
• 4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

创建和遍历

添加(创建)
1.先创建一个head 头节点，作用就是表示单链表的头
2.后面我们每添加一个节点，就直接加入到链表的最后

public class SingleLinkedList {
    public static void main(String[] args) {
        SingleLinkedList s=new SingleLinkedList();
        HeroNode h1=new HeroNode(1,"林冲","豹子头");
        HeroNode h2=new HeroNode(2,"李逵","黑旋风");
        HeroNode h3=new HeroNode(3,"松江","及时雨");
        s.add(h1);
        s.add(h2);
        s.add(h3);
        s.list();
    }
    private HeroNode head=new HeroNode(0,"","");
    public void add(HeroNode heroNode){
        HeroNode temp=head;//头节点无法更改，新建一个节点
        while (true){
            if(temp.next==null){
                break;
            }
            temp=temp.next;
        }
        temp.next=heroNode;//链表的最后加入节点
    }
    
     public void list(){

        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp=head.next;
        while (true){
            if(temp==null){
                break;
            }
            System.out.println(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 + '\'' +
                '}';
    }
    
}
结果：

HeroNode{no=1, name='林冲', nickname='豹子头'}
HeroNode{no=2, name='李逵', nickname='黑旋风'}
HeroNode{no=3, name='松江', nickname='及时雨'}

顺序插入链表

需要按照编号的顺序添加

• 1.首先找到新添加的节点的位置,是通过辅助变量(指针),通过遍历来查找的
• 2.遍历后的位置：

（1）新的节点.next=temp.next
（2）temp.next =新的节点

public static void main(String[] args) {
        SingleLinkedList s=new SingleLinkedList();
        HeroNode h1=new HeroNode(2,"林冲","豹子头");
        HeroNode h2=new HeroNode(1,"李逵","黑旋风");
        HeroNode h3=new HeroNode(3,"松江","及时雨");
        
        s.addByorder(h1);
        s.addByorder(h2);
        s.addByorder(h3);
        s.list();
    }
public void addByorder(HeroNode heroNode){
        HeroNode temp=head;
        boolean flog=false;
        while (true){
            if(temp.next==null){
                break;
            }
            if(temp.next.no>heroNode.no){
                break;
            }
            if(temp.next.no==heroNode.no){
                flog=true;
                break;
            }
           temp=temp.next;
        }
        if(flog){
            System.out.println("加入数据重复");
        }else {
            heroNode.next=temp.next;
            temp.next=heroNode;
        }
    }
 结果：
 HeroNode{no=1, name='李逵', nickname='黑旋风'}
HeroNode{no=2, name='林冲', nickname='豹子头'}
HeroNode{no=3, name='松江', nickname='及时雨'}

修改

通过辅助变量遍历查找要改变的序号

public class SingleLinkedList {
    public static void main(String[] args) {
        SingleLinkedList s=new SingleLinkedList();
        HeroNode h1=new HeroNode(2,"林冲","豹子头");
        HeroNode h2=new HeroNode(1,"李逵","黑旋风");
        HeroNode h3=new HeroNode(3,"松江","及时雨");

        s.addByorder(h1);
        s.addByorder(h2);
        s.addByorder(h3);
        HeroNode h4=new HeroNode(3,"裴宣","铁面孔目");
        s.update(h4);
        s.list();
    }
public void update(HeroNode heroNode){
        HeroNode temp=head.next;
        if(head.next==null){
            System.out.println("链表为空");
        }
        boolean flag=false;
        while (true){
            if(temp==null){
                break;
            }
            if(temp.no==heroNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name=heroNode.name;
            temp.nickname=heroNode.nickname;
        }else {
            System.out.println("没有要修改的序号");
        }
    }
    结果：
    HeroNode{no=1, name='李逵', nickname='黑旋风'}
	HeroNode{no=2, name='林冲', nickname='豹子头'}
	HeroNode{no=3, name='裴宣', nickname='铁面孔目'}

删除

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

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

public static void main(String[] args) {
        SingleLinkedList s=new SingleLinkedList();
        HeroNode h1=new HeroNode(2,"林冲","豹子头");
        HeroNode h2=new HeroNode(1,"李逵","黑旋风");
        HeroNode h3=new HeroNode(3,"松江","及时雨");

        s.addByorder(h1);
        s.addByorder(h2);
        s.addByorder(h3);
        s.delete(3);
        s.list();
    }
public void delete(int no){
        if(head.next==null){
            System.out.println("链表为空");
        }
        HeroNode temp=head.next;
        boolean flag=false;
        while (true){
            if(temp==null){
                break;
            }
            if(temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            temp.next=temp.next.next;
        }
        else {
            System.out.println(no+"序列不存在");
        }
    }
    结果：
    HeroNode{no=1, name='李逵', nickname='黑旋风'}
	HeroNode{no=2, name='林冲', nickname='豹子头'}