本文旨在加深学习印象并留记录以供日后查看。学习视频为韩顺平图解Java数据结构和算法，以下内容来自于视频内容与自我总结。如有错误请您指正。
双向链表
百科：双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。
前文分析了单链表的实现与问题，本文来学习双向链表顺便解决单链表的问题。
思路分析
继续使用单链表的例子，新建立一个HeroNode2的class来存放hero的数据信息，每个HeroNode都是一个节点。我们使用HeroNode2来分析与实现对双向链表的增删改查操作。
创建节点
与单链表不同的是，我们需要定义一个HeroNode2 pre来指向上个节点
//每个HeroNode2都是一个节点
class HeroNode2 {
public int no;
public String name;
public String nickName;
public HeroNode2 next;//指向下个节点
public HeroNode2 pre;//指向上个节点
//构造器，初始化数据
public HeroNode2(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 + '\'' +
'}';
}
}
创建双向链表
class DoubleLinkedList {
//初始化头结点，不存放具体数据
private HeroNode2 head = new HeroNode2(0,"","");
...
}
添加节点
- 将新节点添加到链表尾部（无序）
当有一个新的节点（newNode）需要添加到链表中时，需要找到最后一个节点（endNode），让endNode的next指向newNode，把newNode的pre指向endNode
代码实现：
/**
* 向链表中添加节点（不考虑编号顺序）
* 思路：1、找到链表的最后节点；2、把最后节点的next指向新节点；3、把新节点的pre指向原来的最后节点
* 注：此添加方法是无序的，将新的节点添加到后面
* @param newNode
*/
public void add(HeroNode2 newNode){
//1、找到链表最后节点 遍历
HeroNode2 temp = this.head;//定义一个temp指向头结点
//遍历
while (temp.next != null){//如果temp的next为null,则temp为最后一个节点，然后跳出循环
//如果temp的next不为null，把temp指向他的下一个节点并继续遍历
temp = temp.next;
}
//遍历到最后一个节点时，把temp的next指向新的节点，把新节点的pre指向原来的最后节点
temp.next = newNode;
newNode.pre = temp;
}
-
将新节点按顺序添加到链表中（有序）
此处根据编号来添加节点
如图所示，当有编号为3的节点（node3）要添加进列表时，需要找到节点编号比3大的节点（node5）的前一个节点（node2），让node5的pre指向node3，node3的pre指向node2，node2的next指向node3，node3的next指向node5，即可完成添加。
需要注意：
①要判断当node3存在时，不需要添加
②当要添加的节点是最后一个节点时，注意会出现NullPointerException问题
代码实现：
/**
* 向链表中添加节点，有序
* 根据编号的顺序添加，如果要添加的节点已有则添加失败并提示
* @param newNode
*/
public void addByOrder(HeroNode2 newNode){
//定义一个temp指向头结点
HeroNode2 temp = this.head;
//定义一个标识来判断newNode是否已存在
boolean flag = false;
while (temp.next != null){
//当前节点的下个节点的no>新节点的no，表示找到位置，新节点应该插入到这里
if (temp.next.no > newNode.no){
break;
} else if (temp.next.no == newNode.no){
//当下一个节点的no和新的节点的no相等时，认为已存在
flag = true;
}
temp = temp.next;
}
if (flag){
System.out.println(newNode.no+"已存在");
return;
}
//将结点插入
//让newNode的下一个节点等于原本temp的下一个节点,让原本temp的下一个节点等于newNode
//让newNode的前一个节点等于temp，让temp下一个节点的前一个节点等于newNode
newNode.next = temp.next;
temp.next = newNode;
//此时的temp的next节点已经是newNode，所以原本的temp的next节点应该是temp.next.next
if (temp.next.next != null){
temp.next.next.pre = newNode;
}
newNode.pre = temp;
}
修改节点
修改节点思路与单链表一样，找到后修改即可，找不到提示
①首先通过遍历找到要修改的节点，找不到则要修改的节点不存在
②temp.name = newNode.name;
③temp.nickName = newNode.nickName;
代码实现：
/**
* 修改节点 跟单链表一样
* 根据传入节点的no来对链表中现有的节点信息进行修改
* no作为标识不能修改，如果no修改了应视为添加
* @param newNode
*/
public void update(HeroNode2 newNode){
//如果链表为空，不需要修改，直接返回结束
if (head.next == null){
System.out.println("链表为空");
return;
}
//根据no寻找该节点
HeroNode2 temp = this.head;
boolean flag = false;//设置一个标识标识是否找到
while (temp != null){
//相等时说明找到了要修改的节点
if (temp.no == newNode.no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
temp.name = newNode.name;
temp.nickName = newNode.nickName;
} else {
System.out.println("未找到no为"+newNode.no+"的节点");
}
}
删除节点
双向链表可以实现自我删除某个节点，只需要直接找到要删除的这个节点，例如node5，让后让node5.pre.next = node5.next，node5.next.pre = node5.pre即可。
代码实现：
/**
* 删除节点
* @param no
*/
public void delete(int no){
if (this.head.next == null){
System.out.println("链表为空，无法删除");
return;
}
HeroNode2 temp = this.head.next;
boolean flag = false;//是否找到
while (temp != null){
//找到要删除的节点
if (temp.no == no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
//找到要删除的节点 1、将上个节点的next指向下个节点;2、将下个节点的pre指向前一个节点
temp.pre.next = temp.next;
//当temp不是最后一个节点时，才能将下个节点的pre指向前一个节点，否则temp.next是null，null.pre会抛NPE
if(temp.next != null){
temp.next.pre = temp.pre;
}
} else {
System.out.println("要删除的节点不存在");
}
}
完整代码及测试结果
完整代码：
package com.hyf.linkedlist;
public class DoubleLinkedListDemo {
public static void main(String[] args) {
//测试
//创建节点
HeroNode2 node1 = new HeroNode2(1, "a", "aaa");
HeroNode2 node2 = new HeroNode2(2, "b", "bbb");
HeroNode2 node3 = new HeroNode2(3, "c", "ccc");
HeroNode2 node4 = new HeroNode2(4, "d", "ddd");
HeroNode2 node5 = new HeroNode2(5, "e", "eee");
DoubleLinkedList linkedList = new DoubleLinkedList();
// //添加节点 无序，添加到链表尾部
// linkedList.add(node3);
// linkedList.add(node1);
// linkedList.add(node5);
// linkedList.add(node2);
// linkedList.add(node4);
// //打印列表
// linkedList.list();
// System.out.println("----------------------");
//添加节点 有序
linkedList.addByOrder(node3);
// linkedList.addByOrder(node1);
linkedList.addByOrder(node4);
linkedList.addByOrder(node2);
linkedList.addByOrder(node1);
linkedList.addByOrder(node5);
linkedList.list();
System.out.println("----------------------");
//修改
HeroNode2 node22 = new HeroNode2(2, "b2", "bbb2");
linkedList.update(node22);
linkedList.list();
System.out.println("----------------------");
//删除
linkedList.delete(1);
linkedList.delete(4);
linkedList.delete(5);
linkedList.list();
System.out.println("----------------------");
}
}
class DoubleLinkedList {
//初始化头结点，不存放具体数据
private HeroNode2 head = new HeroNode2(0,"","");
//返回头结点
public HeroNode2 getHead(){
return this.head;
}
/**
* 向链表中添加节点（不考虑编号顺序）
* 思路：1、找到链表的最后节点；2、把最后节点的next指向新节点；3、把新节点的pre指向原来的最后节点
* 注：此添加方法是无序的，将新的节点添加到后面
* @param newNode
*/
public void add(HeroNode2 newNode){
//1、找到链表最后节点 遍历
HeroNode2 temp = this.head;//定义一个temp指向头结点
//遍历
while (temp.next != null){//如果temp的next为null,则temp为最后一个节点，然后跳出循环
//如果temp的next不为null，把temp指向他的下一个节点并继续遍历
temp = temp.next;
}
//遍历到最后一个节点时，把temp的next指向新的节点，把新节点的pre指向原来的最后节点
temp.next = newNode;
newNode.pre = temp;
}
/**
* 向链表中添加节点，有序
* 根据编号的顺序添加，如果要添加的节点已有则添加失败并提示
* @param newNode
*/
public void addByOrder(HeroNode2 newNode){
//定义一个temp指向头结点
HeroNode2 temp = this.head;
//定义一个标识来判断newNode是否已存在
boolean flag = false;
while (temp.next != null){
//当前节点的下个节点的no>新节点的no，表示找到位置，新节点应该插入到这里
if (temp.next.no > newNode.no){
break;
} else if (temp.next.no == newNode.no){
//当下一个节点的no和新的节点的no相等时，认为已存在
flag = true;
}
temp = temp.next;
}
if (flag){
System.out.println(newNode.no+"已存在");
return;
}
//将结点插入
//让newNode的下一个节点等于原本temp的下一个节点,让原本temp的下一个节点等于newNode
//让newNode的前一个节点等于temp，让temp下一个节点的前一个节点等于newNode
newNode.next = temp.next;
temp.next = newNode;
//此时的temp的next节点已经是newNode，所以原本的temp的next节点应该是temp.next.next
if (temp.next.next != null){
temp.next.next.pre = newNode;
}
newNode.pre = temp;
}
/**
* 修改节点 跟单链表一样
* 根据传入节点的no来对链表中现有的节点信息进行修改
* no作为标识不能修改，如果no修改了应视为添加
* @param newNode
*/
public void update(HeroNode2 newNode){
//如果链表为空，不需要修改，直接返回结束
if (head.next == null){
System.out.println("链表为空");
return;
}
//根据no寻找该节点
HeroNode2 temp = this.head;
boolean flag = false;//设置一个标识标识是否找到
while (temp != null){
//相等时说明找到了要修改的节点
if (temp.no == newNode.no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
temp.name = newNode.name;
temp.nickName = newNode.nickName;
} else {
System.out.println("未找到no为"+newNode.no+"的节点");
}
}
/**
* 删除节点
* @param no
*/
public void delete(int no){
if (this.head.next == null){
System.out.println("链表为空，无法删除");
return;
}
HeroNode2 temp = this.head.next;
boolean flag = false;//是否找到
while (temp != null){
//找到要删除的节点
if (temp.no == no){
flag = true;
break;
}
//后移
temp = temp.next;
}
if (flag){
//找到要删除的节点 1、将上个节点的next指向下个节点;2、将下个节点的pre指向前一个节点
temp.pre.next = temp.next;
//当temp不是最后一个节点时，才能将下个节点的pre指向前一个节点，否则temp.next是null，null.pre会抛NPE
if(temp.next != null){
temp.next.pre = temp.pre;
}
} else {
System.out.println("要删除的节点不存在");
}
}
/**
* 遍历显示链表
*/
public void list(){
//当head的next为null时，代表链表为空
if (this.head.next == null){
System.out.println("链表为空");
return;
}
//不为空时，遍历显示
HeroNode2 temp = this.head.next;
while (true){
if (temp == null){
break;
}
System.out.println(temp.toString());
//temp指向后移
temp = temp.next;
}
}
}
//每个HeroNode都是一个节点
class HeroNode2 {
public int no;
public String name;
public String nickName;
public HeroNode2 next;//指向下个节点
public HeroNode2 pre;//指向上个节点
//构造器，初始化数据
public HeroNode2(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 + '\'' +
'}';
}
}
测试结果：
扫一扫
1419
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
