数据结构之单链表_Java

本文主要对单项链表进行了如下几个操作

• 单向链表的创建和遍历。
• 单向链表按顺序插入节点
• 单向链表节点的修改
• 单向链表节点的删除

链表

链表是有序的列表，但是他在内存中的存储如下：

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

单链表（带头节点）逻辑结构示意图如下：

接下来我们来写一个单链表的应用实例

使用head头的单向链表实现 -编号排行榜管理，-完成对各节点的增删改查操作。

1. 第一种方式在添加角色是，直接添加到链表是尾部。思路分析示意图：
   

代码如下：

package cn.datastructures.linkedlist;

/**
 *测试单向链表
 *（因为增删改，主要容易出错的就是第一个和最后一个，所以删改，我就偷偷懒，
 *	就操作第一个和最后一个了！！！）
 *@author 最皮双皮奶
 */
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //先创建节点
        Node node1=new Node(1, "one", "打篮球");
        Node node2=new Node(2, "two", "打游戏");
        Node node3=new Node(3, "three", "学习");
        Node node4=new Node(4, "four", "跑步");
        Node node5=new Node(5, "five", "睡觉");
        //创建链表
        SingleLinkedList sll=new SingleLinkedList();
        //1.将数据加入链表
        sll.add(node1);
        sll.add(node2);
        sll.add(node3);
        sll.add(node4);
        sll.add(node5);
        //2.将数据加入链表
        /*sll.addNode(node1);
        sll.addNode(node3);
        sll.addNode(node2);
        sll.addNode(node4);
        sll.addNode(node5);*/
        //遍历链表
        sll.list();
        //3.修改数据
        /*Node newNode1=new Node(1, "NO.3", "学习打篮球使我快乐");
        Node newNode2=new Node(5, "NO.3", "睡觉使我快乐");
        System.out.println("《《《《《《《《《《《修改后》》》》》》》》》》》");
        sll.update(newNode1);
        sll.update(newNode2);
        //遍历链表
        sll.list();*/
        //4.根据no删除数据
       /* sll.del(1);
        sll.del(5);
        System.out.println("《《《《《《《《《《《删除后》》》》》》》》》》》");
        //遍历链表
        sll.list();*/
    }
}

/**
 * 定义SingleLinkedList，用它来管理我们的界节点
 */
class SingleLinkedList {
    /**
     先初始化头节点，头节点不存放数据，不能移动。
     */
    private Node headNode=new Node(0, "", "");

    /**
     *添加节点到单向链表
     * 思路：（不考虑编号顺序的情况下）
     * 1.找到当前链表的最后节点
     * 2.将最后这个节点的next指向新的节点
     */
    public void add(Node node){
        //因为headNext不能动，所以我们需要创建一个辅助节点
        Node temp=headNode;
        //遍历链表，找到最后一个节点
        while (true) {
            //如果temp.next为null，就是找到了链表的最后
            if (temp.next == null) {
                break;
            }
            //如果当前不是最后节点，就寻找下一个节点
            temp=temp.next;
        }
        //当退出while循环，代表已经找到了最后一个节点temp
        //将最后这个节点的next指向node节点。
        temp.next=node;
    }

    /**
     * 遍历链表
     */
    public void list(){
        //先判断链表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空！！！");
            return;
        }
        /**
         * 因为headNext不能动，所以我们需要创建一个辅助节点来帮助遍历链表
         */
        Node temp=headNode.next;
        while (true) {
            //判断是否的最后一个节点
            if (temp == null) {
                break;
            }
            //重写了toString方法，所以直接输出temp
            System.out.println(temp);
            //将节点后移
            temp=temp.next;
        }
    }
}

/**
 * 定义Node，每个Node对象就是一个节点
 */
class Node {
    /**
     * 编号
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 喜好
     */
    public String like;
    /**
     * 指向下一个节点
     */
    public Node next;

    /**
     * 构造器
     * @param no
     * @param name
     * @param like
     */
    public Node(int no, String name, String like) {
        this.no = no;
        this.name = name;
        this.like = like;
    }

