数据结构：链表(Java)

简介

单链表是一种基本且广泛应用的数据结构，属于链式存储的线性表。它的核心特点是通过指针将一系列动态分配的内存单元（称为节点或结点）串联起来，每个节点包含两个主要部分：数据域和指针域。

基本概念

1. 节点（Node）：
   • 数据域（Data Field）：用于存储实际数据，可以是任何类型（如整数、字符、浮点数、结构体等），根据应用需求确定。
   • 指针域（Pointer Field 或 Next Pointer）：存储指向下一个节点的地址（也称为后继节点）。对于单链表而言，每个节点只有一个指向下一个节点的指针。
2. 链表的形态：
   • 空链表：链表由头指针标识，当链表为空时，头指针值为 NULL 或 nullptr，表示没有节点。
   • 非空链表：头指针指向第一个有效节点，该节点称为首节点或头节点。从首节点开始，通过连续跟随每个节点的指针域，可以访问到链表中的所有其他节点，直到最后一个节点，其指针域为 NULL，表示链表的尾部。
   
   连接关系如下图所示
   

对单链表的操作

前置工作

class SingleLinkedList {
    //先初始化一个头节点,头节点不要动,不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");

    //返回头节点，不给setting方法
    public HeroNode getHead() {
        return head;
    }
}
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //构造器
    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    //为了显示方法，我们重新toString

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

插入节点

• 头插法：在链表头部插入新节点，新节点成为新的首节点，原首节点成为新节点的后继。
• 尾插法：在链表尾部插入新节点，需要从头开始遍历链表找到原尾节点，然后修改其指针域指向新节点，新节点的指针域置为 NULL。
• 指定位置插入：找到待插入位置的前驱节点，将新节点的指针域指向前驱节点的后继节点，前驱节点的指针域改为指向新节点。

头插法和尾插法不做赘述，下面是按照编号大小进行插入：

public void add(HeroNode heroNode) {
        //当不考虑编号顺序时
        //1.找到当前链表的最后节点
        //2.将最后这个节点的next指向新添加的节点(heroNode)
        HeroNode temp = head;
        boolean flag = false;//标志是否找到
        while (true) {
            if (temp.next == null) {
                break;//到达链表最后
            }
            if (temp.next.no > heroNode.no) {//找到位置
                heroNode.next = temp.next;
                break;
            } else if (temp.next.no == heroNode.no) {//编号已经存在
                flag = true;
                //这里可以进行对英雄的替换处理
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            System.out.printf("编号%d已经存在,不能继续加入", heroNode.no);
        } else {
            temp.next = heroNode;
        }
    }

删除节点

• 删除首节点：若链表非空，更新头指针使其直接指向原首节点的后继节点。

public void deleteHead() {
	if (head.next == null) {
            return;
    }
	head = head.next;
}

• 删除指定节点：找到待删除节点的前驱节点，将其指针域跳过待删除节点，直接指向待删除节点的后继节点。同时释放待删除节点的内存。

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.println("没有找到" + no + "节点，删除失败");
        }
    }

• 删除尾节点：需要从头开始遍历链表找到倒数第二个节点（即尾节点的前驱），将其指针域置为 NULL，并释放尾节点的内存。

public void deleteTail() {
	// 初始化辅助指针
	HeroNode prev = null;
	HeroNode current = head;
	// 遍历链表查找倒数第二个节点
	while (current != null && current.next != null) {
        prev = current;
        temp = temp.next;
	}
	// 如果链表非空，则进行删除操作
    if (current != null) {
        // 修改指针，断开尾节点与链表的连接
        prev.next = null;
        // Java 中自动垃圾回收，无需手动释放内存
    }
}

查找节点

• 按值查找：从头节点开始，逐个比较节点数据域的值与目标值，直到找到匹配的节点或遍历完链表。

