JAVA数据结构与算法——双向链表

单链表缺点分析

• 单链表查找的方向只能是一个方向的，双向链表可以向前或者向后查找。
• 单链表不能自我删除，需要依靠辅助节点，而双向链表可以自我删除。

双向链表示意图

图1-1 双向链表

双向链表操作思路

• 遍历：和单链表一样，只是可以向前也可以 向后查找。
• 添加：（默认添加到链表尾）

1. 先找到双向链表的最后这个节点
2. temp.next = newHeroNode
3. newHeroNode.pre = temp 

图1-2 双向链表的添加示意图

 

• 修改：和单项链表一样
• 删除：

1. 由于是双向链表，所以可以实现自我删除某个节点。
2. 直接找到要删除的节点，例如：删除节点5
3. temp.pre.next = temp.next
4. temp.next.pre = temp.pre

 双向链表代码实现

 

package com.jun._4_doublelinkedlist;

/**
 * 测试双向链表的遍历、修改、删除、添加
 * 
 * @author jun
 *
 */
public class DoubleLinkedListDome {

	public static void main(String[] args) {
		System.out.println("双向链表测试：");

		HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
		HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
		HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
		HeroNode2 hero4 = new HeroNode2(4, "林冲", "豹子头");
		// 创建双向链表对象
		DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
		doubleLinkedList.add(hero1);
		doubleLinkedList.add(hero2);
		doubleLinkedList.add(hero3);
		doubleLinkedList.add(hero4);
		doubleLinkedList.list();
		// 修改
		System.out.println("修改测试：");
		HeroNode2 hero5 = new HeroNode2(4, "公孙胜", "入云龙");
		doubleLinkedList.update(hero5);
		doubleLinkedList.list();
		// 删除
		System.out.println("删除测试：");
		doubleLinkedList.dele(4);
		doubleLinkedList.list();
	}

}

//创建双向链表的类
class DoubleLinkedList {
	// 初始化表头
	private HeroNode2 head = new HeroNode2(0, "", "");

	// 返回头结点
	public HeroNode2 getHead() {
		return head;
	}

	// 遍历双向链表的方法
	public void list() {
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		HeroNode2 temp = head.next;
		while (true) {
			// 判断
			if (temp == null) {
				break;
			}
			// 不为空，输出节点信息
			System.out.println(temp);
			// 将next后移
			temp = temp.next;
		}
	}

	// 添加
	public void add(HeroNode2 heroNode) {
		// 辅助指针
		HeroNode2 temp = head;
		// 循环遍历
		while (true) {
			// 寻找链表的最后
			if (temp.next == null) {
				break;
			}
			// 未找到,temp后移
			temp = temp.next;
		}
		temp.next = heroNode;
		heroNode.pre = temp;
	}

	// 修改
	public void update(HeroNode2 newHeroNode) {
		// 判空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 找到需要的节点(辅助变量)
		HeroNode2 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的节点，不能修改\n", newHeroNode.no);
		}
	}

	// 删除
	// 1、对于双向链表可以直接找到要删除的节点
	// 2、找到后自我删除就可以
	public void dele(int no) {
		// 判空
		if (head.next == null) {
			System.out.println("链表为空，不能删除");
			return;
		}
		HeroNode2 temp = head.next;// 辅助变量
		boolean flag = false;// 标识是否找到待删除节点的前一个节点
		while (true) {
			if (temp == null) {// 链表最后节点的next
				break;
			}

			if (temp.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;// 后移

		}
		// 判断flag
		if (flag) {// 找到
			// 双向链表删除操作
			temp.pre.next = temp.next;
			if (temp.next != null) {
				temp.next.pre = temp.pre;
			}

		} else {
			System.out.printf("要找的节点%d， 不存在\n", no);
		}
	}

}

//定义节点
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;
	}

	// 重写toString
	@Override
	public String toString() {
		return "HeroNode [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}

}

 输出

 

双向链表测试：
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]
修改测试：
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=公孙胜, nickname=入云龙]
删除测试：
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]

 注意空指针异常

            temp.pre.next = temp.next;
            temp.next.pre = temp.pre;

如果删除的是最后一个节点，第二行代码将会出现空指针异常，所以在执行第二行代码之前要进行判断。