    /**
     * 重写toString方法，方便遍历
     * @return
     */
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", Like='" + like + '\'' +
                '}';
    }
}

2. 对上面代码进行优化：在添加角色时，根据编号将角色插入到指定位置（如果有这个编号，则添加失败，给出错误提示）。思路分析示意图：
   

代码如下：

//SingleLinkedList.java中修改方法
 /**
     * 优化代码，将add方法修改成addNode方法，使角色插入时，可以根据编号插入指定位置
     * （如果编号重复，则给出提示信息）
     * @param node
     */
    public void addNode(Node node){
        /*1）.因为头节点不能动，所以我们定义一个辅助节点来帮助我们找到添加的位置
            2）.因为是单链表，我们无法找到上一个节点，
                    所以我们需要找到的temp是位于添加位置的前一个节点，
                    否则无法加入。
         */
        Node temp=headNode;
        //定义flag变量，判断添加的编号是否存在。
        boolean flag=false;
        //循环遍历，寻找需要的temp节点
        while (true) {
            //判断temp是否已经到链表的最后
            if (temp.next == null) {
                break;
            }
            //找到需要的节点temp了。
            if (temp.next.no > node.no) {
                break;
            }
            //代表索要添加的编号已存在！将flag修改为true。
            if (temp.next.no == node.no) {
                flag=true;
                break;
            }
            //将temp后移，继续遍历链表
            temp=temp.next;
        }
        if (flag) {
            System.out.println("准备插入的编号为"+temp.no+"角色已存在");
        }else {
            //找到需要的temp节点，添加节点到temp节点的后面
            node.next=temp.next;
            temp.next=node;
        }
    }

3. 修改节点信息：
   思路：
   1）.先找到该节点，通过遍历
   2）.temp.name=newNode.name;temp.nickName=newNode.nickName

代码如下

//SingleLinkedList.java中添加update方法
 /**
     * 修改节点的信息，根据no编号来修改，即，no编号不能改变
     * @param newNode
     */
    public void update(Node newNode){
        //先判断链表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，无法修改");
            return;
        }
        //根据no找到需要修改的节点
        //因为头节点无法移动，先定义一个辅助节点,方便查找需要修改的节点
        Node temp=headNode;
        //定义flag变量，判断是否找到需要修改的节点
        boolean flag=false;
        //循环遍历链表，寻找需要修改的节点
        while (true) {
            //判断temp是否已经到链表的最后
            if (temp == null) {
                break;
            }
            //找到需要的节点了，将flag修改为true
            if (temp.no == newNode.no) {
                flag=true;
                break;
            }
            //节点后移，继续遍历
            temp=temp.next;
        }
        //根据flag判断是否找到需要修改的节点。
        if (flag) {
            temp.name=newNode.name;
            temp.like=newNode.like;
        }else {
            System.out.println("没有找到编号为"+newNode.no+"的对象，无法修改");
        }
    }

4.删除节点：思路分析图：

代码如下：

//SingleLinkedList.java中添加del方法
/**
     * 根据no删除节点
     * 思路：
     *          1.头节点不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
     *          2.说明我们在比较时，是temp.next.no和需要删除的节点的no比较
     */
    public void del(int no){
     	//先判断链表是否为空
        if (headNode.next == null) {
            System.out.println("链表为空，无法删除节点");
            return;
        }
        //定义辅助节点
        Node temp=headNode;
        //定义flag变量，判断是否找到需要删除的节点
        boolean flag=false;
        //循环遍历，寻找需要删除的节点
        while (true) {
            //判断temp是否是链表的最后一个
            if (temp.next == null) {
                break;
            }
            //找到待删除节点的前一个节点temp,修改flag为true
            if (temp.next.no == no) {
                flag = true;
                break;
            }
            //节点后移，继续遍历
            temp=temp.next;
        }
        //判断flag，为true则进行删除节点的操作，为false则输出错误信息
        if (flag) {
            temp.next=temp.next.next;
        }else {
            System.out.println("没有找到编号为"+no+"的角色,无法删除");
        }
    }

感谢阅读！！！