图解Java数据结构之双向链表

上一篇文章说到了单链表，也通过案例具体实现了一下，但是单链表的缺点也显而易见。

1. 单向链表查找的方向只能是一个方向
2. 单向链表不能自我删除，需要靠辅助节点

而双向链表则能够很轻松地实现上面的功能。

何为双向链表

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

增删改查思路分析

对于单链表，我们已经有所了解，并且掌握了增删改查，而双向链表与单链表唯一不同之处就在于多了一个指向前一个节点的指针。虽然只有这点不同，但是双向链表在增删改查的实现上还是与单链表有很多不一样之处。

1、插入节点

1. 先找到双向链表的最后一个节点(通过一个辅助节点temp)
2. 使temp.next指向要插入的节点
3. 使要插入节点的前驱指针(pre)指向temp(比单链表多出这一步)

2、删除节点

1. 直接找到要删除的节点temp(因为是双向链表，因此可以实现自我删除某个节点)
2. 使temp.pre.next = temp.next(解释一下：temp.pre指向的是前一个节点，然后将temp.pre.next也就是temp的前一个节点的下一个节点指向temp的下一个节点。这句话可能有点绕，通俗点说，就是本来被删除节点的前一个节点的next指向的是被删除节点，但此时让它指向被删除节点的下一个节点，这样就跳过了被删除节点)
3. 当然因为是双向链表，前驱指针pre也需要修改，使temp.next.pre = temp.pre，道理是一样的，就是让被删除节点的下一个节点的pre指向被删除节点的前一个节点，这样也就跳过了被删除节点

关于修改和遍历的实现原理和单链表相同，不作重复介绍。

增删改查代码实现

思路分析过后，就是代码实现。

首先创建出节点类Hero：

//定义HeroNode，每个HeroNode对象就是一个节点
class Hero {
	public int no;
	public String name;
	public String nickname;
	public Hero next;// 指向下一个节点
	public Hero pre;// 指向前一个节点

	// 构造器
	public Hero(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 Hero head = new Hero(0, "", "");

	// 添加节点到双向链表
	public void add(Hero hero) {
		// 当不考虑编号的顺序时:
		// 1、找到当前链表的最后节点
		// 2、将最后这个节点的next域指向新的节点即可

		// 因为head头节点不能动，因此我们需要一个辅助节点temp
		Hero temp = head;
		// 遍历链表，找到尾节点
		while (true) {
			// 找到链表的尾节点
			if (temp.next == null) {
				break;
			}
			// 如果不是尾节点，将temp后移
			temp = temp.next;
		}

		// 循环结束后，temp指向的是尾节点
		// 形成一个双向链表
		temp.next = hero;
		hero.pre = temp;
	}

	// 修改节点的信息，根据no编号来修改
	public void update(Hero newHero) {
		// 根据newHeroNode的编号进行修改
		// 判断链表是否为空
		if (head == null) {
			System.out.println("链表为空");
			return;
		}
		// 找到需要修改的节点
		// 定义辅助节点
		Hero temp = head.next;
		boolean flag = false;// 表示是否找到该节点
		while (true) {
			if (temp == null) {
				break;// 链表遍历结束
			}
			if (temp.no == newHero.no) {
				// 找到需要修改的节点
				flag = true;
				break;
			}
			temp = temp.next;// 将temp后移
		}
		// 根据flag判断是否已经找到要修改的节点
		if (flag) {
			temp.name = newHero.name;
			temp.nickname = newHero.nickname;
		} else {
			// 没有找到节点
			System.out.println("没有找到");
		}
	}

	// 从双向链表中删除一个节点
	// 对于双向链表可以直接找到要删除的节点，自我删除即可
	public void delete(int no) {

		// 判断当前链表是否为空
		if (head.next == null) {
			System.out.println("链表为空，无法删除");
			return;
		}

		// 定义辅助节点
		Hero temp = head.next;
		boolean flag = false;// 是否找到待删除节点的前一个节点
		while (true) {
			if (temp == null) {
				// 遍历结束
				break;
			}
			if (temp.no == no) {
				// 找到
				flag = true;
				break;
			}
			temp = temp.next;// 将temp后移
		}
		// 判断flag
		if (flag) {
			// 找到
			// 可以删除
			temp.pre.next = temp.next;
			// 如果要删除的节点是最后一个节点，则不需要执行该条代码
			if (temp.next != null) {
				temp.next.pre = temp.pre;
			}
		} else {
			// 未找到
			System.out.println("要删除的节点不存在");
		}
	}

	// 遍历双向链表
	public void list() {
		// 判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 创建一个辅助节点
		Hero temp = head.next;
		while (true) {
			// 判断是否到了链表末尾
			if (temp == null) {
				break;
			}
			// 输出节点信息
			System.out.println(temp);
			// 将temp后移
			temp = temp.next;
		}
	}
}

那么接下来测试一下：

public static void main(String[] args) {
		// 创建节点
		Hero hero1 = new Hero(1, "宋江", " 及时雨");
		Hero hero2 = new Hero(2, "卢俊义", "玉麒麟");
		Hero hero3 = new Hero(3, "吴用", "智多星");
		Hero hero4 = new Hero(4, "林冲", "豹子头");

		//创建一个双向链表
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

		//添加节点
		doubleLinkedList.add(hero1);
		doubleLinkedList.add(hero2);
		doubleLinkedList.add(hero3);
		doubleLinkedList.add(hero4);

		//修改
		Hero newHero = new Hero(4, "公孙胜", "入云龙");
		doubleLinkedList.update(newHero);

		//删除
		doubleLinkedList.delete(1);

		//遍历
		doubleLinkedList.list();
	}

运行结果：

HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=公孙胜, nickname=入云龙]

其实如果你掌握了单链表，关于双向链表的操作将非常简单，两者只是有一些细微的差别，并无大的变化。