数据结构笔记-双向链表增删改查

与单向链表对比

1. 单链表查找的方向只能是向后的一个方向；双向链表可以向前或者向后查找
2. 单链表不能自我删除，需要引入辅助变量(查找到待删除节点的前一个节点)；双向链表可以自我删除
3. 双向链表的节点内容除了next还有指向前一个节点的pre

遍历

遍历方式和单链表相同，但是可以向前或者向后

添加

到链表最后

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

按照no顺序

1. temp.pre.next = heroNode;
2. heroNode.pre = temp.pre;
3. heroNode.next = temp;
4. temp.pre = heroNode;

修改

同单向链表

删除

1. 直接找到需要删除的节点temp
2. temp.pre.next = temp.next
3. temp.next.pre = temp.pre，如果是最后一个节点，不需要执行这句话，否则会出现空指针异常

代码示例

//创建一个双向链表的类
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.next;
		}
	}
	//添加节点到双向链表结尾
	public void addHero(HeroNode2 heroNode) {
		//由于head节点不能动，所以需要一个辅助变量temp来遍历
		HeroNode2 temp = head;
		//遍历链表找到最后节点
		while(true) {
			if(temp.next == null) {
				break;
			}
			temp = temp.next; //没有找到最后就将temp后移
		}
		temp.next = heroNode; //当退出while循环时，temp保证指向了最后一个节点，此时将数据添加进来
		heroNode.pre = temp;
	}
//按顺序添加
	public void addByOrder(HeroNode2 heroNode) {
		HeroNode2 temp = head;
		boolean flag = false; //用于标识新添加的标号是否已经存在,默认为false
		while(true) {
			if(temp==null) {
				break;
			}
			if(temp.no > heroNode.no) {
				break;
			}else if(temp.no == heroNode.no){
				flag = true; //说明编号存在
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.println("准备插入的英雄编号"+temp.next.no+"已存在");
		}else {
			temp.pre.next = heroNode;
			heroNode.pre = temp.pre;
			heroNode.next = temp;
			temp.pre = heroNode;
		}
	}

	//修改，同单向链表
	public void update(HeroNode2 newHeroNode) {
		boolean flag = false;
		//根据新节点的编号no进行修改即可
		if(head.next == null) {
			System.out.println("链表为空");
		}
		//找到需要修改的节点
		HeroNode2 temp = head.next;
		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);
		}
	}
	//删除节点
	public void delete(int no) {
		if(head.next==null) {
			System.out.println("链表为空，无法删除");
		}
		HeroNode2 temp = head.next;
		boolean flag = false; //标志是否找到了待删除节点的前一个节点
		while(true) {
			if(temp ==null) {
				break;
			}
			if(temp.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		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; //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 + "]";
	}
}