链表 (Linked List)
一、单链表
目录:
-
1). 节点的定义
2). 插入
3). 遍历
4). 修改
5). 删除
-
1). 求链表的长度
2). 求倒数第 k 个节点
3). 反转链表
4). 合并两个有序的链表
1. 链表的存储结构:
1). 链表是有序存储的,但在内存中是按照下图方式来进行存储的
2). 我们更常见的是链表的逻辑结构,如下图所示:
2. 知识点:
1). 链表是以节点的方式来存储的,是链式存储
2). 每个节点包含 data 域, next 域,其中 next 指向下一个节点
3). 在实际的存储中,链表的各个节点不一定是连续存储的
4). 链表分带头节点和不带头节点的链表,根据实际的需求来确定;一般用头节点来代表整个链表
3. 单向链表的功能实现:
1). 节点定义:
class HeroNode{
public int no;
public String name;
public String nickname; //梁山好汉的花名
public HeroNode next;
HeroNode(int no, String name, String nickname){
this.no = no;
this.name = name;
this.nickname = nickname;
this.next = null;
}
/**
* 为了显示方便,我们便重写了 toString 方法
* @return 该英雄节点的数据域信息
*/
@Override
public String toString(){
return "HeroNode [no:" + this.no + " name:" + this.name + " nickname:" + this.nickname + " ]";
}
}
2). 插入:(重点是辅助链接 tmp 的作用)
核心步骤:
step1: 找到目标位置(即应该插入到哪里),通过遍历链表实现
step2: 将节点插入目标位置处,巧用 next 链接指向
a. 直接在链表的尾部插入
/**
* 向链表中添加节点:直接添加到链表尾部,不考虑顺序
* 思路:
* 遍历整个链表找到当前链表尾部的节点(即 next 指向 null 的节点);
* 然后另此节点的 next 指向新加入的节点,新加入的节点的 next 指向 null。
* @param heroNode 要向链表添加的节点
*/
public void add(HeroNode heroNode){
// 由于链表的头节点不能动,因此需要一个辅助遍历链表的节点引用
HeroNode tmp = this.head;
// 1. 遍历整个链表,寻找位于链表尾部的节点
while(tmp.next != null){
tmp = tmp.next;
}
// 2. 将位于尾部的节点的 next 指向新加入的节点
tmp.next = heroNode;
}
b. 在指定位置插入:
/**
* 向链表中添加节点:按照英雄序号 node.no 顺序(从小到大),并且需要判断是否存在重复节点
* 思路:
* heroNode 所添加的位置要求 tmp.no < heroNode.no < tmp.next.no
* 目标位置要是 heroNode 插入位置的前一个节点,因为这样才可以将 heroNode 插入
* step1: heroNode.next = tmp.next
* step2: tmp.next = heroNode
* @param heroNode 添加的英雄节点
*/
public void addByOrder(HeroNode heroNode){
// 是否存在重复序号节点的标志,true-存在,false-不存在
boolean flag = false;
// 凡是涉及到遍历链表的操作,那么就需要一个辅助链接 tmp
HeroNode tmp = this.head;
// 1. 遍历寻找节点插入位置
while(tmp != null){
// 出现重复英雄序号,不予插入
if(heroNode.no == tmp.no){
flag = true;
break;
}
// 如果链表为空,或者当前插入的节点序号又比当前链表中所有节点的序号都大,那么直接插在队尾
/**
* 注意:此判断一定要写在序号是否重复之后,
* 因为如果此时插入的节点序号正好与当前链表中尾部节点序号相等,
* 如果把此判断写在最前面,会没有判断序号是否重复而直接插入到链表末尾了。
*/
if(tmp.next == null){
break;
}
// 找到目标位置
if(heroNode.no < tmp.next.no){
break;
}
tmp = tmp.next;
}
// 2. 找到目标位置后,将节点插入链表中
if(!flag){
heroNode.next = tmp.next;
tmp.next = heroNode;
}else{
System.out.printf("准备插入的英雄序号%d已经存在了,不能插入\n", heroNode.no);
}
}
3). 遍历:
/**
* 遍历整个链表
* @param method 1-使用 while 循环方式遍历,2-使用 for 循环方式遍历。
*/
public void showList(int method){
// 首先链表不能为空,如果为空则立即返回
if(this.head.next == null){
System.out.println("此链表当前为空!");
return;
}
if(method == 1){
HeroNode tmp = this.head.next;
while(tmp != null){
// 对节点的操作
System.out.println(tmp);
tmp = tmp.next;
}
}else if(method == 2){
for(HeroNode tmp = this.head.next; tmp != null; tmp = tmp.next){
// 对节点的操作
System.out.println(tmp);
}
}
}
4). 修改:
/**
* 根据传入的节点 heroNode.no 对链表中对应编号节点的 name 和 nickname 进行修改
* @param heroNode 修改样例
*/
public void modify(HeroNode heroNode){
if(this.head.next == null){
System.out.println("当前链表为空,无法进行修改");
return;
}
HeroNode tmp = this.head.next;
boolean flag = false; // 是否找到 no 与 heroNode.no 一致的节点标志
// 1. 定位
while(tmp != null){
if(tmp.no == heroNode.no){
flag = true;
break;
}
tmp = tmp.next;
}
// 2. 修改
if(flag){
tmp.name = heroNode.name;
tmp.nickname = heroNode.nickname;
}else{
System.out.printf("未找到编号为%d的节点\n", heroNode.no);
}
}
5). 删除
/**
* 删除指定编号的节点
* 思路:
* 1. 定位,找到要删除节点的前一个节点,即 tmp 为待删除节点的前一个节点,tmp.no = no
* 2. 删除,令 tmp.next = tmp.next.next
* @param no
*/
public void delete(int no){
if(this.head.next == null){
System.out.println("当前链表为空,无法进行删除操作");
return;
}
HeroNode tmp = this.head;
// 是否找到目标删除节点的标志
boolean flag = false;
// 1. 定位
while(tmp.next != null){
if(tmp.next.no == no){
flag = true;
break;
}
tmp = tmp.next;
}
// 2. 删除
if(flag)
tmp.next = tmp.next.next;
else
System.out.println("要删除的节点不存在");
}
4. 习题:
1). 求链表的长度:
/**
* 统计链表的长度,不包括链表的头节点 head
* @param head 需要统计长度的链表的头节点
* @return 返回链表的长度
*/
public static int getLength(HeroNode head){
int length = 0;
HeroNode tmp = head.next;
while(tmp != null){
length++;
tmp = tmp.next;
}
return length;
}
2). 求倒数第 k 个节点:
法1:
/**
* 查找倒数第 index 个节点
* 思路:
* 1. 先求出链表的总长度 size
* 2. 遍历到第 index 个节点,从头开始遍历到第 size-index 个节点返回此节点
* @param head 查找节点所属链表的头节点
* @param index 节点的倒数编号
* @return 返回倒数第 index 个节点
*/
public static HeroNode findLastIndexNode(HeroNode head, int index){
// 链表为空
if(head.next == null){
return null;
}
int size = HeroLinkedList.getLength(head);
// 查找节点超出范围
if(index <= 0 || index > size){
return null;
}
HeroNode tmp = head.next;
for(int i = 0; i < size-index; i++){
tmp = tmp.next;
}
return tmp;
}
法2:
/**
* 查找倒数第 index 个节点,双指针法
* 思路:
* 定义两个指针 p 和 q ,初始位置均指向链表的第一个节点;
* 之后令 p 与 q 相差 index 个节点;
* p 与 q 同时后移,当 q 为空时,p 所指向的就为目标节点。
* @param head 查找的节点所属链表的头节点
* @param index 所要查找节点的倒数序号
* @return 返回所要查找的节点
*/
public static HeroNode findLastIndexNode2(HeroNode head, int index){
// 链表为空
if(head.next == null){
return null;
}
int size = HeroLinkedList.getLength(head);
// 查找节点超出范围
if(index <= 0 || index > size){
return null;
}
HeroNode p = head.next;
HeroNode q = p;
for(int i = 0; i<index; i++){
q = q.next;
}
while(q != null){
p = p.next;
q = q.next;
}
return p;
}
3). 反转链表:
/**
* 单链表反转
* @param head 要反转的链表的头节点
*/
public static void reverseList(HeroNode head){
// 如果当前链表为空或只有一个节点,无需反转
if(head.next == null || getLength(head) == 1){
return;
}
HeroNode newHead = new HeroNode(0, "", "");
HeroNode current = null;
while(head.next != null){
// 1. 将节点从原链表中取出
current = head.next;
head.next = current.next;
// 2. 将取出的节点插入到新的头节点之后
current.next = newHead.next;
newHead.next = current;
}
head.next = newHead.next;
}
4). 合并两个有序的链表
法1:
/**
* 合并链表:合并两个已经有序的链表,并保证合并后链表中的节点是有序的(从小到大)
* 思路:
* 两个链表同时从头开始遍历,每遍历一个节点都将两个链表中此时所遍历节点的序号进行比较,
* 选择其中较小序号的节点,并插入到合并链表中(只有当节点被插入,才会遍历下一个节点)
* @param head1 要合并的第一个链表的头节点
* @param head2 要合并的第二个链表的头节点
* @return 返回合并后新链表的头节点
*/
public static HeroNode merge(HeroNode head1, HeroNode head2){
HeroNode mergedHead = new HeroNode();
// 特殊情况:如果存在合并的链表为空的情况
if(head1.next == null || head2.next == null){
mergedHead = head1.next == null ? head2 : head1;
return mergedHead;
}
// 一般情况:
HeroNode tmp = mergedHead;
HeroNode tmp1 = head1.next;
HeroNode tmp2 = head2.next;
while(tmp1 != null || tmp2 != null){
if(tmp1 != null && tmp2 != null) {
if(tmp1.no <= tmp2.no){
tmp.next = tmp1;
tmp1 = tmp1.next; // 只有当节点被插入到合并后的链表中,才能接着往下遍历比较
} else{
tmp.next = tmp2;
tmp2 = tmp2.next;
}
} else{
if(tmp1 == null && tmp2 != null){
tmp.next = tmp2;
tmp2 = tmp2.next;
} else if(tmp2 == null && tmp1 != null){
tmp.next = tmp1;
tmp1 = tmp1.next;
}
}
tmp = tmp.next;
}
return mergedHead;
}
法2:
public static HeroNode merge(HeroNode head1, HeroNode head2){
// 特殊情况:如果存在合并的链表为空的情况
if(head1.next == null || head2.next == null)
return head1.next == null ? head2 : head1;
// 一般情况:
HeroNode mergedHead = new HeroNode();
HeroNode tmp = mergedHead;
HeroNode tmp1 = head1.next;
HeroNode tmp2 = head2.next;
while(tmp1 != null && tmp2 != null){
if(tmp1.no <= tmp2.no){
tmp.next = tmp1;
tmp1 = tmp1.next;
} else{
tmp.next = tmp2;
tmp2 = tmp2.next;
}
tmp = tmp.next;
}
// 当有一个链表为空时,直接将另一个链表的剩余部分接到合并链表的尾部即可
tmp.next = tmp1 == null ? tmp2 : tmp1;
return mergedHead;
}