双向链表--------------增删改查

一、双向链表的查询

思路：所谓查询操作其实就是实现双向链表的遍历

• 1）遍历方式和单链表一样，只是可以向前也可以向后查找 

    public void list() {
    		//判断链表是否为空
		if(head.next==null) {
			System.out.println("链表为空");
			return;
		}
		
		//因为头结点不能动，因此我们需要一个辅助变量来遍历
		//由于头结点不存储信息，因此，我们要打印的第一个节点是head.next的数据
		//所以temp=head.next
		HeroNode2 temp=head.next;
		
		//temp!=null判断是否到最后
		while(temp!=null) {
			//输出节点信息
			System.out.println(temp);
			//将temp后移
			temp=temp.next;
		}
	}
	

二、双向链表的添加

1、在原来链表的最后添加新节点

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

    public void add(HeroNode2 heroNode) {
		//需要一个辅助变量，因为head节点不能动
		HeroNode2 temp=head;
		//遍历链表，找到最后
		//当节点的next域==null时，找到了链表的最后
		while(temp.next!=null) {
			//如果没有找到最后,将temp后移
			temp=temp.next;
		}
		//当退出while循环时，temp指向了链表最后
		temp.next=heroNode;
		heroNode.pre=temp;
	}
	

2、在两个节点之间添加新的节点

• 1）遍历链表找到要添加节点的前一个节点
• 2）判断是否要在最后一个节点的位置添加新节点？
• 3）若在最后一个节点添加新节点，则

            temp.next=heroNode;

            heroNode.pre=temp;

