双向链表

双向链表优点：

1. 单向链表只能一个方向查找，双向链表可以左右两个方向查找
2. 单向链表不能自我删除，需要辅助节点，双向链表可以自我删除
   

class DoubleLinkedListDemo 
{
	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();

		//修改链表
		HeroNode2 newhero = new HeroNode2(4,"公孙胜","入云龙");
		doublelinkedlist.update(newhero);
		System.out.println("修改后的：");
		doublelinkedlist.list();

		//删除链表
		doublelinkedlist.del(3);
		System.out.println("删除后的：");
		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) {
		//因为head节点不能动，需要一个辅助变量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;
		boolean flag = false;            //表示是否找到该节点
		while (true)
		{
			if (temp == null)            
			{
				break;       //已经遍历完链表
			}
			if (temp.no == newheronode.no)
			{
				//找到
				flag =true;
				break;
			}
		}
		if (flag)
		{
			temp.name = newheronode.name;
			temp.nickname = temp.nickname;
		}else 
			System.out.println("没有找到该%d节点"+ newheronode.no);
	}

	//从双向链表删除节点
	//1.对于双向链表可以直接找到双向链表这个节点
	//2.找到后，直接删除就好
	public void del(int no) {
		if (head.next == null)
		{
			System.out.println("链表为空，无法删除");
			return;
		}

		HeroNode2 temp = head.next;    //辅助节点（直接找待删除节点而不是前一个）
		boolean flag  = false;        //标识是否找到待删除节点
		while (true)
		{
			if (temp.next == null)    //已经找到链表节点最后一个的next
			{
				break;              //遍历完成
			}
			if (temp.no == no)
			{
				flag = true;         //找到待删除节点的前一个节点
				break;
			}
			temp = temp.next;
		}
		if (flag)
		{
			//temp.next.next = temp.next;      //单向链表删除节点
			temp.pre.next = temp.next;
			
			if (temp.next != null)
			{
				//如果最后一个节点不需要执行下面这句话，否则会出现空指针异常
				temp.next.pre = temp.pre;
			}
			
		}else
			System.out.println("删除节点不存在");
	}

}


//定义HeroNode,每个HeroNode就是一个节点
class HeroNode2
{
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 next;         //定义变量next,类型为HeroNode,next目前值为null,指向下一个节点
	public HeroNode2 pre;          //指向前一个节点

	//构造方法
	public HeroNode2(int no,String name,String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

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

}