Java实现单链表操作

一、Node类定义

// 定义节点
class Node{
   public int no;// 节点序号
   public String name;// 节点名称
   public Node next;// 指向下一个节点

    // 定义构造器进行赋值
    public Node(int no, String name) {
        this.no = no;
        this.name = name;
    }

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

二、定义SingleLinkedList类封装对节点的操作

class SingleLinkedList{
    Node head = new Node(0,"");

    // 定义一个添加方法
    public void add(Node heroNode){
        // 因为头节点不能进行修改, 所以我们定义一个辅助变量来指向头节点
        Node temp = head;

        // 循环遍历, 找到最后一个节点
        while (true){
            // 找到最后一个节点后, 直接退出循环
            if (temp.next == null){
                break;
            }
            // 还没到最后一个节点,指向下一个节点
            temp = temp.next;
        }
        // 此时temp为最后一个节点,我们将temp.next指向我们添加的节点即可
        temp.next = heroNode;
    }
    // 添加节点, 后添加的节点如果和前面的节点的序号相同则不能进行添加
    public void addByOrder(Node node){
        // 在指定位置添加节点
        // 定义辅助量指向head节点
        Node temp = head;

        // 定义flag来标志指定位置是否已经存在了节点, 如果存在则不能添加
        // 默认为不存在
        boolean flag = false;

        // 循环遍历
        while (true){
            if (temp.next == null){
                // 此时链表已经到了最后
                break;
            }
            if (temp.next.no > node.no){
                // 如果temp下一个节点的索引值大于所要插入的节点索引值
                // 此时就可以退出循环
                // 并将heroNode插入到temp.next节点和temp节点之间
                break;
            }else if (temp.next.no == node.no){
                // 如果索引位置相同, 此时也该退出循环
                flag = true;
                break;
            }
            // 如果上述条件都不符合, 此时应该将temp指向下一个节点
            temp = temp.next;
        }

        // 退出循环后
        if (flag){// 如果flag为true, 证明此时要插入的节点的索引的位置已经包含了一个节点, 此时应该进行提示
            System.out.printf("准备插入的节点编号 %d 已经存在了, 不能加入\n",node.no);
        }else {
            // 此时可以进行添加
            node.next = temp.next;
            temp.next = node;
        }
    }

    // 更改节点(根据序号)
    public void update(Node heroNode){

        // 定义一个临时变量来指向头节点
        Node temp = head;
        // 定义一个flag来标志是否找到该节点
        boolean flag = false;
        while (true){
            if (temp.next == null){
                // 循环遍历已经到了最后
                break;
            }
            if (temp.next.no == heroNode.no){
                // 如果节点索引相同, 则令flag=true, 并且退出循环
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            // 如果找到索引值相同的节点, 此时可以进行修改操作
            temp.next.name = heroNode.name;
        }else {
            // 没有找到索引值相同的, 已经到了链表结尾
            System.out.printf("没有找到索引值为 %d 的节点",heroNode.no);
        }

    }
    // 根据序号删除节点
    public void delete(int no){
        // 定义一个临时变量来指向头节点
        Node temp = head;

        // 定义一个flag来标志是否已经找到该节点  默认为未找到
        boolean flag = false;
        while (true){
            if (temp.next == null){
                // 链表为空,退出循环
                break;
            }
            if (temp.next.no == no){
                // flag设置为true则表明已经找到该节点,此时可以进行退出
                flag = true;
                break;
            }
            // 如果都不符合上述情况, 则可以让temp指向下一个节点
            temp = temp.next;
        }

        if (flag){
            // 标明已经找到了该节点
            temp.next = temp.next.next;
        }else {
            System.out.println("链表为空!!!!");
        }
    }
    // 显示所有节点方法
    public void list(){
        // 头节点不能进行修改, 所以我们需要定义一个辅助变量来指向第一个节点 (注:这里不是head)
        Node temp = head.next;
        if (temp == null){
            // 第一个节点为空,则退出
            System.out.println("链表为空");
            return;
        }
        // 开始循环遍历所有节点
        while (true){
            if (temp == null){
                System.out.println("链表到头了");
                return;
            }
            // 打印节点信息
            System.out.println(temp);
            // temp指向下一个节点
            temp = temp.next;

        }
    }
}

三、添加main方法进行测试

  public static void main(String[] args) {
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.addByOrder(new Node(1,"张三"));
        singleLinkedList.addByOrder(new Node(3,"李四"));
        singleLinkedList.addByOrder(new Node(2,"王五"));
        singleLinkedList.addByOrder(new Node(5,"赵六"));

        // 遍历所有节点
        System.out.println("------------修改前-----------");
        singleLinkedList.list();

        singleLinkedList.update(new Node(3,"李四四~~~~~~~~~"));

        // 遍历所有节点
        System.out.println("------------修改后-----------");
        singleLinkedList.list();

        System.out.println("------------删除节点-----------");
        singleLinkedList.delete(1);

        System.out.println("删除序号为:" + 1 + "的节点后");
        singleLinkedList.list();
    }

四、测试结果

------------修改前-----------
HeroNode{no=1, name='张三', next=HeroNode{no=2, name='王五', next=HeroNode{no=3, name='李四', next=HeroNode{no=5, name='赵六', next=null}}}}
HeroNode{no=2, name='王五', next=HeroNode{no=3, name='李四', next=HeroNode{no=5, name='赵六', next=null}}}
HeroNode{no=3, name='李四', next=HeroNode{no=5, name='赵六', next=null}}
HeroNode{no=5, name='赵六', next=null}
链表到头了
------------修改后-----------
HeroNode{no=1, name='张三', next=HeroNode{no=2, name='王五', next=HeroNode{no=3, name='李四四~~~~~~~~~', next=HeroNode{no=5, name='赵六', next=null}}}}
HeroNode{no=2, name='王五', next=HeroNode{no=3, name='李四四~~~~~~~~~', next=HeroNode{no=5, name='赵六', next=null}}}
HeroNode{no=3, name='李四四~~~~~~~~~', next=HeroNode{no=5, name='赵六', next=null}}
HeroNode{no=5, name='赵六', next=null}
链表到头了
------------删除节点-----------
删除序号为:1的节点后
HeroNode{no=2, name='王五', next=HeroNode{no=3, name='李四四~~~~~~~~~', next=HeroNode{no=5, name='赵六', next=null}}}
HeroNode{no=3, name='李四四~~~~~~~~~', next=HeroNode{no=5, name='赵六', next=null}}
HeroNode{no=5, name='赵六', next=null}
链表到头了