数据结构之双向链表

双向链表

1）、双向链表的构造：head节点、data、next（指向下一个）、pre（指向上一个）

2）、双向链表的添加、遍历、删除、修改的操作思想===>代码实现

a．遍历；方式和单链表一样，只是可以向前查找，向后查找

b．添加(默认添加到双向链表的最后)；先找到双向链表的最后这个节点，temp.next=newHead 最后一
个节点指向新节点，新节点的pre指向我们的最后一个节点，newHead.pre=temp;

c．修改：思路和原来的单项链表一样

d．删除：双向链表可以实现自我删除，直接找到要删除的这个节点，比如
temp,tem.pre.next=temp.next, temp.next.pre=temp.pre

3）、代码实现双向链表的增删改查

package linkedlist;
public class DoubleLikedListDemo {
	public static void main(String[] args) {
		//双向链表测试
		System.out.println("双向链表的测试");

		HerNode2 hero1 = new HerNode2(1, "宋江", "及时雨");
		HerNode2 hero2 = new HerNode2(2, "卢俊义", "玉麒麟");
		HerNode2 hero3 = new HerNode2(3, "吴用", "智多星");
		HerNode2 hero4 = new HerNode2(4, "林冲", "豹子头");
		HerNode2 hero5 = new HerNode2(4, "林冲2", "豹子头2");

		DoubleLikedList singleLinkedList = new DoubleLikedList();

		/*singleLinkedList.add(hero1);
		singleLinkedList.add(hero3);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero4);*/

		singleLinkedList.addOrder(hero1);
		singleLinkedList.addOrder(hero3);
		singleLinkedList.addOrder(hero2);
		singleLinkedList.addOrder(hero4);

		System.out.println("原来的链表");
		singleLinkedList.list();

		System.out.println("修改后的链表");
		singleLinkedList.update(hero5);
		singleLinkedList.list();

		System.out.println("删除后的链表");
		singleLinkedList.delete(4);
		singleLinkedList.list();

	}
}
//创建一个双向链表类
class DoubleLikedList{
	//初始化一个头节点，头节点不要动,不存放具体的数据
	private HerNode2 head = new HerNode2(0,"","");
	//返回头节点
	public HerNode2  getHead(){
		return head;
	}


	/**
	 * //按照编号顺序添加
	 * @param herNode
	 */
	public void addOrder(HerNode2 herNode){
		//因为头节点不能动，我们需要通过一个辅助变量来帮助找到添加的位置
		//因为是单链表，我们要找的temp，是位于添加位置的前一个节点，否则插入不了
		HerNode2 temp =head;
		boolean flag= false;//用来标志添加的编号是否已经存在，默认为false
		while (true){
			if (temp.next==null){//说明temp已经在链表最后
				break;
			}
			if (temp.next.no>herNode.no){//找到位置，就在temp的后面插入
				break;
			}else if (temp.next.no==herNode.no){//说明希望添加的heroNode的编号已然存在
				flag=true;
				break;
			}
			temp=temp.next;//后移，遍历当前链表
		}
		//判断flag的值
		if (flag){
			System.out.printf("您的英雄%d已存在\n",herNode.no);
		}else {
			//插入到链表中，temp后面
			herNode.next=temp.next;//当前插入的节点的指向temp的后一位
			temp.next=herNode;//temp指向新的节点，这样就插到中间了。
			herNode.pre=temp;

		}
	}
	/**
	 * 对于双向链表，可以直接找到到要删除的节点
	 * 找到以后自我删除即可
	 * @param no
	 */
	public void delete(int no){
		//判断当前链表是否为空
		if (head.next==null){
			System.out.println("空链表,无法删除");
			return;
		}
		HerNode2 temp = head.next;//辅助变量
		boolean flag = false;//表示是否找到待删除节点
		while (true){
			if (temp==null){//已经到链表最后节点的next域
				break;
			}
			if (temp.no==no){//找到待删除节点的前一个节点temp
				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.println("要删除的节点不存在。。。");
		}

	}
	/**
	 * 修改双向链表中的节点，和单向链表一样，只是节点类型改为了HerNode2
	 * @param newNode
	 */
	public void update(HerNode2 newNode){
		//判断是否为空
		if (head.next==null){
			System.out.println("链表为空");
			return;
		}
		//找到修改的节点通过遍历
		HerNode2 temp=head.next;
		boolean flag =false;//表示是否找到该节点
		while (true){
			if (temp==null){
				break;//已经遍历完成
			}
			if (temp.no== newNode.no){
				flag=true;
				break;
			}
			temp=temp.next;
		}
		if (flag){
			temp.name=newNode.name;
			temp.nickName=newNode.nickName;
		}else {
			System.out.printf("没有找到编号%d 的节点",newNode.no);
		}


	}
	/**
	 * 添加一个节点到双向链表
	 * @param herNode
	 */
	public void add(HerNode2 herNode){
		//因为head节点不能动，因此需要一个辅助变量temp
		HerNode2 temp = head;
		//遍历链表，找到最后
		while (true){
			//判断当前节点是否是最后一个
			if (temp.next==null){
				break;
			}
			//如果没有找到最后，将temp后移，查找后一个
			temp=temp.next;
		}
		//当前退出while循环时，temp就指向链表最后
		temp.next=herNode;
		herNode.pre=temp;
	}

	//显示链表【遍历】
	public void list(){
		//判断链表是否为空
		if(head.next==null){
			System.out.println("链表为空！");
			return;
		}
		//如果不为空至少有一个节点，所以从第二个节点开始遍历，
		// 头节点不能动，因此，需要一个辅助变量来遍历
		HerNode2 temp = head.next;
		while (true){
			//是否到链表最后
			if (temp==null){
				break;
			}
			//输出当前节点的信息
			System.out.println(temp);
			//将temp后移，判断下一个，输出
			temp=temp.next;
		}
	}

}
//定义一个heroNode，每个node对象就是一个节点
class HerNode2{
	public int no;
	public String name;
	public String nickName;
	public HerNode2 next;//指向下一个节点,默认为null
	public HerNode2 pre;//指向上一个节点,默认为null
	//构造器
	public HerNode2(int no,String name,String nickName){
		this.no=no;
		this.name=name;
		this.nickName=nickName;
	}
	public HerNode2(){};

	@Override
	public String toString() {
		return "HerNode2{" +
				"no=" + no +
				", name='" + name + '\'' +
				", nickName='" + nickName + '\'' +
				'}';
	}
}