单向链表的基本操作

定义节点

package com.hand.linkedlist;

/**
 * 节点Node
 */
public class HeroNode {
    /**
     * 序号
     */
    public int no;

    /**
     * 姓名
     */
    public String name;


    /**
     * 下个节点
     */
    public HeroNode next;


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

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder("{");
        sb.append("\"no\":")
                .append(no);
        sb.append(",\"name\":\"")
                .append(name).append('\"');
        sb.append(",\"next\":")
                .append(next);
        sb.append('}');
        return sb.toString();
    }
}

单向链表操作

package com.hand.linkedlist;

/**
 * 单链表操作API
 */
public class SingleLinkedList {

    /**
     * 初始化头节点
     */
    HeroNode head = new HeroNode(0, "");


    /**
     * 单链表 新增节点
     */
    public void add(HeroNode heroNode) {
        //head节点不能动 先保留一个临时节点
        HeroNode temp = head;
        while (true) {
            //找到了链表的最后
            if (temp.next == null) {
                break;
            }
            //指针后移
            temp = temp.next;
        }
        //追加大链表的最后
        temp.next = heroNode;
    }


    /**
     * 单链表 按照顺序添加
     */
    public void addByOrder(HeroNode heroNode) {
        //指向一个临时变量
        HeroNode temp = head;
        //标记是否重复添加
        boolean flag = false;

        while (true) {
            //temp已经在链表最后 退出循环
            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("插入的节点已经存在.");
            throw new RuntimeException("node already exists.");
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }


    /**
     * head节点不动 需要一个temp辅助节点找到待删除节点的前一个节点
     * 比较的是 temp.next.no 和需要删除节点的no的比较
     */
    public void delete(int no) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;
            }
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.next = temp.next.next;
        } else {
            System.out.printf("找不到要删除的节点 编号为%d\n", no);
            throw new RuntimeException("node not found.");
        }
    }


    /**
     * 更新节点
     *
     * @param paramHeroNode
     */
    public void update(HeroNode paramHeroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //标记是否找到
        boolean flag = false;
        //临时节点
        HeroNode temp = head.next;

        while (true) {
            //已经遍历完毕
            if (temp == null) {
                break;
            }
            //如果编号相等代表找到
            if (temp.no == paramHeroNode.no) {
                flag = true;
                break;
            }
            //后移
            temp = temp.next;
        }
        if (flag) {
            //修改
            temp.name = paramHeroNode.name;
        } else {
            System.out.printf("找不到编号为%d的节点.", paramHeroNode.no);
            throw new RuntimeException("node not found.");

        }
    }


    /**
     * 单链表 遍历节点
     */
    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.toString());
            //链表向后移动
            temp = temp.next;
        }
    }
}

测试

package com.hand.linkedlist;


public class TestLinkedList {
    public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        HeroNode hero1 = new HeroNode(1,"a");
        HeroNode hero2 = new HeroNode(2,"b");
        HeroNode hero3 = new HeroNode(3,"c");

        //测试节点的有序加入
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);

        //测试节点的更新
        singleLinkedList.update(new HeroNode(3,"cc"));

        //测试节点的额删除
        singleLinkedList.delete(4);

        //测试节点的查询
        singleLinkedList.list();
    }
}