Java数据结构与算法———(17)双向链表应用实例,修改节点信息

根据输入节点的no值,修改双向链表中对应节点的信息。

一、代码
package linkedlist;
/**
 * 此双链表的头节点不是首节点
 * @author Lee
 *
 */
//一、  测试类
public class DoubleLinkedListDemo {

	public static void main(String[] args) {
		
		//1.  创建节点(英雄)
		HeroNode2 hero1 = new HeroNode2(1, "宋江", "及时雨");
		HeroNode2 hero2 = new HeroNode2(2, "卢俊义", "玉麒麟");
		HeroNode2 hero3 = new HeroNode2(3, "吴用", "智多星");
		HeroNode2 hero4 = new HeroNode2(4, "公孙胜", "入云龙");
		HeroNode2 hero5 = new HeroNode2(5, "关胜", "大刀");
		HeroNode2 hero6 = new HeroNode2(6, "林冲", "豹子头");
		
		//2.  创建双链表
		DoubleLinkedList doublelinkedlist1 = new DoubleLinkedList();
		
		//3.  添加节点到双链表末尾并输出,输出顺序等于添加节点顺序
		/*doublelinkedlist1.addByAdd(hero1);
		doublelinkedlist1.addByAdd(hero3);
		doublelinkedlist1.addByAdd(hero5);
		doublelinkedlist1.addByAdd(hero2);
		doublelinkedlist1.addByAdd(hero4);
		doublelinkedlist1.addByAdd(hero6);
		doublelinkedlist1.list();
		*/
		
		//4.  添加节点到双向链表(根据no的值),输出顺序等于no的顺序(可以理解为插入节点)
		/*doublelinkedlist1.addByOrder(hero1);
		doublelinkedlist1.addByOrder(hero6);
		doublelinkedlist1.addByOrder(hero5);
		doublelinkedlist1.addByOrder(hero2);
		doublelinkedlist1.addByOrder(hero3);
		doublelinkedlist1.addByOrder(hero4);
		System.out.println("按编号顺序输出... ... ...");
		doublelinkedlist1.list();
		*/
		
		//5.修改节点信息
		doublelinkedlist1.addByAdd(hero1);
		doublelinkedlist1.addByAdd(hero2);
		System.out.println("修改节点信息之前... ... ...");
		doublelinkedlist1.list();
		System.out.println("----------双向链表中存在待修改的节点----------");
		HeroNode2 newHeroNode1 = new HeroNode2(2, "吴用", "智多星");
		doublelinkedlist1.update(newHeroNode1);
		System.out.println("修改节点信息之后... ... ...");
		doublelinkedlist1.list();
		System.out.println("----------双向链表中不存在待修改的节点----------");
		HeroNode2 newHeroNode2 = new HeroNode2(3, "宋江", "及时雨");
		doublelinkedlist1.update(newHeroNode2);
		System.out.println("修改节点信息之后");
		doublelinkedlist1.list();
	}

}

//二、 双链表类
class DoubleLinkedList{
	//  初始化一个头节点,不存放具体数据,头节点不能动
	private HeroNode2 head = new HeroNode2(0, "", "");
	
	//1.  获得头节点
	public HeroNode2 getHead() {
		return head;
	}
	
	//2.  添加节点到双链表的最后,输出顺序等于添加顺序
	//思路:直接将新节点添加到双链表的最后
	//(1)  用 while 遍历链表,找到双链表的最后一个节点。当退出 while 时,辅助节点 temp 已指向双链表的最后一个节点(只要内存还有空间,理论上链表就不会满)
	//(2)  直接将新节点接到双链表最后一个节点之后
	public void addByAdd(HeroNode2 heronode) {
		//(1)  遍历链表,找到双链表的最后一个节点
		HeroNode2 temp = head;
		while(true) {//对于不知道循环次数的情况,要用  while 循环
			if(temp.next == null) {
				break;
			}
			temp = temp.next;//temp 后移,继续遍历双链表
		}
		//(2)  当退出 while循环时,temp就指向了双链表的最后一个节点
		temp.next = heronode;
		heronode.pre = temp;//这里一定要注意,不能丢掉,否则就不是双链表
	}
	
