Java数据结构之双向链表

使用双向链表实现 –水浒英雄排行榜

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

分析：

直接从链表尾部插入节点：

package linkedlist;

public class DoubleLinkedListDemo {
	
	public static void main(String[] args) {
		// 进行测试
		// 先创建节点
		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);
		
		System.out.println("原链表为：");
		doubleLinkedList.list();
		
		//修改
		HeroNode2 newHeroNode = new HeroNode2(4,"公孙胜","入云龙");
		doubleLinkedList.update(newHeroNode);
		System.out.println("修改后的链表为：");
		doubleLinkedList.list();
		
		//删除
		doubleLinkedList.delete(4);
		System.out.println("删除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);
			// 将temp后移
			temp = temp.next;
		}
	}

	public void add(HeroNode2 heroNode) {
		// 因为头结点不能动，所以我们需要一个辅助变量temp
		HeroNode2 temp = head;
		// 遍历链表，找到最后
		while (true) {
			// 找到链表的最后
			if (temp.next == null) {
				break;
			}
			// 如果没有到最后，则将temp后移
			temp = temp.next;
		}
		// 当退出while循环时，temp就指向了链表的最后
		// 形成一个双向链表
		temp.next = heroNode;
		heroNode.pre = temp;
	}

	// 修改一个节点的内容，和单向链表一样，只是节点类型改变
	public void update(HeroNode2 newHeroNode) {
		// 判断是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 根据no编号找到带修改的节点
		// 定义一个辅助变量
		HeroNode2 temp = head.next;
		while (true) {
			if (temp == null) {// 遍历完链表但仍没有找到对应编号的节点
				System.out.printf("没有找到编号为%d的节点，修改失败\n", newHeroNode.no);
				return;
			}
			if (temp.no == newHeroNode.no) {// 找到对应编号的节点，并进行修改
				temp.name = newHeroNode.name;
				temp.nickname = newHeroNode.nickname;
				System.out.println("修改成功");
				return;
			}
			temp = temp.next;
		}
	}

	// 从双向链表删除一个节点
	// 对于双向链表，我们可以直接找到待删除的节点，然后进行自我删除即可
	public void delete(int no) {
		// 判断当前链表是否为空
		if (head.next == null) {
			System.out.println("链表为空，删除失败");
			return;
		}
		HeroNode2 temp = head.next;
		while (true) {
			if (temp == null) {// 已经到链表的最后
				System.out.printf("待删除的节点%d不存在，删除失败\n", no);
				return;
			}
			if (temp.no == no) {// 找到了待删除节点的前一个节点temp
				temp.pre.next = temp.next;
				// 如果是最后一个节点，则不需要执行下面这句话，否则会出现空指针异常
				if (temp.next != null) {
					temp.next.pre = temp.pre;
				}
				System.out.println("删除成功");
				return;
			}
			temp = temp.next;
		}
	}

// 定义HeroNode2，每个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;
	}

	// 为了显示方便，我们重写toString方法
	@Override
	public String toString() {
		return "HeroNode2 [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
}

结果：

原链表为：
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode2 [no=3, name=吴用, nickname=智多星]
HeroNode2 [no=4, name=林冲, nickname=豹子头]
修改成功
修改后的链表为：
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode2 [no=3, name=吴用, nickname=智多星]
HeroNode2 [no=4, name=公孙胜, nickname=入云龙]
删除成功
删除4号后的链表为：
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode2 [no=3, name=吴用, nickname=智多星]

按编号顺序插入节点：

package linkedlist;

public class DoubleLinkedListDemo {
	
	public static void main(String[] args) {
		// 进行测试
		// 先创建节点
		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.addByOrder(hero4);
		doubleLinkedList.addByOrder(hero1);
		doubleLinkedList.addByOrder(hero2);
		doubleLinkedList.addByOrder(hero3);
		
		System.out.println("原链表为：");
		doubleLinkedList.list();
		
		//修改
		HeroNode2 newHeroNode = new HeroNode2(4,"公孙胜","入云龙");
		doubleLinkedList.update(newHeroNode);
		System.out.println("修改后的链表为：");
		doubleLinkedList.list();
		
		//删除
		doubleLinkedList.delete(4);
		System.out.println("删除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);
			// 将temp后移
			temp = temp.next;
		}
	}

	// 修改一个节点的内容，和单向链表一样，只是节点类型改变
	public void update(HeroNode2 newHeroNode) {
		// 判断是否为空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		// 根据no编号找到带修改的节点
		// 定义一个辅助变量
		HeroNode2 temp = head.next;
		while (true) {
			if (temp == null) {// 遍历完链表但仍没有找到对应编号的节点
				System.out.printf("没有找到编号为%d的节点，修改失败\n", newHeroNode.no);
				return;
			}
			if (temp.no == newHeroNode.no) {// 找到对应编号的节点，并进行修改
				temp.name = newHeroNode.name;
				temp.nickname = newHeroNode.nickname;
				System.out.println("修改成功");
				return;
			}
			temp = temp.next;
		}
	}

	// 从双向链表删除一个节点
	// 对于双向链表，我们可以直接找到待删除的节点，然后进行自我删除即可
	public void delete(int no) {
		// 判断当前链表是否为空
		if (head.next == null) {
			System.out.println("链表为空，删除失败");
			return;
		}
		HeroNode2 temp = head.next;
		while (true) {
			if (temp == null) {// 已经到链表的最后
				System.out.printf("待删除的节点%d不存在，删除失败\n", no);
				return;
			}
			if (temp.no == no) {// 找到了待删除节点的前一个节点temp
				temp.pre.next = temp.next;
				// 如果是最后一个节点，则不需要执行下面这句话，否则会出现空指针异常
				if (temp.next != null) {
					temp.next.pre = temp.pre;
				}
				System.out.println("删除成功");
				return;
			}
			temp = temp.next;
		}
	}
	
	//按编号顺序从小到大插入链表
	public void addByOrder(HeroNode2 heroNode) {
		HeroNode2 temp = head;
		while(true) {
			if(temp.next == null) {//此时temp已经指向了链表的最后
				break;
			}
			if(temp.next.no > heroNode.no) {//找到应插入的位置
				break;
			}else if(temp.next.no == heroNode.no){//判断编号是否已经存在
				System.out.printf("准备插入的英雄的排名%d已经存在，添加失败\n",heroNode.no);
				return;
			}
			temp=temp.next;
		}
		//将其插入到temp后面
		heroNode.next = temp.next;
		heroNode.pre = temp;
		if(temp.next != null) {//当插入的位置不是最后时
			temp.next.pre = heroNode;
		}
		temp.next = heroNode;
	}
}

// 定义HeroNode2，每个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;
	}

	// 为了显示方便，我们重写toString方法
	@Override
	public String toString() {
		return "HeroNode2 [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
	}
}

结果：

原链表为：
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode2 [no=3, name=吴用, nickname=智多星]
HeroNode2 [no=4, name=林冲, nickname=豹子头]
修改成功
修改后的链表为：
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode2 [no=3, name=吴用, nickname=智多星]
HeroNode2 [no=4, name=公孙胜, nickname=入云龙]
删除成功
删除4号后的链表为：
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode2 [no=3, name=吴用, nickname=智多星]