文章目录
1 链表
链表是有序的列表,它在内存中的存储如下:
上图小结:
<1>链表是以节点的方式存储的,是链式存储
<2>每个节点包含data域,next域(指向下一个节点)
<3>链表的各个节点不一定是连续存储
<4>链表分为带头节点的链表和和不带头节点的链表
2 单链表
单链表(带头节点)逻辑结构如下图所示
3 单链表的应用
本文列举单链表的以下应用:
(1)乱序添加节点
(2)乱序添加,根据规则排序(即操作完成后是有序的)
(3)删除节点
(4)修改节点
(5)遍历单链表
(6)获取单链表中节点的个数
(7)查询单链表的倒数第k个节点
(8)单链表反转
(9)从尾到头逆序打印单链表,类似于反转
完整代码贴于文末。
首先定义一个节点MyNode
package com.company.linkedlist;
/**
* 每个MyNode对象就是一个节点
*/
public class MyNode {
public int no;
public String name;
public String nickName;
/**
* 指向下一个节点
*/
public MyNode next;
public MyNode(int no, String name, String nickName) {
this.no = no;
this.name = name;
this.nickName = nickName;
}
@Override
public String toString() {
return "MyNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickName='" + nickName + '\'' +
'}';
}
}
接下来定义单链表:
package com.company.linkedlist;
import java.util.Stack;
/**
* 单链表
* <p>
* 思路:
* 给定链表一个虚拟的头节点,便于操作
*/
public class SingleLinkedList {
/**
* 先初始化一个虚拟头节点,虚拟头节点不动,不存放具体的数据
*/
private MyNode mVirtualHeadNode = new MyNode(0, "", "");
/**
* 返回虚拟头节点
*/
public MyNode getVirtualHeadNode() {
return mVirtualHeadNode;
}
}
3.1 乱序添加节点
/**
* 添加节点
* <p>
* 思路:当不考虑链表的最后节点
* 1、找到当前链表的最后节点
* 2、将最后这个节点的next指向新的节点
*/
public void addNode(MyNode myNode) {
// 因为mVirtualHeadNode节点不能动,因此需要一个辅助变量tempNode
MyNode tempNode = mVirtualHeadNode;
// 遍历链表,找到最后
while (true) {
// 找到链表的最后
if (tempNode.next == null) {
break;
}
// 如果没有找到最后,将tempNode后移
tempNode = tempNode.next;
}
/*
当退出while循环时,tempNode就指向了链表的最后,
再将最后这个节点的next指向新的节点
*/
tempNode.next = myNode;
}
测试代码:
package com.company.linkedlist;
public class SingleLinkedListDemo {
public static void main(String[] args) {
// 创建节点
MyNode myNode1 = new MyNode(1, "宋江", "及时雨");
MyNode myNode2 = new MyNode(2, "卢俊义", "玉麒麟");
MyNode myNode3 = new MyNode(3, "吴用", "智多星");
MyNode myNode4 = new MyNode(4, "林冲", "豹子头");
// 创建单链表
SingleLinkedList mSingleLinkedList = new SingleLinkedList();
// 乱序添加节点
mSingleLinkedList.addNode(myNode4);
mSingleLinkedList.addNode(myNode1);
mSingleLinkedList.addNode(myNode3);
mSingleLinkedList.addNode(myNode2);
// 遍历链表
mSingleLinkedList.showList();
}
}
测试效果:
3.2 乱序添加,根据规则排序(即操作完成后是有序的)
/**
* 根据顺序添加节点(乱序添加,操作完成后是有序的)
*/
public void addNodeByOrder(MyNode myNode) {
/*
因为虚拟头节点不能动,所以需要一个辅助指针(变量)来帮助找到添加的位置。
因为单链表,我们找的tempNode是位于添加位置的前一个节点,否则插入不了
*/
MyNode tempNode = mVirtualHeadNode;
// 表示添加的序号是否存在,默认为false
boolean flag = false;
while (true) {
// 已到链表的最后
if (tempNode.next == null) {
break;
}
// 找到位置,就在tempNode的后面插入
if (tempNode.next.no > myNode.no) {
break;
}
// 希望添加的节点序号已存在
if (tempNode.next.no == myNode.no) {
flag = true;
break;
}
// 后移,遍历当前链表
tempNode = tempNode.next;
}
if (flag) {
System.out.printf("该序号已存在,不可插入~~\n", myNode.no);
} else {
// 插入到链表中,tempNode的后面
myNode.next = tempNode.next;
tempNode.next = myNode;
}
}
测试代码:
// 乱序添加,顺序显示节点
mSingleLinkedList.addNodeByOrder(myNode4);
mSingleLinkedList.addNodeByOrder(myNode1);
mSingleLinkedList.addNodeByOrder(myNode3);
mSingleLinkedList.addNodeByOrder(myNode2);
// 遍历链表
mSingleLinkedList.showList();
测试效果:
3.3 删除节点
/**
* 删除节点
* <p>
* 1、虚拟头节点不动,仍需要一个辅助变量tempNode用来找到待删除节点的前一个节点
* 2、比较时,用tempNode.next.no与待删除节点的no比较
*
* @param myNode 此处可传入节点,也可传入节点序号
*/
public void deleteNode(MyNode myNode) {
MyNode tempNode = mVirtualHeadNode;
// 表示是否找到待删除节点
boolean flag = false;
while (true) {
// 已找到链表最后
if (tempNode.next == null) {
break;
}
// 找到待删除节点的前一个节点,即tempNode
if (tempNode.next.no == myNode.no) {
flag = true;
break;
}
// tempNode后移,遍历
tempNode = tempNode.next;
}
if (flag) {
tempNode.next = tempNode.next.next;
} else {
System.out.printf("待删除节点不存在,请核实~~\n", myNode.no);
}
}
测试代码:
mSingleLinkedList.deleteNode(myNode2);
删除效果:
3.4 修改节点
/**
* 修改节点
* <p>
* 根据序号来修改,因此序号不能动
*/
public void updateNode(MyNode myNode) {
// 是否为空表
if (mVirtualHeadNode.next == null) {
System.out.println("链表为空,无法修改~~");
return;
}
// 根据序号找到要修改的节点,此处也需要一个辅助变量
MyNode tempNode = mVirtualHeadNode.next;
// 是否找到该节点
boolean flag = false;
while (true) {
// 已遍历完链表
if (tempNode == null) {
break;
}
// 找到该节点
if (tempNode.no == myNode.no) {
flag = true;
break;
}
tempNode = tempNode.next;
}
if (flag) {
tempNode.name = myNode.name;
tempNode.nickName = myNode.nickName;
} else {
System.out.printf("未找到序号为%d的节点,请核实~~\n", myNode.no);
}
}
检测修改效果:
MyNode myNode = new MyNode(2, "小卢", "麒麟哥~");
mSingleLinkedList.updateNode(myNode);
效果图:
3.5 遍历单链表
/**
* 遍历(显示)单链表
*/
public void showList() {
// 判断链表是否为空
if (mVirtualHeadNode.next == null) {
System.out.println("链表为空");
return;
}
// 虚拟头节点不动,此处仍需要一个辅助变量tempNode来帮助遍历
MyNode tempNode = mVirtualHeadNode.next;
while (true) {
// 到链表最后
if (tempNode == null) {
break;
}
System.out.println(tempNode);
// 将tempNode后移,此处需注意
tempNode = tempNode.next;
}
}
检测遍历效果:
mSingleLinkedList.showList();
遍历链表的效果图就是前面看到的各种效果哦。
3.6 获取单链表中节点的个数
/**
* 获取单链表的节点个数(若是带虚拟节点的链表,则不统计虚拟节点)
*
* @param virtualHeadNode 链表的虚拟头节点
* @return 有效节点的个数
*/
public static int getLength(MyNode virtualHeadNode) {
// 空链表
if (virtualHeadNode.next == null) {
return 0;
}
int length = 0;
// 定义一个辅助变量(不统计虚拟头、尾节点)
MyNode curNode = virtualHeadNode.next;
while (curNode != null) {
length++;
// 遍历
curNode = curNode.next;
}
return length;
}
检测代码:
System.out.println("有效节点个数:" + SingleLinkedList.getLength(mSingleLinkedList.getVirtualHeadNode()));
效果:
3.7 查询单链表的倒数第k个节点
/**
* 查找单链表中的倒数第k个节点
* <p>
* 思路:
* 1、编写一个方法,接收head节点,同时接收一个index
* 2、index表示倒数第index个节点
* 3、先把链表从头到尾遍历,得到链表的总长度size,见getLength()
* 4、得到size后,从链表的第一个节点开始遍历(size-index)个就可以得到
* 5、若找到了就返回该节点,否则返回null
*
* @param virtualHeadNode 虚拟头节点
* @param index 倒数第index个节点
* @return 返回查找到的节点
*/
public static MyNode findIndexNode(MyNode virtualHeadNode, int index) {
// 如果链表为空,返回null
if (virtualHeadNode.next == null) {
return null;
}
// 第一次 遍历得到链表的长度(节点个数)
int size = getLength(virtualHeadNode);
// 第二次遍历size-index位置,就是倒数第k个节点
if (index <= 0 || index > size) {
return null;
}
// 定义辅助变量,for循环定位到倒数的index
MyNode curNode = virtualHeadNode.next;
for (int i = 0; i < size - index; i++) {
curNode = curNode.next;
}
return curNode;
}
测试代码:
MyNode findNode = SingleLinkedList.findIndexNode(mSingleLinkedList.getVirtualHeadNode(), 2);
System.out.println("倒数第2节点是:" + findNode.toString());
效果:
3.8 单链表反转
/**
* 单链表反转
*/
public static void reverseList(MyNode virtualHeadNode) {
// 如果当前链表为空,或只有一个节点,则无需反转
if (virtualHeadNode.next == null || virtualHeadNode.next.next == null) {
return;
}
// 定义一个辅助指针(变量),帮助遍历原来的链表
MyNode curNode = virtualHeadNode.next;
// 指向当前节点curNode的下一个节点
MyNode nextNode = null;
MyNode reverseHeadNode = new MyNode(0, "", "");
// 遍历原来的链表,每遍历一个节点就将其取出,并放在新的链表reverseHeadNode的最前端
while (curNode != null) {
// 先暂时保存当前节点的下一个节点,备用
nextNode = curNode.next;
// 将curNode的下一个节点指向新的链表的最前端
curNode.next = reverseHeadNode.next;
// 将curNode连接到新的链表上
reverseHeadNode.next = curNode;
// 让curNode后移
curNode = nextNode;
}
// 将virtualHeadNode.next指向reverseHeadNode.next,实现单链表反转
virtualHeadNode.next = reverseHeadNode.next;
}
测试代码:
SingleLinkedList.reverseList(mSingleLinkedList.getVirtualHeadNode());
效果:
3.9 从尾到头逆序打印单链表,类似于反转
该例需要用到栈结构Stack,这里先给一个Stack的示例。
package com.company.linkedlist;
import java.util.Stack;
/**
* 演示栈Stack的基本使用
*/
public class TestStack {
public static void main(String[] args) {
Stack<String> stack = new Stack<>();
// 入栈
stack.add("jack");
stack.add("tom");
stack.add("smith");
// 出栈
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
}
调用出栈方法后,就已经实现逆序效果了:
以上就是栈Stack的示例,接下来看逆序打印链表。
逆序打印单链表代码:
/**
* 从尾到头逆序打印单链表,类似于反转
* <p>
* 思路:
* 将各个节点压入栈中,利用栈的先进后出的特性实现逆序打印
*/
public static void reversePrint(MyNode virtualHeadNode) {
// 空链表不能打印
if (virtualHeadNode.next == null) {
return;
}
// 创建一个栈,将各个节点压入栈
Stack<MyNode> stack = new Stack<>();
MyNode curNode = virtualHeadNode.next;
// 将链表的所有节点压入栈
while (curNode != null) {
stack.push(curNode);
// curNode后移,这样可以压入下一个节点
curNode = curNode.next;
}
// 出栈即为逆序
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
测试代码:
SingleLinkedList.reversePrint(mSingleLinkedList.getVirtualHeadNode());
效果:
4 完整代码
4.1 SingleLinkedList.java:
package com.company.linkedlist;
import java.util.Stack;
/**
* 单链表
* <p>
* 思路:
* 给定链表一个虚拟的头节点,便于操作
*/
public class SingleLinkedList {
/**
* 先初始化一个虚拟头节点,虚拟头节点不动,不存放具体的数据
*/
private MyNode mVirtualHeadNode = new MyNode(0, "", "");
/**
* 返回虚拟头节点
*/
public MyNode getVirtualHeadNode() {
return mVirtualHeadNode;
}
/**
* 添加节点
* <p>
* 思路:当不考虑链表的最后节点
* 1、找到当前链表的最后节点
* 2、将最后这个节点的next指向新的节点
*/
public void addNode(MyNode myNode) {
// 因为mVirtualHeadNode节点不能动,因此需要一个辅助变量tempNode
MyNode tempNode = mVirtualHeadNode;
// 遍历链表,找到最后
while (true) {
// 找到链表的最后
if (tempNode.next == null) {
break;
}
// 如果没有找到最后,将tempNode后移
tempNode = tempNode.next;
}
/*
当退出while循环时,tempNode就指向了链表的最后,
再将最后这个节点的next指向新的节点
*/
tempNode.next = myNode;
}
/**
* 根据顺序添加节点(乱序添加,操作完成后是有序的)
*/
public void addNodeByOrder(MyNode myNode) {
/*
因为虚拟头节点不能动,所以需要一个辅助指针(变量)来帮助找到添加的位置。
因为单链表,我们找的tempNode是位于添加位置的前一个节点,否则插入不了
*/
MyNode tempNode = mVirtualHeadNode;
// 表示添加的序号是否存在,默认为false
boolean flag = false;
while (true) {
// 已到链表的最后
if (tempNode.next == null) {
break;
}
// 找到位置,就在tempNode的后面插入
if (tempNode.next.no > myNode.no) {
break;
}
// 希望添加的节点序号已存在
if (tempNode.next.no == myNode.no) {
flag = true;
break;
}
// 后移,遍历当前链表
tempNode = tempNode.next;
}
if (flag) {
System.out.printf("该序号已存在,不可插入~~\n", myNode.no);
} else {
// 插入到链表中,tempNode的后面
myNode.next = tempNode.next;
tempNode.next = myNode;
}
}
/**
* 删除节点
* <p>
* 1、虚拟头节点不动,仍需要一个辅助变量tempNode用来找到待删除节点的前一个节点
* 2、比较时,用tempNode.next.no与待删除节点的no比较
*
* @param myNode 此处可传入节点,也可传入节点序号
*/
public void deleteNode(MyNode myNode) {
MyNode tempNode = mVirtualHeadNode;
// 表示是否找到待删除节点
boolean flag = false;
while (true) {
// 已找到链表最后
if (tempNode.next == null) {
break;
}
// 找到待删除节点的前一个节点,即tempNode
if (tempNode.next.no == myNode.no) {
flag = true;
break;
}
// tempNode后移,遍历
tempNode = tempNode.next;
}
if (flag) {
tempNode.next = tempNode.next.next;
} else {
System.out.printf("待删除节点不存在,请核实~~\n", myNode.no);
}
}
/**
* 修改节点
* <p>
* 根据序号来修改,因此序号不能动
*/
public void updateNode(MyNode myNode) {
// 是否为空表
if (mVirtualHeadNode.next == null) {
System.out.println("链表为空,无法修改~~");
return;
}
// 根据序号找到要修改的节点,此处也需要一个辅助变量
MyNode tempNode = mVirtualHeadNode.next;
// 是否找到该节点
boolean flag = false;
while (true) {
// 已遍历完链表
if (tempNode == null) {
break;
}
// 找到该节点
if (tempNode.no == myNode.no) {
flag = true;
break;
}
tempNode = tempNode.next;
}
if (flag) {
tempNode.name = myNode.name;
tempNode.nickName = myNode.nickName;
} else {
System.out.printf("未找到序号为%d的节点,请核实~~\n", myNode.no);
}
}
/**
* 遍历(显示)单链表
*/
public void showList() {
// 判断链表是否为空
if (mVirtualHeadNode.next == null) {
System.out.println("链表为空");
return;
}
// 虚拟头节点不动,此处仍需要一个辅助变量tempNode来帮助遍历
MyNode tempNode = mVirtualHeadNode.next;
while (true) {
// 到链表最后
if (tempNode == null) {
break;
}
System.out.println(tempNode);
// 将tempNode后移,此处需注意
tempNode = tempNode.next;
}
}
/**
* 获取单链表的节点个数(若是带虚拟节点的链表,则不统计虚拟节点)
*
* @param virtualHeadNode 链表的虚拟头节点
* @return 有效节点的个数
*/
public static int getLength(MyNode virtualHeadNode) {
// 空链表
if (virtualHeadNode.next == null) {
return 0;
}
int length = 0;
// 定义一个辅助变量(不统计虚拟头、尾节点)
MyNode curNode = virtualHeadNode.next;
while (curNode != null) {
length++;
// 遍历
curNode = curNode.next;
}
return length;
}
/**
* 查找单链表中的倒数第k个节点
* <p>
* 思路:
* 1、编写一个方法,接收head节点,同时接收一个index
* 2、index表示倒数第index个节点
* 3、先把链表从头到尾遍历,得到链表的总长度size,见getLength()
* 4、得到size后,从链表的第一个节点开始遍历(size-index)个就可以得到
* 5、若找到了就返回该节点,否则返回null
*
* @param virtualHeadNode 虚拟头节点
* @param index 倒数第index个节点
* @return 返回查找到的节点
*/
public static MyNode findIndexNode(MyNode virtualHeadNode, int index) {
// 如果链表为空,返回null
if (virtualHeadNode.next == null) {
return null;
}
// 第一次 遍历得到链表的长度(节点个数)
int size = getLength(virtualHeadNode);
// 第二次遍历size-index位置,就是倒数第k个节点
if (index <= 0 || index > size) {
return null;
}
// 定义辅助变量,for循环定位到倒数的index
MyNode curNode = virtualHeadNode.next;
for (int i = 0; i < size - index; i++) {
curNode = curNode.next;
}
return curNode;
}
/**
* 单链表反转
*/
public static void reverseList(MyNode virtualHeadNode) {
// 如果当前链表为空,或只有一个节点,则无需反转
if (virtualHeadNode.next == null || virtualHeadNode.next.next == null) {
return;
}
// 定义一个辅助指针(变量),帮助遍历原来的链表
MyNode curNode = virtualHeadNode.next;
// 指向当前节点curNode的下一个节点
MyNode nextNode = null;
MyNode reverseHeadNode = new MyNode(0, "", "");
// 遍历原来的链表,每遍历一个节点就将其取出,并放在新的链表reverseHeadNode的最前端
while (curNode != null) {
// 先暂时保存当前节点的下一个节点,备用
nextNode = curNode.next;
// 将curNode的下一个节点指向新的链表的最前端
curNode.next = reverseHeadNode.next;
// 将curNode连接到新的链表上
reverseHeadNode.next = curNode;
// 让curNode后移
curNode = nextNode;
}
// 将virtualHeadNode.next指向reverseHeadNode.next,实现单链表反转
virtualHeadNode.next = reverseHeadNode.next;
}
/**
* 从尾到头逆序打印单链表,类似于反转
* <p>
* 思路:
* 将各个节点压入栈中,利用栈的先进后出的特性实现逆序打印
*/
public static void reversePrint(MyNode virtualHeadNode) {
// 空链表不能打印
if (virtualHeadNode.next == null) {
return;
}
// 创建一个栈,将各个节点压入栈
Stack<MyNode> stack = new Stack<>();
MyNode curNode = virtualHeadNode.next;
// 将链表的所有节点压入栈
while (curNode != null) {
stack.push(curNode);
// curNode后移,这样可以压入下一个节点
curNode = curNode.next;
}
// 出栈即为逆序
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
/**
* 合并两个有序的单链表,合并后的链表仍然有序(请读者思考完成)
*/
}
4.2 SingleLinkedListDemo.java:
package com.company.linkedlist;
public class SingleLinkedListDemo {
public static void main(String[] args) {
// 创建节点
MyNode myNode1 = new MyNode(1, "宋江", "及时雨");
MyNode myNode2 = new MyNode(2, "卢俊义", "玉麒麟");
MyNode myNode3 = new MyNode(3, "吴用", "智多星");
MyNode myNode4 = new MyNode(4, "林冲", "豹子头");
// 创建单链表
SingleLinkedList mSingleLinkedList = new SingleLinkedList();
// 乱序添加节点
mSingleLinkedList.addNode(myNode4);
mSingleLinkedList.addNode(myNode1);
mSingleLinkedList.addNode(myNode3);
mSingleLinkedList.addNode(myNode2);
// 乱序添加,顺序显示节点
mSingleLinkedList.addNodeByOrder(myNode4);
mSingleLinkedList.addNodeByOrder(myNode1);
mSingleLinkedList.addNodeByOrder(myNode3);
mSingleLinkedList.addNodeByOrder(myNode2);
// 遍历链表
mSingleLinkedList.showList();
System.out.println("----");
// 删除节点
mSingleLinkedList.deleteNode(myNode2);
// 修改节点
MyNode myNode = new MyNode(2, "小卢", "麒麟哥~");
mSingleLinkedList.updateNode(myNode);
// 求单链表中有效节点个数
System.out.println("有效节点个数:" + SingleLinkedList.getLength(mSingleLinkedList.getVirtualHeadNode()));
// 查找倒数第k个节点
MyNode findNode = SingleLinkedList.findIndexNode(mSingleLinkedList.getVirtualHeadNode(), 2);
System.out.println("倒数第2节点是:" + findNode.toString());
// 反转单链表
SingleLinkedList.reverseList(mSingleLinkedList.getVirtualHeadNode());
/*mSingleLinkedList.showList();*/
// 逆序打印单链表
SingleLinkedList.reversePrint(mSingleLinkedList.getVirtualHeadNode());
}
}
说明:
本文整理自韩顺平老师的课程,强烈推荐韩老师的课。
去公众号阅读: