Java数据结构与算法--双向链表（DoubleLinkeList）

1. 双向链表的操作分析和实现

   使用带 head 头的双向链表实现------水浒英雄排行榜

2. 管理单向链表的缺点分析

   1. 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找。
   2. 单向链表不能自我删除，需要靠辅助节点 ，而双向链表，则可以自我删除，所以前面我们单链表删除时节点，总是找到 temp,temp 是待删除节点的前一个节点(认真体会)。
   3. 分析了双向链表如何完成遍历，添加，修改和删除的思路。

对上图的说明:
分析 双向链表的遍历，添加，修改，删除的操作思路—>代码实现

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

2. 添加 (默认添加到双向链表的最后)

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

3. 修改 思路和 原来的单向链表一样。

4. 删除。

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

import java.util.linkedList;

public class DoublelinkedListDemo {
    public static void main(String[] args) {
        HeroNode2 heroNode1 = new HeroNode2(0, "张三", "san");
        HeroNode2 heroNode2 = new HeroNode2(1, "李四", "si");
        HeroNode2 heroNode3 = new HeroNode2(2, "王五", "wu");
        HeroNode2 heroNode4 = new HeroNode2(3, "赵六", "liu");
        DoublelinkedList doublelinkedList = new DoublelinkedList();
        doublelinkedList.add(heroNode1);
        doublelinkedList.add(heroNode2);
        doublelinkedList.add(heroNode4);
        doublelinkedList.add(heroNode3);
        doublelinkedList.list();
        System.out.println("------清空链表后------");
        doublelinkedList.clear();
        doublelinkedList.list();
        System.out.println("------按照no顺序添加------");
        doublelinkedList.addOrder(heroNode3);
        doublelinkedList.addOrder(heroNode1);
        doublelinkedList.addOrder(heroNode2);
        doublelinkedList.addOrder(heroNode3);
        HeroNode2 heroNode5 = new HeroNode2(2, "赵云", "yun");
        doublelinkedList.list();
        System.out.println("------修改后------");
        doublelinkedList.update(heroNode5);
        doublelinkedList.list();
        System.out.println("------删除后------");
        doublelinkedList.delete(0);
        doublelinkedList.list();

    }
}

class DoublelinkedList{

    private HeroNode2 head = new HeroNode2(0,"","");

    // 获取头节点(不是链表中的有效数据)
    public HeroNode2 getHead() {
        return head;
    }


    // 根据编号no删除节点
    public void delete(int no){
        if (head.next==null){
            System.out.println("空链表，无法删除");
        }
        // head节点不能动,创建一个备份
        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.println("你要删除的节点不存在");
        }
    }

    //根据no修改链表数据
    public void update(HeroNode2 newHeroNode){
        if (head.next==null){
            System.out.println("链表为空");
        }

        // head节点不能动,创建一个备份
        HeroNode2 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.println("要修改的节点不存在");
        }

    }

    //添加的时候按照no从小到大排序
    public void addOrder(HeroNode2 heroNode){
        //因为head节点不能用，所以创建一个辅助
        HeroNode2 temp = head;
        boolean flag = false;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.no==heroNode.no){
                flag = true;
                break;
            }
            if (temp.next.no>heroNode.no){
                break;
            }
            temp = temp.next;
        }
        if (flag){
            System.out.println("该数据已存在");
        }else {
            heroNode.next = temp.next;
            if (temp.next!=null){
                temp.next.pre = heroNode;
            }
            heroNode.pre = temp;
            temp.next= heroNode;
        }

    }

    // 按顺序依次添加到链表尾部
    public void add(HeroNode2 heroNode){
        //因为head节点不能用，所以创建一个辅助
        HeroNode2 temp = head;
        //遍历链表，找到最后一个节点
        while (true){
            if (temp.next==null){
                temp.next = heroNode;
                heroNode.pre = temp;
                break;
            }
            temp = temp.next;
        }
    }
    // 打印链表所有数据
    public void list(){
        //因为head节点不能用，所以创建一个辅助
        HeroNode2 temp = head;
        while (true){
            if (temp.next==null){
                break;
            }
            System.out.println(temp.next);
            temp = temp.next;
        }
    }

    // 清空链表
    public void clear(){
        head.next=null;
    }

}

class HeroNode2{
    public Integer no;
    public String name;
    public String nickName;
    public HeroNode2 next;
    public HeroNode2 pre;

    public HeroNode2(Integer no, String name, String nickName) {
        this.no = no;
        this.name = name;
        this.nickName = nickName;
    }


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