单链表的实现

链表

• 链表是以节点的方式存储，是链式存储。

• 每个节点包含 data 域：存放数据，next 域：指向下一个节点。

• 链表的各个节点不一定是连续存储。

• 分为带头节点的链表和没有头节点的链表。

• 添加节点：直接在链表的尾部添加

  • 先创建一个 head 头节点，作用就是表示单链表的头。
  • 每添加一个节点，就直接加入到链表的最后。

• 添加节点：按照编号的顺序添加

  • 首先需要找到新节点 newNode 需要添加的位置，通过辅助变量(指针) temp，通过遍历查找
  • `newNode.next = temp.next;``
  • ``temp.next = newNode;`

• 遍历：

  • 通过一个辅助变量，帮助遍历整个链表

• 修改节点

  • 根据 no 找到需要修改的节点
  • 修改节点的 name，nickname 即可

• 删除节点：

  • 找到需要删除的节点的前一个节点 `temp``
  • ``temp.next = temp.next.next;`
  • 在Java中，被删除的节点，将不会有其他引用指向，会被垃圾回收机制回收

代码如下：

//定义SingleLinkedList,即链表,管理节点 Node
class SingleLinkedList{
    //先初始化一个头节点，头节点不动，不存放具体的数据
    private Node head = new Node(0, "", "");

    //添加节点到链表中
    //思路：当不考虑节点的编号时
    //1. 找到当前链表的最后一个节点
    //2. 将最后这个节点的 next 指向新节点，新节点的 next 置为空
    public void add(Node node){
        //因为 head 节点不能动，因此需要一个辅助变量 temp，用来遍历整个链表
        Node temp = head;

        //遍历链表,找到链表的最后一个节点
        while (true){
            if (temp.next == null) { //找到最后一个节点
                break;
            }
            //如果没有找到，则 temp 后移
            temp = temp.next;
        }
        //退出 while 循环时，temp 就指向了链表的最后一个节点
        //将 temp(最后一个节点) 的 next 指向新的节点
        temp.next = node;
        node.next = null;
    }

    //第二种添加节点的方式，按照 Node 中的 no 的顺序来添加节点
    //(如果链表中已经存在相同的 no 时，则添加失败，并给出提示)
    public void addByOrder(Node node){
        //创建辅助指针 temp，temp 指向的是头节点，而不是头节点的 next
        //用 temp 来找到需要进行添加操作的位置，即找到的添加位置的前一个节点。
        Node temp = head;
        boolean flag = false; // flag标志添加的编号已经存在，默认为false

        while (true){
            if (temp.next == null){ //说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > node.no){//此时找到了需要添加的位置，就在 temp 的后面插入。
                break;
            }else if (temp.next.no == node.no){//此时说明希望添加的 node 的编号已经存在
                flag = true;
                break;
            }
            //temp 后移
            temp = temp.next;
        }

        //判断是否编号已经存在
        if (flag){//不能添加，编号已经存在
            System.out.printf("添加失败，准备插入的英雄的编号 %d 已经存在\n", node.no);
            return;
        }else {
            //可以添加 node 节点
            node.next = temp.next;
            temp.next = node;
        }
    }

    //修改节点的信息，根据 no 编号来进行修改，即 no 编号不能修改。
    public void update(Node node){
        if (head.next == null){
            System.out.println("链表为空！");
            return;
        }

        //找到需要修改的节点，根据 no 编号
        Node temp = head.next;
        boolean flag = false; // 表示是否找到该节点

        while (true){
            if (temp == null){
                System.out.println("链表遍历结束，未找到需要修改节点");
                break;
            }
            if (temp.no == node.no){
                //找到需要修改的节点
                flag = true;
                break;
            }
            temp = temp.next;
        }

        //根据 flag,判断是否找到要修改的节点
        if (flag){
            temp.name = node.name;
            temp.nickname = node.nickname;
        }else {// 没有找到需要修改的节点
            System.out.printf("没有找到编号 %d 的节点，不能修改\n", node.no);
        }
    }

