单链表Java数据结构篇

本章学习目录

• 页内目录
  一，了解单链表
  二，定义节点类
  三，链表的增删改查
  四，链表的进阶操作

一，单链表

• 概念：是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
• 组成：链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
• 分类：有头节点的单链表和没头节点的单链表
• 逻辑结构：
• 解决单链表问题：大多数都要依靠一个自己定义的辅助节点

二，定义节点类

package com.链表;
/**
 * 定义Node,，每一个Node对象都是一个节点
 */
public class Node{
    public int no;
    public String name;
    public String message;
    public Node next;//指向下一个节点
    
    //三个参数的构造函数
    public Node(int node, String name, String message) {
        this.no = node;
        this.name = name;
        this.message = message;
    }

    //重写toString方法
    @Override
    public String toString() {
        return "Node{" +
                "node=" + no +
                ", name='" + name + '\'' +
                ", message='" + message + '\'' +
                '}';
    }
}

三，链表的增删改查

package com.链表;

import java.util.Stack;

public class SingleLinkedList {
    //初始化一个头节点
    Node head = new Node(0, "", "");

    public Node getHead() {
        return head;
    }

    /**
     * 增加节点的方法
     * 链表最后节点的特性：最后节点的下一个节点为null
     */
    public void add(Node node) {
        //因为head节点不能动，所以我们定义一个辅助节点
        Node temp = head;
        while (true) {
            //给出口！找到链表的最后
            if (temp.next == null) {
                break;
            }
            //如果没有找到就将该节点后移
            temp = temp.next;
        }
        //当退出while循环则说明temp.next=null
        //将temp节点的下一个节点指向node;
        temp.next = node;
    }

    /**
     * 遍历链表
     */
    public void printNode() {
        //当链表为空的情况
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //当链表不为空；链表不知深度；所以while循环
        //头节点不能动，多以我们通过辅助节点遍历
        Node temp = head.next;
        while (true) {
            //给出口！是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }
    }

    /**
     * 乱序添加，顺序输出，且node标号不能相同
     * 思路：利用while循环找出最后一个大于node的节点
     */
    public void addByOrder(Node node) {
        //头节点不能动，所以我们通过辅助节点temp操作
        Node temp = head;
        //当头节点后面有节点的时候进入while循环
        while (temp.next != null) {
            //当temp的下一个节点大于要添加的node节点的时候
            if (temp.next.no > node.no) {
                break;
            }
            //要添加的node节点等于temp的下一个节点的时候
            if (node.no == temp.next.no) {
                System.out.println("该节点编号已经存在" + temp.next);
                //添加的节点已经有了，所以直接打印信息并退出
                return;
            }
            //让temp向后移动
            temp = temp.next;
        }
        //让满足刚好temp的下一个的节点赋予新添加的node的节点的下一个
        node.next = temp.next;
        //让新的节点称为temp的后继节点
        temp.next = node;
    }

    /**
     * 根据no更改信息
     */
    public void updata(Node node) {
        //创建辅助节点temp
        Node temp = head.next;
        //判断是否找到该节点的一个指标
        boolean flag = false;
        while (true){
            if (temp==null){
                break;//链表已经遍历完成
            }
            if(temp.no==node.no){
                flag=true;
                break;
            }
            //让temp移动
            temp=temp.next;
        }
        if (flag){
            temp.name=node.name;
            temp.message=node.message;
        }else{
            System.out.println(node.no+"没有找到");
        }
    }
    /**
     * 根据no删除节点信息
     */
    public void del(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;
        }
        if (flag){
            //将no节点的前一个节点的指针指向
            temp.next=temp.next.next;
        }else {
            System.out.println(no+"节点不存在");
        }
    }
}

四，链表的进阶操作

package com.链表;

import java.util.Stack;

public class SingleLinkedList {
    //初始化一个头节点
    Node head = new Node(0, "", "");

    //方便在测试类中获得head节点
    public Node getHead() {
        return head;
    }
    /**
     * 统计节点的个数，不包括head节点
     */
    public static int nodeLength(Node head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        Node countNode = head.next;
        while (countNode != null) {
            length++;
            //让计数节点移动
            countNode = countNode.next;
        }
        return length;
    }

    /**
     * 找到倒数第几个节点
     * 总长度-倒数第几个=该节点的index
     */
    public static Node findLastIndex(Node head, int lastIndex) {
        if (head.next == null) {
            return null;
        }
        Node curNode = head.next;
        int length = nodeLength(head);
        if (lastIndex > length || lastIndex <= 0) {
            return null;
        }
        for (int i = 1; i <= length - lastIndex; i++) {
            curNode = curNode.next;
        }
        return curNode;
    }

    /**
     * 将链表反转
     */
    public static void reverseNodeList(Node head) {
        //定义一个新的链表，用于临时存放新的链表
        Node newList = new Node(0, "", "");
        //遍历链表，每得到一个节点都放入临时链表
        //定义一个临时节点
        Node temp = head.next;
        //定义一个临时存放的节点
        Node tem = null;
        while (temp != null) {
            tem = temp.next;//记录原链表的temp的下一个节点

            //将temp放到新链表中
            temp.next = newList.next;//将新链表头节点的下一个节点确认为temp的后继节点
            newList.next = temp;//将temp作为新链表的头节点的下一个节点

            temp = tem;//让指针持续移动
        }
        head.next = newList.next;
    }

    /**
     * 逆序打印链表（栈）
     */
    public static void reversePrint(Node head) {
        //定义一个辅助节点
        Node temp = head.next;
        Stack<Node> stack = new Stack<>();
        while (temp != null) {
            stack.add(temp);
            temp = temp.next;
        }
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }
}

• 注：数据结构的话，建议大家有了一定的java基础，再看看B站尚硅谷的课程，满满干货；当然本人也是学完，自己加深记忆再写一遍的