0078 双向链表

  

package LinkedList_;
/*双向链表的增删改查
 * 
 * 应用实例——使用带头结点的双向链表实现水浒英雄排名管理
 * 1.遍历方式和单链表一样，但双向链表可以向前也可以向后查找
 * 
 * 2.添加（添加到双向链表的最后）
 *         1.先找到双向链表的最后结点
 *         2.temp.next = newHeroNode;
 *         3.newHeroNode.pre = temp;
 * 
 * 3.修改 思路与单向链表一致
 *         根据no，找到需要修改的结点，定义一个辅助变量temp
 * 
 * 4.删除
 *         双向链表可以实现自我删除某个结点
 *         1.找到要删除的结点，如temp
 *         2.temp.pre.next = temp.next;
 *         3.temp.next.pre = temp.pre;
 * 
 * 5.查找
 *         遍历，找到就返回true，反之false
 * 
 */
public class DoubleLinkedList_ {
    public static void main(String[] args) {
        //创建结点
        HeroNode02 hero1 = new HeroNode02(1, "宋江", "及时雨");
        HeroNode02 hero2 = new HeroNode02(2, "卢俊义", "玉麒麟");
        HeroNode02 hero3 = new HeroNode02(3, "吴用", "智多星");
        HeroNode02 hero4 = new HeroNode02(4, "公孙胜", "入云龙");
        
        //创建双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        //添加
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        
        //遍历
        doubleLinkedList.list();
        
        //修改
        HeroNode02 newHeroNode02 = new HeroNode02(1,"呼保义","孝义黑三郎");
        doubleLinkedList.update(newHeroNode02);
        System.out.println("修改后的链表=========================================");
        doubleLinkedList.list();
        
        //删除
        doubleLinkedList.delete(1);
        doubleLinkedList.delete(4);
        System.out.println("删除后的链表=========================================");
        doubleLinkedList.list();
        
        //查找
        System.out.println("查找结果");
        System.out.println(doubleLinkedList.search(1));
        System.out.println(doubleLinkedList.search(2));
        System.out.println(doubleLinkedList.search(3));
        System.out.println(doubleLinkedList.search(4));
        
        //第二种添加方法
        doubleLinkedList.add02(hero1);
        doubleLinkedList.add02(hero4);
        HeroNode02 hero5 = new HeroNode02(5, "关胜", "大刀");
        doubleLinkedList.add02(hero5);
        System.out.println("添加后==============================================");
        doubleLinkedList.list();
    }
}

//创建一个双向链表的类
class DoubleLinkedList{
    //初始化头结点，不能动
    private HeroNode02 head = new HeroNode02(0, "", "");
    
    public HeroNode02 getHead() {
        return head;
    }
    
    //1.遍历双向链表的方法
    //显示链表(遍历)
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此需要一个辅助变量来遍历
        HeroNode02 temp = head.next;
        while(true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出结点信息
            System.out.println(temp);
            //temp后移
            temp = temp.next;
        }
    }
    
    //2.添加（添加到双向链表的最后）
    public void add(HeroNode02 heroNode) {
        //因为head头结点不能动，需要一个辅助变量 temp
        HeroNode02 temp = head;
        //遍历链表，找到最后
        while(true) {
            if (temp.next == null) {//找到链表最后
                break;
            }
            temp = temp.next;//没有找到，将temp后移
        }
        //退出while循环时，temp就指向了链表的最后
        //形成双向链表
        temp.next = heroNode;
        heroNode.pre = temp;
    }
    
    //第二种添加方法：根据排名将英雄插入到指定位置（如果有这个排名，则插入失败）
    public void add02(HeroNode02 heroNode) {
        //头结点不动，通过辅助变量找到添加位置
        //temp位于添加位置的前一个结点
        HeroNode02 temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//temp已到链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {//temp位置找到，在添加位置的前一个结点
                break;
            }else if (temp.next.no == heroNode.no) {//说明编号存在
                flag = true;
                break;
            }
            temp=temp.next;//都不满足上述情况，将temp后移
        }
        //判断flag的值
        if (flag) {
            System.out.printf("编号%d已经存在，不能加入\n",heroNode.no);
        }else {
            //形成双向链表
            if (temp.next != null) {
                heroNode.next = temp.next;
                temp.next.pre = heroNode;
            }
            temp.next = heroNode;
            heroNode.pre = temp;
        }
    }
    
        
    //3.修改 思路与单向链表一致
    //修改结点信息，根据no编号修改(修改no相当于添加)
    public void update(HeroNode02 newHeroNode) {
        //判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //根据no，找到需要修改的结点
        //定义一个辅助变量
        HeroNode02 temp = head.next;
        boolean flag = false;//表示是否找到该结点
        while(true) {
            if (temp == null) {//遍历结束
                break;
            }
            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);
            }
        }
    
    //4.删除
    //双向链表可以实现自我删除某个结点
        //1.找到要删除的结点，如temp
        //2.temp.pre.next = temp.next;
        //3.temp.next.pre = temp.pre;
    public void delete(int no) {
        //判断当前链表是否为空
        if(head.next == null) {
            System.out.println("链表为空，无法删除");
            return;
        }
        HeroNode02 temp = head.next;//辅助变量
        boolean flag = false;//标志是否找到
        while(true) {
            if (temp == null) {//已到链表最后
                break;
            }
            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.pre;//如果删除的是最后一个结点，就不需执行，否则出现空指针异常
            }
        }else {
            System.out.printf("要删除的%d结点不存在\n",no);
        }
    }
    
    //5.查找
    public boolean search(int no) {
        HeroNode02 temp = head.next;
        while(temp != null) {
            if (temp.no == no) {
                return true;
            }
            temp = temp.next;
        }
        return false;
    }
}

//定义HeroNode，每个HeroNode对象就是一个结点
class HeroNode02{
    public int no;
    public String name;
    public String nickname;
    public HeroNode02 next;//指向下一个结点，默认为null
    public HeroNode02 pre;//指向前一个结点，默认为null
    //构造器
    public HeroNode02(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }
    //重写toString
    @Override
    public String toString() {
        return "HeroNode02 [no=" + no + ", name=" + name + ", nickname=" + nickname + "]";
    }
}