Java数据结构之单链表的实现与面试题汇总
作者：兴趣使然黄小黄
由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。本文为大家介绍了单链表的实现与面试题汇总，感兴趣的可以了解一下
1 单链表
1.1 单链表介绍
由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。单链表通过一组任意的存储单元来存储线性表中的数据元素，不需要使用地址连续的存储单元，因此它 不要求在逻辑上相邻的两个元素在物理位置上也相邻。
物理结构示意图：
逻辑结构示意图：
关于单链表的一些说明：
- 链表是以节点的方式存储的，每个节点包含data和next域，分别表示存储的数据和指向下一个节点；
- 链表的各个节点不一定是连续存储的；
- 可以根据实际需求来构造是否带有头节点的链表。
1.2 单链表的实现思路分析
1.2.1 单链表的创建与遍历
单链表的创建：
先创建一个 head 头节点，表示单链表的头；
每添加一个节点就直接加入链表的最后；
遍历的思路：
创建一个辅助指针，用于帮助遍历整个链表；
当指针指向的节点的next域为null，说明当前节点为最后一个，遍历完成。 1.2.2 单链表节点的插入与修改
示意图如下：
- 首先需要通过遍历找到需要添加节点的位置，图中示意的为a1的位置；
- 新的节点的next指向a1.next；
- 将该位置，即a1.next指向新的节点。
修改操作相当于上述过程的简化，只需要找到对应的节点直接修改节点对应的属性即可，这里不再赘述。
1.2.3 单链表节点的删除
删除序号为 “2” 的节点示意图如下：
思路如下：
- 找到待删除节点的前一个节点，示例中则找到序号为1的节点；
- 让该节点的 temp.next = temp.next.next，即可；
- 由于被删除的节点没有其他的指向，则会由Java的垃圾回收机制进行回收，无需处理。
1.3 实现代码
StudentNode.java 节点类：
/**
* @author 兴趣使然黄小黄
* @version 1.0
* 链表的节点类，包含学生信息和next
*/
public class StudentNode {
public String no; //学号
public String name; //姓名
public int age; //年龄
public StudentNode next; //指向下一个节点
//构造器
public StudentNode(String no, String name, int age ){
this.no = no;
this.name = name;
this.age = age;
}
//为了显示方便
@Override
public String toString() {
return "StudentNode{" +
"no='" + no + '\'' +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
StudentLinkedList.java 链表的实现类：
/**
* @author 兴趣使然黄小黄
* @version 1.0
* 链表的实现类，用于管理众多StudentNode节点
*/
public class StudentLinkedList {
//初始化头节点
private StudentNode head = new StudentNode("", "", 0);
//获取头节点
public StudentNode getHead() {
return head;
}
//添加节点
//1.找到当前链表的最后节点
//2.将最后节点的next指向新的节点
public void add(StudentNode studentNode) {
StudentNode temp = head;
//遍历链表找到最后的节点
while (temp.next != null) {
//没有找到，就后移
temp = temp.next;
}
//最后的节点的next指向新节点
temp.next = studentNode;
}
//遍历 显示链表
public void showList(){
//判断链表是否为空
if (head.next == null){
System.out.println("当前链表为空");
return;
}
//遍历 使用辅助指针
StudentNode temp = head;
while (temp != null){
//更新指针
temp = temp.next;
if (temp.next == null){
System.out.print(temp);
break;
}
System.out.print(temp + "--->");
}
}
//插入节点
//根据学号顺序查找添加的位置, 如果存在, 则提示错误信息
public void addByOrder(StudentNode studentNode){
//寻找的temp应该为添加位置的前一个节点
StudentNode temp = head;
boolean flag = false; //标识新添加的no是否已经存在
while (true){
if (temp.next == null){
//已经在链表的尾部
break;
}
if (Integer.parseInt(temp.next.no) > Integer.parseInt(studentNode.no)){
//位置找到 插入到temp后
break;
}else if (Integer.parseInt(temp.next.no) == Integer.parseInt(studentNode.no)){
//已经存在
flag = true;
break;
}
//移动指针
temp = temp.next;
}
if (flag){
System.out.println("\n准备插入的学生信息: " + studentNode.no + "，该学号已经存在，不可添加！");
}else {
studentNode.next = temp.next;
temp.next = studentNode;
}
}
//根据no学号修改学生信息
public void update(StudentNode studentNode){
if (head.next == null){
System.out.println("当前链表为空, 无法修改");
return;
}
StudentNode temp = head.next;
boolean flag = false; //表示是否找到节点
while (true){
if (temp == null){
break;
}
if (temp.no == studentNode.no){
flag = true;
break;
}
temp = temp.next;
}
if (flag){
temp.name = studentNode.name;
temp.age = studentNode.age;
}else {
System.out.println("没有找到");
}
}
//删除节点
public void delete(String no){
StudentNode 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;
System.out.println("删除成功！");
}else {
System.out.println("要删除的节点不存在！");
}
}
}
测试类：
/**
* @author 兴趣使然黄小黄
* @version 1.0
* 测试链表
*/
public class StudentListTest {
public static void main(String[] args) {
StudentNode node1 = new StudentNode("1", "黄小黄", 21);
StudentNode node2 = new StudentNode("2", "懒羊羊", 21);
StudentNode node3 = new StudentNode("3", "沸羊羊", 22);
//创建单链表 录入数据 输出
StudentLinkedList list = new StudentLinkedList();
list.add(node1);
list.add(node2);
list.add(node3);
System.out.println("遍历链表:");
list.showList();
//测试插入数据方法
StudentNode node5 = new StudentNode("5", "美羊羊", 19);
StudentNode node4 = new StudentNode("4", "暖羊羊", 19);
list.addByOrder(node5);
list.addByOrder(node4);
System.out.println("\n依次插入学号为5、4的学生后:");
list.showList();
//测试修改方法
System.out.println("\n测试修改方法:");
list.update(new StudentNode("1", "祢豆子", 10));
list.showList();
//测试删除方法
System.out.println("\n测试删除方法:");
list.delete("1");
list.delete("5");
list.showList();
}
}
实现结果：
遍历链表:
StudentNode{no='1', name='黄小黄', age=21}--->StudentNode{no='2', name='懒羊羊', age=21}--->StudentNode{no='3', name='沸羊羊', age=22}
依次插入学号为5、4的学生后:
StudentNode{no='1', name='黄小黄', age=21}--->StudentNode{no='2', name='懒羊羊', age=21}--->StudentNode{no='3', name='沸羊羊', age=22}--->StudentNode{no='4', name='暖羊羊', age=19}--->StudentNode{no='5', name='美羊羊', age=19}
测试修改方法:
StudentNode{no='1', name='祢豆子', age=10}--->StudentNode{no='2', name='懒羊羊', age=21}--->StudentNode{no='3', name='沸羊羊', age=22}--->StudentNode{no='4', name='暖羊羊', age=19}--->StudentNode{no='5', name='美羊羊', age=19}
测试删除方法:
删除成功！
删除成功！
StudentNode{no='2', name='懒羊羊', age=21}--->StudentNode{no='3', name='沸羊羊', age=22}--->StudentNode{no='4', name='暖羊羊', age=19}
Process finished with exit code 0
2 单链表的面试题
2.1 统计单链表中有效节点数量
/**
*
* @param head 头节点
* @return 返回有效节点个数
*/
public static int getLength(StudentNode head){
if (head.next == null){
return 0;
}
int length = 0;
StudentNode temp = head.next;
while (temp != null){
length++;
temp = temp.next;
}
return length;
}
2.2 新浪–倒数第k个节点
查找链表中倒数第k个节点
思路分析：
- 编写一个方法，接收head头节点和index，index表示k；
- 链表从头到尾遍历，求出长度（链表节点个数）size；
- 从第一个节点，遍历size-length次，即可找到倒数第k个节点。
参考代码：
/**
* 获取单链表中倒数第k个节点
* @param head 链表的头节点
* @param index 倒数第 k 个元素
* @return 返回倒数第 k 个元素，或者 null
*/
public static StudentNode findLastIndexNode(StudentNode head, int index){
//如果链表为空
if (head.next == null){
return null;
}
//得到链表的长度(节点个数)
int size = getLength(head);
//遍历 size-index次 得到倒数第index个节点
//数据校验
if (index <= 0 || index > size){
return null;
}
//遍历
StudentNode current = head.next;
for (int i = 0; i < size - index; i++) {
current = current.next;
}
return current;
}
2.3 腾讯–单链表的反转
反转单链表
思路分析：
- 可以使用头插法；
- 以原链表为模板，每遍历一个节点，取出，并接在新链表的最前端；
- 原head头节点，指向新的节点；
- 直到遍历完为止。
参考代码：
/**
* 头插法反转链表
* @param head 接收待反转的链表
* @return 返回一个反转后的新链表
*/
public static StudentLinkedList reverseList(StudentNode head){
if (head.next == null){
return null;
}
StudentNode old = head.next; //用于遍历旧链表
//创建新链表，新链表根据原链表遍历得到
StudentLinkedList newList = new StudentLinkedList();
StudentNode newHead = newList.getHead(); //新链表的头节点
//遍历构造
boolean flag = true; //标记是否为第一次添加
while (old != null){
//头插法加入到新链表中
StudentNode newNode = new StudentNode(old.no, old.name, old.age);
if(flag){
newHead.next = newNode;
newNode.next = null;
flag = false;
}else {
newNode.next = newHead.next;
newHead.next = newNode;
}
old = old.next;
}
return newList;
}
以上方式虽然可以实现链表的反转，但是是以返回一个新的反转链表的形式，并没有真正意义上实现原地反转，下面介绍另一种方式：
双指针:
/**
* 双指针就地反转链表
* @param head 接收链表的头节点，方法中会将链表反转
*/
public static void reverse(StudentNode head){
//如果当前链表为空 或者只有一个节点 直接返回即可
if (head.next == null || head.next.next == null){
return;
}
//辅助指针遍历原来的链表
StudentNode cur = head.next; //当前节点
StudentNode next = null; //指向cur的下一个节点
StudentNode reverseHead = new StudentNode("", "", 0);
//遍历原来的链表，每遍历一个节点，就取出，放在新链表的最前端
while (cur != null){
next = cur.next; //暂时保存当前节点的下一个节点
cur.next = reverseHead.next; //讲cur下一个节点放在链表最前端
reverseHead.next = cur;
cur = next; //cur后移动
}
head.next = reverseHead.next;
return;
}
2.4 百度–逆序打印单链表
从尾到头打印单链表
方式一： 先将单链表反转，然后再打印。但是这样会破坏掉原有单链表的结构，而题目要求仅仅是打印，因此不建议！
方式二： 利用栈模拟
将单链表的各个节点压入栈中，利用栈先进后出的特点，实现逆序打印。
参考代码：
/**
* 利用栈模拟 实现链表的逆序打印
* @param head 链表的头节点
*/
public static void reversePrintList(StudentNode head){
if (head.next == null){
return; //空链表无法打印
}
//创建栈模拟逆序打印
Stack<StudentNode> stack = new Stack<>(); //栈
StudentNode cur = head.next;
//将链表的所有节点压入栈
while (cur != null){
stack.push(cur);
cur = cur.next;
}
//逆序打印
while (!stack.empty()){
//出栈
System.out.println(stack.pop());
}
return;
}
以上就是Java数据结构之单链表的实现与面试题汇总的详细内容，更多关于Java单链表的资料请关注脚本之家其它相关文章！