/**
     * 查找指定编号的英雄节点
     *
     * @param no 要查找的英雄编号
     * @return 找到的英雄节点，如果未找到或链表为空则返回null
     */
    public HeroNode searchHeroByNo(int no) {
        // 检查链表是否为空
        if (head == null) {
            return null;
        }

        HeroNode temp = head;
        while (temp != null) {
            // 如果找到匹配的节点，直接返回该节点
            if (temp.no == no) {
                return temp;
            }

            // 移动到下一个节点
            temp = temp.next;
        }

        // 如果遍历完整个链表仍未找到匹配的节点，返回null
        return null;
    }

• 按位置查找：给定一个索引，从头节点开始计数，依次访问相应位置的节点
不做赘述

更新节点

• 给定一个节点的指针或索引，可以直接修改其数据域的值。

public void update(HeroNode newHeroNode) {
	if (head == null) {
		return;
	}
	HeroNode targetNode = head。next;//我们规定头结点没有数据
	while (targetNode != null) {
		if (targetNode.no == newHeroNode.no) {
			targetNode.name = newHeroNode.name;
            targetNode.nickname = newHeroNode.nickname;
			return;
		}
		targetNode = targetNode.next;
	}
}

进阶操作

为操作方便先给出链表长度的方法

/**
     * 获取到链表的长度（节点的个数, 如果是头结点的链表需要不统计）
     */
    public int getLength(HeroNode head) {
        if (head.next == null) {
            return 0;
        }
        int length = 0;
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

查找倒数第k个节点

/**
     * 查找单链表中倒数第k个节点
     * 1. 编写一个方法，接收head节点，同时接收一个index
     * 2. index表示是倒数第index个节点
     * 3. 先把链表从头到尾遍历，得到链表的总的长度getLength
     * 4. 得到size后，我们从链表的第一个开始遍历（size-index）个，就可以得到
     */
     public HeroNode findLastIndexNode(HeroNode head, int index) {
        if (head.next == null) {
            return null;
        }
        int size = getLength(head);
        if (index <= 0 || index > size) {
            return null;
        }
        HeroNode temp = head.next;
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
  	 }

完成对链表的反转

/**
     * 完成单链表的反转
     * 
     * @param head 单链表的头节点
     * @return 反转后的链表的头节点
     */
    public HeroNode reverseList(HeroNode head) {
        // 如果链表为空或只有一个节点，无需反转，直接返回头节点
        if (head.next == null || head.next.next == null) {
            return head;
        }
        // 定义一个辅助节点，用于遍历链表
        HeroNode cur = head.next;
        HeroNode next = null; // 指向当前节点[cur]的下一个节点
        // 创建一个虚拟头节点，用于构建反转后的链表
        HeroNode reverseHead = new HeroNode(0, "", "");
        // 遍历链表，将每个节点从原链表中移除并插入到新链表的头部，实现链表反转
        while (cur != null) {
            next = cur.next; // 保存当前节点的下一个节点
            // 将当前节点[cur]的下一个节点指向新链表的头部
            cur.next = reverseHead.next; 
            reverseHead.next = cur; // 将当前节点[cur]连接到新链表的头部
            cur = next; // 更新当前节点为下一个节点
        }
        // 将原链表的头节点的下一个节点指向反转后链表的头节点，完成反转
        head.next = reverseHead.next;
        return head;
    }

逆序打印

/**
     * 从未到头打印单链表
     * 方式一：先反转链表，再打印链表
     * 但是这样做的问题是会破坏原来的链表结构，
     * 如果需要操作原来的链表，就不能这样做
     * 方式二：使用栈，将链表节点压入栈中，利用栈的先进后出的特点，就实现了逆序打印的效果
     */
    public void reversePrint(HeroNode head) {
        if (head.next == null) {
            return;
        }
        Stack<HeroNode> stack = new Stack<>();
        HeroNode cur = head.next;
        //将链表的所有节点压入栈中
        while (cur != null) {
            stack.push(cur);
            cur = cur.next;
        }
        //将栈中的节点进行打印，pop出栈顶元素
        while (!stack.isEmpty()) {
            System.out.println(stack.pop());//栈的特点先进后出
        }
    }