链表_双向链表模拟

import java.util.ArrayList;
import java.util.List;

/**
 * 双向链表
 */
public class DoubleLinkedListDemo {

    public static void main(String[] args) {
        //创建单链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        //创建节点
        HeroNode2 heroNode1 = new HeroNode2(1, "A", "aa");
        HeroNode2 heroNode2 = new HeroNode2(2, "B", "bb");
        HeroNode2 heroNode3 = new HeroNode2(3, "C", "cc");
        HeroNode2 heroNode4 = new HeroNode2(5, "E", "ee");
        HeroNode2 heroNode5 = new HeroNode2(4, "D", "dd");

        HeroNode heroNode6 = new HeroNode(4, "Z", "zz");
        //加入
        doubleLinkedList.addLast(heroNode1);
        doubleLinkedList.addLast(heroNode2);
        doubleLinkedList.addLast(heroNode3);
        doubleLinkedList.addLast(heroNode4);
        doubleLinkedList.addLast(heroNode5);
//        doubleLinkedList.addLast(heroNode5);
        //修改
        doubleLinkedList.update(heroNode6);
        doubleLinkedList.delete(1);
        //展示
        doubleLinkedList.show();

//        - #### 单链表中有效节点的个数
        System.out.println(doubleLinkedList.getCount());

//         - #### 查找单链表中的单数第K个节点
        System.out.println(doubleLinkedList.getNode(4));


    }

}


class DoubleLinkedList {
    //初始化头结点
    private HeroNode2 head = new HeroNode2(0, "", "");

    /**
     * 添加
     * 添加到列表的最后
     * ①找到当前列表的最后节点
     * ②将最后节点的next指向新的节点
     *
     * @param heroNode
     */
    public void addLast(HeroNode2 heroNode) {
        //临时
        HeroNode2 tmp = head;

        //遍历链表，找到最后的节点
        while (true) {
            //没有下一个节点，则为最一个节点
            if (tmp.getNext() == null) {
                break;
            }
            //向后移
            tmp = tmp.getNext();
        }
        //设置新的节点
        tmp.setNext(heroNode);
        heroNode.setPre(tmp);

    }


    /**
     * 修改
     * 根据编号修改英雄
     *
     * @param heroNode
     */
    public void update(HeroNode heroNode) {

        //判断是否为空
        if (head.getNext() == null) {
            System.out.println("空");
            return;
        }
        HeroNode2 tmp = head.getNext();
        //表示是否找到
        boolean flag = false;
        while (true) {
            if (tmp == null) {
                break;
            }

            if (tmp.getNo() == heroNode.getNo()) {
                //找到
                flag = true;
                break;
            }

            tmp = tmp.getNext();

        }
        if (flag) {
            tmp.setName(heroNode.getName());
            tmp.setNickName(heroNode.getNickName());
        } else {
            System.out.println("找不到");
        }

    }

    /**
     * 根据no删除
     *
     * @param no
     */
    public void delete(int no) {
        //判断是否为空
        if (head.getNext() == null) {
            System.out.println("空");
            return;
        }
        HeroNode2 tmp = head.getNext();

        //是否找到
        boolean flag = false;

        while (true) {

            if (tmp == null) {
                break;
            }
            if (tmp.getNo() == no) {
                flag = true;
                break;
            }
            tmp = tmp.getNext();
        }

        if (flag) {
            tmp.getPre().setNext(tmp.getNext());

            if (tmp.getNext() != null) {
                tmp.getNext().setPre(tmp.getPre());
            }



        } else {
            System.out.println("找不到");
        }

    }

    /**
     * 插入中间
     *
     * @param heroNode
     */
    public void addByOrder(HeroNode2 heroNode) {
        //临时
        HeroNode2 tmp = head;
        //默认添加的编号不存在
        boolean flag = false;
        //遍历链表，找到要插入的节点
        while (true) {
            //没有下一个节点，则为最一个节点
            if (tmp.getNext() == null) {
                break;
            }
            //大于当前节点的no
            if (tmp.getNext().getNo() > heroNode.getNo()) {
                break;
            } else if (tmp.getNext().getNo() == heroNode.getNo()) {
                flag = true;
            }
            //向后移
            tmp = tmp.getNext();
        }
        if (flag) {
            //编号存在
            System.out.println("已经存在相同编号：" + heroNode);
            return;
        }
        //设置新的节点
        //声明原先的节点
        HeroNode2 preNode = tmp.getNext();
        heroNode.setNext(preNode);
        tmp.setNext(heroNode);

    }

    /**
     * 显示
     */
    public void show() {
        System.out.println("-------------show--------------");
        //空链表
        if (head.getNext() == null) {
            return;
        }
        //临时
        HeroNode2 tmp = head.getNext();
        while (true) {
            System.out.println(tmp);
            //没有下一个节点，则为最一个节点
            if (tmp.getNext() == null) {
                break;
            }
            //向后移
            tmp = tmp.getNext();
        }
    }


    //        - #### 单链表中有效节点的个数
    public int getCount() {
        int count = 0;

        HeroNode2 tmp = head.getNext();

        while (tmp != null) {
            count++;
            tmp = tmp.getNext();
        }

        return count;
    }


    //         - #### 查找单链表中的第K个节点
    public HeroNode2 getNode(int k) {
        int count = 0;

        HeroNode2 tmp = head.getNext();
        HeroNode2 result = null;
        while (tmp != null) {
            count++;
            if (count == k) {
                result = tmp;
                break;
            }

            tmp = tmp.getNext();
        }

        return result;
    }

    /**
     * - #### 单链表的反转
     * 方法①：存入容器，遍历容器
     */
    public void reverse() {
        HeroNode2 tmp = head.getNext();
        List<HeroNode2> list = new ArrayList();

        while (tmp != null) {
            list.add(tmp);
            tmp = tmp.getNext();
        }

        HeroNode2 tmp1 = head;
        int i = list.size() - 1;
        //移除 最后一个元素的尾指针
        list.get(0).setNext(null);
        while (i >= 0) {
            tmp1.setNext(list.get(i));
            tmp1 = tmp1.getNext();
            i--;
        }

    }


    public HeroNode2 getHead() {
        return head;
    }
}

/**
 * 模拟英雄排行
 */
class HeroNode2 implements Cloneable {

    /**
     * 号码
     */
    private int no;

    /**
     * 名字
     */
    private String name;

    /**
     * 昵称
     */
    private String nickName;

    /**
     * 上一个
     */
    private HeroNode2 pre;
    /**
     * 下一个
     */
    private HeroNode2 next;


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

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNickName() {
        return nickName;
    }

    public void setNickName(String nickName) {
        this.nickName = nickName;
    }

    public HeroNode2 getPre() {
        return pre;
    }

    public void setPre(HeroNode2 pre) {
        this.pre = pre;
    }

    public HeroNode2 getNext() {
        return next;
    }

    public void setNext(HeroNode2 next) {
        this.next = next;
    }
}