本文详细介绍了链表的基本概念，包括数据域、next域、带头节点和无头节点的链表。讲解了如何在链表尾部添加节点、按编号顺序添加节点、遍历链表、修改节点信息以及删除节点的实现方法。此外，还提供了获取链表长度、查找倒数第k个节点、反转链表以及从尾到头打印链表的算法。
链表
-
链表是以节点的方式存储，是链式存储。
-
每个节点包含 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的特点是先进后出
}
}
扫一扫
3694
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
