手写链表、链表的基本使用

链表的特点：

1. 链表以节点的方式来存储
2. 每个节点包括：值和下一个节点的地址
3. 节点不一定是连续存储的 。

package shuJuJieGouYuSuanFa.lianBiao;


public class LinkedLista {
    public static void main(String[] args) {
        HeroNode a = new HeroNode(1, "松江", "及时雨");
        HeroNode b = new HeroNode(2, "李俊毅", "玉麒麟");
        HeroNode c = new HeroNode(3, "吴用", "军师");
        HeroNode d = new HeroNode(4, "测试1", "及时雨");
        SingLinkList s = new SingLinkList();
        s.insert(a);
        s.insert(c);
        s.insert(b);
        s.insert(d);
        HeroNode tes = new HeroNode(4, "测试2", "我母鸡啊！");
        s.update(tes);
        s.delete(4);
        s.List();
    }
}

class SingLinkList {
    private HeroNode head = new HeroNode(0, "", "");

    //添加元素
    public void add(HeroNode heroNode) {
        HeroNode t = head;
        while (true) {
            if (t.next == null) {
                break;
            }
            t = t.next;
        }
        t.next = heroNode;
    }

    //删除
    public void delete(int no) {
        HeroNode t = head;
        boolean flag = false;
        while (true) {
            if (t.next == null) {
                break;
            }
            if (t.next.no == no) {
                flag = true;
                break;
            }
            t = t.next;
        }
        if (flag) {
            t.next = t.next.next;
        } else {
            System.out.println("未找到元素");
        }
    }

    //修改
    public void update(HeroNode heroNode) {
        HeroNode t = head.next;
        boolean flag = false;
        while (true) {
            if (t == null) {
                break;
            }
            if (t.no == heroNode.no) {
                flag = true;
                break;
            }
            t = t.next;
        }
        if (flag) {
            t.name = heroNode.name;
            t.nikname = heroNode.nikname;
        } else {
            System.out.println("未找到");
        }
    }

    //插入元素
    public void insert(HeroNode heroNode) {
        HeroNode t = head;
        boolean flag = false;
        while (true) {
            //到达了最后一位
            if (t.next == null) {
                break;
            }
            //编号存在
            if (t.next.no == heroNode.no) {
                flag = true;
            }
            //待加入的位置确定
            if (heroNode.no < t.next.no) {
                break;
            }
            t = t.next;
        }
        if (flag) {
            System.out.println("位置已被添加");
        } else {
            //ac+b
            // b=a的下一位（c的位置）
            //a的下一位 =b
            heroNode.next = t.next;
            t.next = heroNode;

        }
    }

    //查看所有元素
    public void List() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        HeroNode t = head.next;
        while (true) {
            if (t == null) {
                break;
            }
            System.out.println(t);
            t = t.next;
        }
    }
}

//链表类
class HeroNode {
    public int no;

    public String name;
    public String nikname;
    public HeroNode next;

    public HeroNode(int no, String name, String nikname) {
        this.no = no;
        this.name = name;
        this.nikname = nikname;
    }

    @Override
    public String toString() {
        return "HeroNode[" +
                "no=" + no +
                ", name='" + name + ''' +
                ", nikname='" + nikname + ']';
    }
}

始终定义一个链表头，不适用他存储数据，

添加的逻辑：

查询到节点next指向的空时，就代表这个节点时最后一个，

删除逻辑：

给定编号，遍历链表，找到编号后，将改节点的next指向该节点next.next，这样就把中间的被删除空出来了

修改逻辑：

给定修改节点，遍历链表找到后修改类容就好，这里为什么不直接将查找链表=修改链表呢，以为被修改链表的next是一个空，后面的所有元素将会丢失。

查询所有元素逻辑：

输出直到next不是空的所有元素

按照顺序加入、插入：

主要就是找到被插入节点的前一位（a），将待插入节点next设为它(a)的后一位，

再将前一位的next设为被插入节点.