1.链表（Linked List）介绍
链表是有序的列表，但是它在内存中的存储如下.
小结：
链表是以节点的方式来存储，是链式存储；
每个节点包含 data 域，next 域，next 域指向下一个节点；
如图，发现链表的各个节点不一定是连续存放的；
链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。
单链表（带头结点）逻辑结构示意图如下
2.单链表的应用实例
需求：
使用带head头的单向链表实现-水浒英雄排行榜管理
（1）完成对英雄人物的增删改查操作；
（2）第一种方法在添加英雄时，直接添加到链表的尾部；
（3）第二种方式在添加英雄时，根据排名将英雄插入到指定位置（如果有这个排名，则添加失败，并给出提示）。
单链表创建示意图
第一种方法添加节点思路分析：
（1）先创建一个 head 头节点，作用就是表示单链表的头；
（2）后面我们每添加一个节点，就直接加入到链表的最后；
遍历节点思路分析：
（1）通过一个辅助变量遍历，帮助遍历整个链表；
代码如下：
/**
* 单链表
*/
public class SingleLinkedListDemo {
public static void main(String[] args) {
// 进行测试
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
// 加入
singleLinkedList.add(hero1);
singleLinkedList.add(hero4);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
// 显示
singleLinkedList.list();
}
}
// 定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
// 先初始化一个头节点，头节点不要动
private HeroNode head = new HeroNode(0, "", "");
// 添加节点到单向链表
// 1.当不考虑序号的顺序时，找到当前链表的最后节点
// 2.将最后这个节点的next 指向新的节点
public void add(HeroNode heroNode) {
// 因为head 节点不能动，因此需要一个辅助遍历temp
HeroNode temp = head;
while (true) {
// 找到链表的最后
if (temp.next == null) {
break;
}
// 如果没有找到，将temp 后移
temp = temp.next;
}
// 当退出while循环时，temp就指向了链表的最后，将最后这个节点的next 指向新的节点
temp.next = heroNode;
}
// 显示链表【遍历】
public void list() {
// 判断链表是否为空
if(head.next == null){
System.out.println("链表为空");
return;
}
// 因为头节点，不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true){
// 判断是否到链表的最后
if(temp == null){
break;
}
// 输出节点的信息
System.out.println(temp);
// 将 temp 后移，否则死循环
temp = temp.next;
}
}
}
// 定义HeroNode，每个HeroNode 的对象就是一个节点
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;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}第二种方法按照编号顺序添加节点思路分析：
（1）首先找到新添加的节点的位置，通过辅助指针查找，通过遍历查找；
（2）新的节点.next = temp.next；
（3）将 temp.next = 新的节点；
单链表删除思路分析：
（1）先找到需要删除的这个节点的前一个节点temp；
（2）temp.next = temp.next.next；
（3）被删除的节点，将不会有其他引用指向，会被垃圾回收
代码如下：
/**
* 单链表
*/
public class SingleLinkedListDemo {
public static void main(String[] args) {
// 进行测试
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
// 加入
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero1);
// singleLinkedList.addByOrder(hero3);
// 显示
singleLinkedList.list();
// 测试修改节点
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
System.out.println("~~~~~~修改后链表~~~~~~");
// 显示
singleLinkedList.list();
// 删除
singleLinkedList.delete(3);
System.out.println("~~~~~~删除后链表~~~~~~");
// 显示
singleLinkedList.list();
}
}
// 定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
// 先初始化一个头节点，头节点不要动
private HeroNode head = new HeroNode(0, "", "");
// 添加节点到单向链表
// 1.当不考虑序号的顺序时，找到当前链表的最后节点
// 2.将最后这个节点的next 指向新的节点
public void add(HeroNode heroNode) {
// 因为head 节点不能动，因此需要一个辅助遍历temp
HeroNode temp = head;
while (true) {
// 找到链表的最后
if (temp.next == null) {
break;
}
// 如果没有找到，将temp 后移
temp = temp.next;
}
// 当退出while循环时，temp就指向了链表的最后，将最后这个节点的next 指向新的节点
temp.next = heroNode;
}
// 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
// （如果有这个排名，则添加失败，并给出提示）
public void addByOrder(HeroNode heroNode) {
// 因为head 节点不能动，因此需要一个辅助指针找到添加的位置
// 因为单链表。我们找的temp是位于添加位置的前一个节点，否则插入不了
HeroNode temp = head;
// 标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
// 说明 temp 已经在链表的最后
break;
}
if (temp.next.no > heroNode.no) {
// 位置找到，就在temp的后面插入
break;
} else if (temp.next.no == heroNode.no) {
// 说明希望添加的heroNode的编号已经存在
flag = true;
}
// 后移
temp = temp.next;
}
// 判断flag的值
if (flag) {
// 不能添加，说明编号存在
System.out.printf("准备插入的英雄的编号%d 已经存在了，不能加入\n", heroNode.no);
} else {
// 插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 显示链表【遍历】
public void list() {
// 判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 因为头节点，不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
// 判断是否到链表的最后
if (temp == null) {
break;
}
// 输出节点的信息
System.out.println(temp);
// 将 temp 后移，否则死循环
temp = temp.next;
}
}
// 修改节点信息，根据no编号来修改，即编号不能改
// 说明
// 1.根据newHeroNode的no来修改即可
public void update(HeroNode newHeroNode) {
// 判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 找到需要修改的节点，根据no编号
// 定义一个辅助变量
HeroNode temp = head;
// 表示是否找到该节点
boolean flag = false;
while (true) {
if(temp == null){
// 到链表的最后，已经遍历完链表
break;
}
if(temp.no == newHeroNode.no){
// 找到了
flag = true;
break;
}
temp = temp.next;
}
// 根据 flag 判断是否找到要修改的节点
if(flag){
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
}else{
// 没有找到节点
System.out.printf("没有找到编号%d 的节点，不能修改\n", newHeroNode.no);
}
}
// 删除节点
public void delete(int no){
HeroNode temp = head;
// 标志是否找到待删除的节点
boolean flag = false;
while (true){
if(temp.next == null){
// 已经遍历完
break;
}
if(temp.next.no == no){
// 已经找到待删除节点的前一个节点的temp
flag = true;
break;
}
// 后移
temp = temp.next;
}
if(flag){
// 删除
temp.next = temp.next.next;
}else{
System.out.printf("要删除的 %d的节点不存在", no);
}
}
}
// 定义HeroNode，每个HeroNode 的对象就是一个节点
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;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}3.单链表面试题
单链表常见面试题有如下：
（1）求单链表中有效节点的个数。
（2）查找单链表中的倒数第k个节点【新浪面试题】。
（3）单链表的反转【腾讯面试题】。
（4）从尾到头打印单链表【百度，要求方式1：反向遍历。方式2：Stack栈】。
（5）合并两个有序的单链表，合并之后的链表依然有序。
package com.shangguigu.datastructure.linkedlist;
import java.util.Stack;
/**
* 单链表
*/
public class SingleLinkedListDemo {
public static void main(String[] args) {
// 进行测试
HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");
// 创建链表
SingleLinkedList singleLinkedList = new SingleLinkedList();
// 加入
singleLinkedList.addByOrder(hero2);
singleLinkedList.addByOrder(hero4);
singleLinkedList.addByOrder(hero3);
singleLinkedList.addByOrder(hero1);
// singleLinkedList.addByOrder(hero3);
// 显示
singleLinkedList.list();
// 测试修改节点
HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
singleLinkedList.update(newHeroNode);
System.out.println("~~~~~~修改后链表~~~~~~");
// 显示
singleLinkedList.list();
// 删除
singleLinkedList.delete(3);
System.out.println("~~~~~~删除后链表~~~~~~");
// 显示
singleLinkedList.list();
// 测试一下 求单链表中有效节点的个数
System.out.println(SingleLinkedList.getLength(singleLinkedList.getHead()));
// 测试，得到倒数第k个节点
System.out.println(SingleLinkedList.findLastIndexNode(singleLinkedList.getHead(), 4));
// 测试，单链表反转
SingleLinkedList.reverseList(singleLinkedList.getHead());
System.out.println("~~~~~~~~~反转后单链表~~~~~~~~~~");
singleLinkedList.list();
System.out.println("~~~~~~~~~反转后单链表~~~~~~~~~~");
// 测试，从尾到头打印单链表
SingleLinkedList.reversePrint(singleLinkedList.getHead());
// 测试合并
SingleLinkedList singleLinkedList2 = new SingleLinkedList();
HeroNode hero11 = new HeroNode(6, "张三", "小张~~");
HeroNode hero22 = new HeroNode(8, "李四", "小李~~");
HeroNode hero33 = new HeroNode(5, "王五", "小王~~");
singleLinkedList2.addByOrder(hero11);
singleLinkedList2.addByOrder(hero22);
singleLinkedList2.addByOrder(hero33);
singleLinkedList2.list();
singleLinkedList2.combineLinkedList(singleLinkedList);
System.out.println("~~~~~~~~合并后单链表~~~~~~~~~~");
singleLinkedList2.list();
}
}
// 定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
// 先初始化一个头节点，头节点不要动
private HeroNode head = new HeroNode(0, "", "");
public HeroNode getHead() {
return head;
}
public void setHead(HeroNode head) {
this.head = head;
}
// 添加节点到单向链表
// 1.当不考虑序号的顺序时，找到当前链表的最后节点
// 2.将最后这个节点的next 指向新的节点
public void add(HeroNode heroNode) {
// 因为head 节点不能动，因此需要一个辅助遍历temp
HeroNode temp = head;
while (true) {
// 找到链表的最后
if (temp.next == null) {
break;
}
// 如果没有找到，将temp 后移
temp = temp.next;
}
// 当退出while循环时，temp就指向了链表的最后，将最后这个节点的next 指向新的节点
temp.next = heroNode;
}
// 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
// （如果有这个排名，则添加失败，并给出提示）
public void addByOrder(HeroNode heroNode) {
// 因为head 节点不能动，因此需要一个辅助指针找到添加的位置
// 因为单链表。我们找的temp是位于添加位置的前一个节点，否则插入不了
HeroNode temp = head;
// 标识添加的编号是否存在，默认为false
boolean flag = false;
while (true) {
if (temp.next == null) {
// 说明 temp 已经在链表的最后
break;
}
if (temp.next.no > heroNode.no) {
// 位置找到，就在temp的后面插入
break;
} else if (temp.next.no == heroNode.no) {
// 说明希望添加的heroNode的编号依然存在
flag = true;
}
// 后移
temp = temp.next;
}
// 判断flag的值
if (flag) {
// 不能添加，说明编号存在
System.out.printf("准备插入的英雄的编号%d 已经存在了，不能加入\n", heroNode.no);
} else {
// 插入到链表中
heroNode.next = temp.next;
temp.next = heroNode;
}
}
// 显示链表【遍历】
public void list() {
// 判断链表是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 因为头节点，不能动，因此需要一个辅助变量来遍历
HeroNode temp = head.next;
while (true) {
// 判断是否到链表的最后
if (temp == null) {
break;
}
// 输出节点的信息
System.out.println(temp);
// 将 temp 后移，否则死循环
temp = temp.next;
}
}
// 修改节点信息，根据no编号来修改，即编号不能改
// 说明
// 1.根据newHeroNode的no来修改即可
public void update(HeroNode newHeroNode) {
// 判断是否为空
if (head.next == null) {
System.out.println("链表为空");
return;
}
// 找到需要修改的节点，根据no编号
// 定义一个辅助变量
HeroNode temp = head;
// 表示是否找到该节点
boolean flag = false;
while (true) {
if (temp == null) {
// 到链表的最后，已经遍历完链表
break;
}
if (temp.no == newHeroNode.no) {
// 找到了
flag = true;
break;
}
temp = temp.next;
}
// 根据 flag 判断是否找到要修改的节点
if (flag) {
temp.name = newHeroNode.name;
temp.nickname = newHeroNode.nickname;
} else {
// 没有找到节点
System.out.printf("没有找到编号%d 的节点，不能修改\n", newHeroNode.no);
}
}
// 删除节点
public void delete(int no) {
HeroNode temp = head;
// 标志是否找到待删除的节点
boolean flag = false;
while (true) {
if (temp.next == null) {
// 已经遍历完
break;
}
if (temp.next.no == no) {
// 已经找到待删除节点的前一个节点的temp
flag = true;
break;
}
// 后移
temp = temp.next;
}
if (flag) {
// 删除
temp.next = temp.next.next;
} else {
System.out.printf("要删除的 %d的节点不存在", no);
}
}
/**
* 获取到单链表的节点的个数（如果是带头结点的链表，不统计头节点）
*
* @param head 链表的头节点
* @return 返回的就是有效节点的个数
*/
public static int getLength(HeroNode head) {
if (head.next == null) {
// 空链表
return 0;
}
int length = 0;
// 定义一个辅助的变量
HeroNode cur = head.next;
while (cur != null) {
length++;
cur = cur.next;
}
return length;
}
// 查找单链表中的倒数第k个节点【新浪面试题】
// 思路
// 1.编写一个方法，接收head节点，同时接收一个index
// 2.index 表示是倒数第 index个节点
// 3.先把链表从头遍历，得到链表的总长度
// 4.得到size后，从链表的第一个开始遍历（size-index）个
// 5.如果找到返回该节点，否则返回空
public static HeroNode findLastIndexNode(HeroNode head, int index) {
// 判断如果链表为空，返回null
if (head.next == null) {
return null;
}
// 第一次遍历得到节点个数
int size = getLength(head);
// 第二次遍历 size-index 位置
// 先做index 校验
if (index <= 0 || index > size) {
return null;
}
// 定义一个辅助变量，for循环定位
HeroNode cur = head.next;
for (int i = 0; i < size - index; i++) {
cur = cur.next;
}
return cur;
}
// 单链表的反转【腾讯面试题】
public static void reverseList(HeroNode head) {
// 如果当前链表为空，或者只有一个节点，无需反转，直接返回
if (head.next == null || head.next.next == null) {
return;
}
// 定义一个辅助的指针，帮助我们遍历原来的链表
HeroNode cur = head.next;
// 指向当前节点的下一个节点
HeroNode next = null;
HeroNode reverseHead = new HeroNode(0, "", "");
// 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
while (cur != null) {
// 先暂时保存当前节点的下一个节点，后面会使用
next = cur.next;
// 将当前节点的下一个节点指向新的链表的最前端
cur.next = reverseHead.next;
// 将 cur 连接到新的链表上
reverseHead.next = cur;
// 让cur后移
cur = next;
}
// 将head.next 指向reverseHead.next，实现单链表的反转
head.next = reverseHead.next;
}
// 从尾到头打印单链表【百度，要求方式1：反向遍历。方式2：Stack栈】
// 思路
// 1.方式1：现将单链表进行反转操作，然后再遍历即可，这样做的问题是会破坏原来的单链表的结构，不建议
// 2.方式2：可以利用栈这个数据结构，将各个节点压入栈中，利用栈的先进后出的特点，实现逆序打印的效果
public static 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 = cur.next;
}
// 将栈中的节点进行打印，pop 出栈
while (stack.size() > 0) {
System.out.println(stack.pop());
}
}
// 合并两个有序的单链表，合并之后的链表依然有序
public void combineLinkedList(SingleLinkedList singleLinkedList) {
// 如果链表为空，直接返回
HeroNode head = singleLinkedList.getHead();
if (head.next == null) {
return;
}
HeroNode cur = head.next;
HeroNode next = null;
while (cur != null){
// 先暂时保存当前节点的下一个节点
next = cur.next;
// 添加节点
this.addByOrder(cur);
// 后移
cur = next;
}
}
}
// 定义HeroNode，每个HeroNode 的对象就是一个节点
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;
}
@Override
public String toString() {
return "HeroNode{" +
"no=" + no +
", name='" + name + '\'' +
", nickname='" + nickname + '\'' +
'}';
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