• 4）不在最后位置添加新节点，则

            temp.next=heroNode;

            heroNode.pre=temp;

            temp.next=heroNode;

            heroNode.pre=temp;

    public void addByOrder(HeroNode2 heroNode) {
		HeroNode2 temp=head;
		boolean flag=false;//标识添加的编号是否存在
		//temp.next==null 说明temp已经在链表的最后
		while(temp.next!=null) {
			if(temp.next.no>heroNode.no) {
				//位置找到，就在temp的后面插入
				break;
			}
			if(temp.next.no==heroNode.no) {
				//说明待添加的编号已存在，不能再添加
				flag=true;
				break;
			}
			temp=temp.next;//后移，遍历链表
		}
		//判断flag的值
		if(flag) {
			//不能添加，说明编号存在
			System.out.printf("准备插入的英雄的编号%d已存在,不能加入\n",heroNode.no);
		}
		else {
			//插入到链表中，temp的后面
			if(temp.next!=null) {
				//不在最后节点位置添加新节点
				heroNode.next=temp.next;
				temp.next.pre=heroNode;
			}
			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(temp!=null) {
			if(temp.no==newHeroNode.no) {
				//找到了
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			temp.name=newHeroNode.name;
			temp.nickname=newHeroNode.nickname;
		}
		else {
			//未找到
			System.out.printf("没有找到编号%d的节点，不能修改\n",newHeroNode.no);
		}
	}
	

四、双向链表的删除

• 1）因为是双向链表，因此，我们可以实现自我删除某个节点
• 2）直接找到要删除的这个节点，比如temp
• 3）temp.pre.next=temp.next;

             temp.next.pre=temp.pre;

 

    public void del(int no) {
		//判断当前链表是否为空
		if(head.next==null) {
			System.out.println("链表为空，无法删除");
			return;
		}
		
		//辅助节点temp
		HeroNode2 temp=head.next;//想找的是待删除节点，所以直接指向第一个节点
		boolean flag=false;//是否找到
		while(temp!=null) {
			if(temp.no==no) {
				//找到待删除节点的前一个节点
				flag=true;
				break;
			}
			temp=temp.next;//temp后移，实现遍历
		}
		if(flag) {
			//可以删除
			temp.pre.next=temp.next;
			
			if(temp.next!=null) {
				//删除节点非最后一个节点
				//若删除节点是最后一个节点则不需要修改temp.next.pre
				temp.next.pre=temp.pre;
			}
		}
		else {
			System.out.printf("要删除节点 %d不存在\n",no);
		}
	}
	

五、最后来个整体代码测试

    package com.atguigu.linkedlist;

    public 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 newHeroNode=new HeroNode2(4, "公孙胜", "入云龙");
		doubleLinkedList.update(newHeroNode);
		//修改后的链表情况
		System.out.println("修改后的链表情况:");
		doubleLinkedList.list();
		
		//删除
		doubleLinkedList.del(3);
		System.out.println("删除后链表情况:");
		doubleLinkedList.list();
		
		//添加节点到两节点之间
		HeroNode2 heroNode=new HeroNode2(3, "吴用", "智多星");
		System.out.println("按顺序添加后的接待情况:");
		doubleLinkedList.addByOrder(heroNode);
		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;
		}
		
		//因为头结点不能动，因此我们需要一个辅助变量来遍历
		//由于头结点不存储信息，因此，我们要打印的第一个节点是head.next的数据
		//所以temp=head.next
		HeroNode2 temp=head.next;
		
		//temp!=null判断是否到最后
		while(temp!=null) {
			//输出节点信息
			System.out.println(temp);
			//将temp后移
			temp=temp.next;
		}
	}
	
	//在尾部添加新节点
	public void add(HeroNode2 heroNode) {
		//需要一个辅助变量，因为head节点不能动
		HeroNode2 temp=head;
		//遍历链表，找到最后
		//当节点的next域==null时，找到了链表的最后
		while(temp.next!=null) {
			//如果没有找到最后,将temp后移
			temp=temp.next;
		}
		//当退出while循环时，temp指向了链表最后
		temp.next=heroNode;
		heroNode.pre=temp;
	}
	
	//在两个节点之间添加新的节点
	public void addByOrder(HeroNode2 heroNode) {
		HeroNode2 temp=head;
		boolean flag=false;//标识添加的编号是否存在
		//temp.next==null 说明temp已经在链表的最后
		while(temp.next!=null) {
			if(temp.next.no>heroNode.no) {
				//位置找到，就在temp的后面插入
				break;
			}
			if(temp.next.no==heroNode.no) {
				//说明待添加的编号已存在，不能再添加
				flag=true;
				break;
			}
			temp=temp.next;//后移，遍历链表
		}
		//判断flag的值
		if(flag) {
			//不能添加，说明编号存在
			System.out.printf("准备插入的英雄的编号%d已存在,不能加入\n",heroNode.no);
		}
		else {
			//插入到链表中，temp的后面
			if(temp.next!=null) {
				//不在最后节点位置添加新节点
				heroNode.next=temp.next;
				temp.next.pre=heroNode;
			}
			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(temp!=null) {
			if(temp.no==newHeroNode.no) {
				//找到了
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if(flag) {
			temp.name=newHeroNode.name;
			temp.nickname=newHeroNode.nickname;
		}
		else {
			//未找到
			System.out.printf("没有找到编号%d的节点，不能修改\n",newHeroNode.no);
		}
	}
	
	//从双向链表中删除一个节点
	//1、对于双向链表可以直接找到要删除的节点
	//2、找到后，自我删除即可
	public void del(int no) {
		//判断当前链表是否为空
		if(head.next==null) {
			System.out.println("链表为空，无法删除");
			return;
		}
		
		//辅助节点temp
		HeroNode2 temp=head.next;//想找的是待删除节点，所以直接指向第一个节点
		boolean flag=false;//是否找到
		while(temp!=null) {
			if(temp.no==no) {
				//找到待删除节点的前一个节点
				flag=true;
				break;
			}
			temp=temp.next;//temp后移，实现遍历
		}
		if(flag) {
			//可以删除
			temp.pre.next=temp.next;
			
			if(temp.next!=null) {
				//删除节点非最后一个节点
				//若删除节点是最后一个节点则不需要修改temp.next.pre
				temp.next.pre=temp.pre;
			}
		}
		else {
			System.out.printf("要删除节点 %d不存在\n",no);
		}
	}
	
}

//定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode2 {
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 next;//指向下一个节点
	public HeroNode2 pre;//指向前一个节点
	
	public HeroNode2(int hNo,String hName,String hNickname) {
		this.no=hNo;
		this.name=hName;
		this.nickname=hNickname;
	}
	
	//为了显示方便，重写toString
	@Override
	public String toString() {
		return "HeroNode [no="+no+",name="+name+",nickname="+nickname+"]";
	}
}