	//3.  添加节点到双链表,根据 no 的值添加,输出顺序等于编号顺序(可以理解为插入节点)
	public void addByOrder(HeroNode2 heronode) {
		//(1)  遍历链表,找到待加入点的前一个节点
		HeroNode2 temp = head;//temp指向待添加节点的前一个位置,所以temp的值为head,而不是head.next
		boolean flag = false;//表示双链表中是否已存在待加入的节点,默认 false ,不存在
		while(true) {
			//<1>  temp已经指向双链表最后一个节点,退出循环
			if(temp.next == null) {
				break;
			}
			//<2>  temp没有指向双链表最后一个节点,让temp指向待加入节点的前一个节点
			if(temp.next.no > heronode.no) {
				break;
			}else if(temp.next.no == heronode.no) {
				flag = true;
				break;
			}
			//<3>  上面的情况都没有出现,temp后移,继续遍历
			temp = temp.next;
		}
		//(2)  判断flag的值,检查待添加的节点是否存在
		if(flag) {//待添加的节点已存在
			System.out.println("待添加的节点已存在... ... ...");
		}else if(temp.next != null){//待添加的节点不存在,且temp不是指向双链表的最后一个节点
			HeroNode2 temp1 = temp.next;
			heronode.pre = temp;
			heronode.next = temp1;
			temp1.pre = heronode;
			temp.next = heronode;
		}else {//待添加的节点不存在,且temp指向双链表的最后一个节点
			heronode.pre = temp;
			heronode.next = null;
			temp.next = heronode;
		}
	}
	
	//4.  显示/输出链表(遍历),按no的大小顺序输出
	public void list() {
		//(1)  首先判断双链表是否为空
		if(head.next == null) {
			System.out.println("双链表为空... ... ...");
			return;//结束方法,不能丢掉
		}
		//(2)  双链表非空,继续输出
		HeroNode2 temp = head.next;
		while(true) {
			//<1>  首先判断temp是否指向双链表最后一个节点的后一个节点
			if(temp == null) {
				break;
			}
			//<2>  temp没有指向双链表最后一个节点的后一个节点,继续遍历输出
			System.out.println(temp);
			temp = temp.next;
		}
	}
	
	//5.  修改节点信息,根据 no 的值(和单向链表相同)
	public void update(HeroNode2 heronode) {
		//(1)  首先判断双链表是否为空
		if(head.next == null) {
			System.out.println("双链表为空... ... ...");
			return;//结束方法,不能丢掉
		}
		//(2)  双链表非空,继续遍历双链表,找到待修改的节点
		HeroNode2 temp = head.next;
		boolean flag = false;//表示是否找到待修改的节点,默认为 false ,没找到
		while(true) {
			//<1>  首先判断是否到达双链表最后
			if(temp == null) {//已经遍历完链表。如果此处用temp.next == null,则无法修改最后一个节点
				break;
			}
			//<2>  没有到达双链表最后,继续遍历,直到找到待修改节点。找到后,退出  while 循环
			if(temp.no == heronode.no) {
				flag = true;
				break;
			}
			//<3> 没有找到待修改的节点,继续遍历双链表
			temp = temp.next;
		}
		//(3)  判断 flag 的值,决定是否能成功修改节点信息
		if(flag) {
			temp.name = heronode.name;
			temp.nickname = heronode.nickname;
		}else {
			System.out.println("待修改的节点不存在... ... ...");
		}
	}
	
	//6.  删除一个节点,根据 no 的值(双链表可以自我删除)
	//思路:双链表可以自我删除,所以只需要找到待删除的节点即可
	public void del(int no) {
		//(1)  首先判断双链表是否为空
		if(head.next == null) {
			System.out.println("双链表为空... ... ...");
			return;//结束方法
		}
		//(2)  双链表不为空,遍历双链表,直到找到待删除的节点
		HeroNode2 temp = head.next;//辅助节点
		boolean flag = false;//表示是否找到待删除的节点,默认为 false ,没找到
		while(true) {
			//<1>  首先判断 temp 是否指向双链表的最后一个节点
			if(temp == null) {//由于双向链表的节点可以自我删除,所以此处不能用temp.next == null。如果用temp.next == null,会导致最后一个节点无法删除。
				break;
			}
			//<2>  temp没有指向双链表的最后一个节点,继续遍历双链表,直到找到待删除的节点
			if(temp.no == no) {
				flag = true;
				break;
			}
			//<3>   temp没有指向双链表的最后一个节点,且没有找到待删除的节点,继续遍历双链表
			temp = temp.next;
		}
		//(3)  判断 flag 的值,决定是否删除节点
		if(flag) {//找到了待删除的节点
			temp.pre.next = temp.next;//将待删除节点的前一个节点的后驱改成待删除节点的后一个节点
			if(temp.next != null) {
				//注意:如果待删除节点是双向链表的最后一个节点,即temp.next == null,不需要执行下面的语句,否则会出现空指针
				temp.next.pre = temp.pre;//将待删除节点的后一个节点的前驱改成待删除节点的前一个节点
			}
		}else {
			System.out.println("没有找到待删除的节点... ... ...");
		}
	}
	
}

//三、  双链表节点类
class HeroNode2{
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 pre;//指向前一个节点,默认为 null
	public HeroNode2 next;//指向后一个节点,默认为 null
	
	//  构造方法
	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=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=吴用, nickname=智多星]
----------双向链表中不存在待修改的节点----------
待修改的节点不存在... ... ...
修改节点信息之后
HeroNode2 [no=1, name=宋江, nickname=及时雨]
HeroNode2 [no=2, name=吴用, nickname=智多星]

你可能感兴趣的:(Java数据结构与算法)