在学习单向链表的时候，使用带head头的双向链表实现-水浒英雄排行榜管理单项向链表的缺点分析：
[1]单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
[2]单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面单链表删除节点时，总是找到temp，temp是代删除节点的前一个节点。
在这里插入图片描述
分析 双向链表的遍历，添加，修改，删除的操作思路==》代码实现
[1]遍历方式和单链表一样，只是可以向前，也可以向后
[2]添加（默认添加到双向链表的最后这个节点）
（1）先找到双向链表的最后这个节点
（2）temp.next=newHeroNode（使最后这个节点直接指向新的节点）
（3）newHeroNode.pre=temp（使新添加进来的节点的pre指向上一个节点）
[3]修改思路和原理和单向链表一样
[4]删除
（1）因为是双向链表，因此，可以自我删除某个节点，而不需要想单链表一样找到前一个节点才能删除
（2）直接找到要删除的节点，比如temp
（3）temp.pre.next=temp.next（要删除节点的上一个节点指向的下一个节点为要删除节点的下一个节点）
（4）temp.next.pre=temp.pre（要删除节点的下一个节点指向的上一个节点为要删除节点的上一个节点）

双向链表的代码实现

创建节点类HeroNode

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 创建一个节点类HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
	public int no;
	public String nickname;
	public String name;
	public HeroNode next;// 指向下一个节点
	public HeroNode pre;// 指向上一个节点
	// 构造器
	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 + ", nickname=" + nickname + ", name="
				+ name + ", next=" + next + ", pre=" + pre + "]";
	}
}

创建一个双向链表的类DoubleLinkedList

1
2
3
4
5
6
7
8
9
// 创建一个双向链表的类
class DoubleLinkedList {
	//先初始化一个头节点，头节点不要动，不存放具体的数据
	private HeroNode head = new HeroNode(0,"","");
	//放回头节点
	public HeroNode getHead(){
		return head;
	}
}

双向链表的遍历

双向链表的遍历，和单向链表一样。(在双向链表的类DoubleLinkedList中添加方法list()来显示双向链表)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//显示链表
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);
		//将next后移,不后移将会是一个死循环
		temp = temp.next;
	}
}

双向链表添加节点

思路：
（1）先找到双向链表的最后这个节点
（2）temp.next=newHeroNode（使最后这个节点直接指向新的节点）
（3）newHeroNode.pre=temp（使新添加进来的节点的pre指向上一个节点）
代码实现（在双向链表的类DoubleLinkedList中添加方法add()来向双向链表添加节点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void add(HeroNode heroNode){
	//应为head节点不能动，因此需要一个辅助变量 temp
	HeroNode temp = head;
	//遍历链表，找到最后
	while(true){
		//找到最后一个
		if(temp.next==null) break;
		//没有找到最后
		temp = temp.next;
	}
	//当退出while循环时，temp就指向了链表的最后
	//形成一个双向链表
	temp.next = heroNode;
	heroNode.pre = temp;
}

双向链表的修改

双向链表的节点内容修改，可单向链表的节点内容修改一样，在双向链表的类DoubleLinkedList中添加方法update()来修改双向链表节点内容

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//修改双向链表一个节点的内容
public void update(HeroNode newHeroNode){
	if(head.next==null){
		System.out.println("链表为空");return;
	}
	//找到需要修改的节点，根据no编号
	//定义一个辅助变量
	HeroNode temp = head.next;
	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的节点，不能修改",newHeroNode.no);
	}
}

双向链表的节点删除

思路：
（1）因为是双向链表，因此，可以自我删除某个节点，而不需要想单链表一样找到前一个节点才能删除
（2）直接找到要删除的节点，比如temp
（3）temp.pre.next=temp.next（要删除节点的上一个节点指向的下一个节点为要删除节点的下一个节点）
（4）temp.next.pre=temp.pre（要删除节点的下一个节点指向的上一个节点为要删除节点的上一个节点）
代码实现（在双向链表的类DoubleLinkedList中添加方法del()来表示删除双向链表中的某个节点）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//删除节点
//对于双向链表，可以直接找到要删除这个节点
public void del(int no){
	
	//判断当前链表是否为空
	if(head.next==null) {
		System.out.println("链表为空~！无法删除");return;
	}
	
	HeroNode temp = head.next;
	boolean flag = false; //标志是否找到待删除节点
	while(true){
		if(temp == null)break;//已经到链表最后
		if(temp.no == no){//找到了待删除节点的前一个节点
			flag = true;
			break;
		}
		//后移，遍历
		temp = temp.next;
	}
	if(flag){//可以删除
		temp.pre.next = temp.next;
		if(temp.next!=null)
		temp.next.pre = temp.pre;//如果是最后一个节点就不需要执行下面这句话，否则会出现空指针异常
	}else{
		System.out.printf("要删除的节点%d,不存在",no);
	}
}