    //删除节点:根据 no 进行删除操作
    //思路：
    //1. 使用辅助指针 temp 找到待删除节点的前一个节点 —— (即使用temp.next.no 与 no 进行比较)
    //2. temp.next = temp.next.next;
    //3. 待删除的节点没有其他引用指向它，会被垃圾回收机制回收
    public void delete(int no){
        Node temp = head;
        boolean flag = false; // 标志是否找到待删除的节点

        while (true){
            if (temp.next == null){ //已经到链表的最后，退出遍历
                break;
            }
            if (temp.next.no == no){ //找到待删除节点的前一个节点
                flag = true;
                break;
            }
            temp = temp.next; //temp后移，遍历
        }

        if (flag){ //此时找到了待删除节点的前一个节点
            //进行删除操作
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

    //显示链表[遍历]
    public void list(){
        //先判断链表是否为空
        if(head.next == null){
            System.out.println("链表为空");
            return;
        }
        //头节点不能动，需要一个辅助变量 temp，用来遍历整个链表
        Node temp = head; // temp 指向的是头节点，而不是头节点的 next

        while (true){
            //是否到链表最后
            if (temp.next == null){
                System.out.println("链表达到最后!");
                break;
            }
            //temp 后移
            temp = temp.next;
            //输出节点的信息
            System.out.println(temp);
        }
    }
}

//定义一个Node,每一个 Node 对象就是一个节点
class Node{
    public int no;
    public String name;
    public String nickname;
    public Node next; // next 域

    //构造器
    public Node(int hNo, String hName, String hNickname){
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }

    //重写 toString()，方便显示
    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname +
                '}';
    }
}

求单链表中的有效节点的个数

/**
 * 获取到单链表的节点的个数(如果是带头节点的链表，需要不统计头节点)
 * @param headNode
 * @return 返回单链表的有效节点个数
 */
public static int getLength(Node headNode){
    int length = 0;
    if (headNode.next == null){
        return length;
    }

    //定义一个辅助指针，进行遍历,没有统计头节点
    Node cur = headNode.next;
    while (cur != null){
        length++;
        cur = cur.next; //遍历
    }
    return length;
}

查找单链表中的倒数第k个节点

/*
 * 思路：
 * 1. 编写一个方法，接收 head 节点，同时接收一个 index
 * 2. index 表示是倒数第 index 个节点
 * 3. 先把从头到尾遍历，得到链表的总长度 getLength()
 * 4. 得到链表总长度后，从链表的第一个节点开始遍历，即需要执行 size - index 次 next 操作
 */
/**
 * 得到链表的总长度 size,从链表的第一个节点开始遍历，需要执行 size - index 次 next 操作，即可找到所需要的节点
 * @param headNode  单链表的头节点
 * @param index  倒数第 index 个节点
 * @return 查找单链表中的倒数第 index 个节点
 */
public static Node findLastIndexNode(Node headNode, int index){
    //如果链表为空，返回null
    Node res = null;
    if (headNode.next == null){
        return res;
    }

    //第一次遍历，得到单链表的长度，不算头节点的长度 —— 使用上面的方法 getLength(headNode)
    int size = getLength(headNode);
    //第二次遍历 (size - index + 1) 位置，就是倒数第 k 个节点
    if (index <= 0 || index > size){
        return res;
    }
    //定义辅助指针，用于遍历单链表
    res = headNode.next;
    //使用 for 循环定位倒数的 index 位置
    for (int i = 0; i < size - index; i++) {
        res = res.next;
    }
    return res;
}

反转链表

//单链表的反转,修改的是原有链表
/*
 * 思路：
 * 1. 先定义一个节点 reverseHead = new Node();
 * 2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表的最前端:
 * 3. 原来的链表的 head.next = reverseHead.next;
 */
public static void reverseList(Node headNode){
    //当前链表为空，或者只有一个节点，无需反转，直接返回
    if (headNode.next == null || headNode.next.next == null){
        return;
    }

    //定义一个辅助指针，用于遍历原来的链表
    Node cur = headNode.next;
    Node pre = null; //指向当前节点的下一个节点
    Node reverseHead = new Node(0, "", ""); //定义反转后链表的头节点
    //遍历原来的链表，每遍历一个节点，就将其取出，放在新的链表的 reverseHead 的最前端
    while (cur != null) {
        pre = cur.next; //先暂时保存当前节点的下一个节点
        cur.next = reverseHead.next; //将 cur 的下一个节点指针指向新的链表的最前端
        reverseHead.next = cur; //将 cur 连接到新的链表上
        cur = pre; // cur 后移
    }
    //将 head.next 指向 reverseHead.next，实现单链表的反转。
    headNode.next = reverseHead.next;
}

从尾到头打印单链表

//将链表从链表表尾输出信息
//方式1：反转链表，再输出
//方式2：可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
public static void reversePrint(Node headNode){
    //链表为空，返回
    if (headNode.next == null){
        return;
    }
    //创建栈
    Stack<Node> stack = new Stack<Node>();
    Node cur = headNode.next;
    //将链表的所有节点入栈
    while (cur != null){
        stack.push(cur); // cur 入栈
        cur = cur.next; // cur 后移
    }
    //从栈顶到栈底输出,pop 出栈
    while (stack.size() > 0){
        System.out.println(stack.pop()); //stack的特点是先进后出
    }
}