单项链表和双向链表-实现英雄节点的增删改操作

一、单项链表

单向链表逻辑结构意图

1.定义一个英雄节点类

//定义一个HeroNode，每个HeroNode对象就是一个节点
class HeroNode{
    public int no;//编号
    public String name ;//姓名
    public String nickName ;//昵称
    public HeroNode next;//next指向下一个节点


    //构造器
    public HeroNode(int 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 + '\'' +
                '}';
    }

}

2.定义一个单向链表，实现对英雄节点的增删改管理！

//定义一个SingleLinkedList，管理heroNode
class SingleLinkedList{
    //初始化头节点,头节点，不存放数据
    private HeroNode headNode = new HeroNode(0,"","");



    //添加HeroNode节点到单链表SingleLinkedList(尾插法)，不考虑顺序
    public void add(HeroNode heroNode){
        //头节点不动，借助辅助变量
        HeroNode tempNode=headNode;
        //遍历整个链表，找到尾结点
        while(true){
            if (tempNode.next ==null){
                break;
            }
            tempNode = tempNode.next;
        }
        //找到尾结点后，将新添加的节点连接在尾结点
        tempNode.next = heroNode;

    }

    //单链表中的节点实现顺序排列，则插入时，可先找到待插入的位置
    public void addByOrder(HeroNode insertHeroNode){
        //因为头节点（head）不能变，所以定义一个辅助指针
        HeroNode tempNode = headNode;
        //定义一个flag。判断待插入的变量是否存在,默认为false，不存在
        boolean flag = false;
        //遍历查找单链表中，待插入的位置
        while(true){
            //当前辅助指针已到单链表的尾部
            if (tempNode.next == null){
                break;
            }
            //找到待插入位置,temp指针指向下一个节点的编号>待插入节点编号，则找到待插入的heroNode在temp和temp.next之间
            if (tempNode.next.no>insertHeroNode.no){

                break;
            }
            //插入的节点已存在
            else if (tempNode.next.no == insertHeroNode.no){
                flag = true;
                break;
            }
            //否则没有找到，则继续寻找待插入位置
            tempNode = tempNode.next;
        }
        if (flag){
            //flag为真则节点存在，不能添加
            System.out.printf("节点编号%d已存在，不能继续插入！！\n",insertHeroNode.no);
        }else{
            //节点不存在，则执行插入操作
            insertHeroNode.next = tempNode.next;//heroNode后面接tempNode.next
            tempNode.next = insertHeroNode;
        }

    }

    //根据插入编号修改节点
    public void update(HeroNode newHeroNode){
        //判断链表是否为空
        if (headNode.next == null){
            System.out.println("该链表为空，没有数据！！！");
            return;
        }

        //定义一个辅助节点
        HeroNode tempNO = headNode.next;
        boolean flag = false;//默认节点不存在
        //根据编号遍历查找节点
        while(true){
            //若得到尾结点，则说明没有找到要修改节点的编号，没有节点信息
            if (tempNO.next == null){
                break;
            }
            if (tempNO.no == newHeroNode.no){
                //如果找到则flag为true
                flag = true;
                break;
            }
            tempNO = tempNO.next;
        }
        //退出循环,根据flag判断，flag = true则找到，flag = false 则没有找到
        if (flag){
            tempNO.name = newHeroNode.name;
            tempNO.nickName = newHeroNode.nickName;
        }else{
            System.out.println("没有找到需要修改的节点编号:"+newHeroNode.no);
        }
    }


    /**
     * 从单链表中删除一一个节点的思路
     * 1.我们先找到需要删除的这个节点的前一个节点temp
     * 2. temp.next = temp.next.next
     * 3.被删除的节点，将不会有其它引用指向，会被垃圾回收机制回收
     *
     **/
    //根据标号删除节点
    public void delete(int no){
        //判断链表是否为空
        if (headNode.next == null){
            System.out.println("链表为空,没有数据！！！");
        }
        HeroNode tempNode =headNode;
        boolean flag2 = false;//标志是否找到待删节点
        while (true){
            //到达尾节点，没找到删除元素的编号
            if (tempNode.next ==null ){
                break;
            }
            if (tempNode.next.no == no){
                flag2 = true;
                break;
            }
            tempNode = tempNode.next;//后移实现遍历
        }
        if (flag2){
            System.out.println("已删除节点编号为"+no+"的节点信息！！");
            tempNode.next =tempNode.next.next;

        }else{
            System.out.println("编号为"+no+"的节点信息不存在,故无法删除！！");
        }
    }



    //遍历显示链表
    public void showNode(){
        //先遍历链表是否为空
        if (headNode.next == null){
            System.out.println("链表为空,没有数据！！！");
        }
        //头节点不能动，所以用临时节点表示
        HeroNode tempNode = headNode.next;
        while(true){
            if (tempNode ==null){
                break;
            }
            //不为空，则输出结点信息
            System.out.println(tempNode);
            //将tempNode后移
            tempNode = tempNode.next;

        }


    }

}

3.测试类

public class SingleLinkedListTest {
    public static void main(String[] args){
        //创建节点
        HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
        HeroNode hero2 = new HeroNode(2,"吴用","智多星");
        HeroNode hero5 = new HeroNode(5,"李逵","黑旋风");
        HeroNode hero3 = new HeroNode(3,"卢俊义","玉麒麟");
        HeroNode hero4 = new HeroNode(4,"武松","豹子头");

        //创建单链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入hero
        /*
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero5);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
         */
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero5);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero4);

        //显示修改前链表
        System.out.println("----------修改前链表--------");
        singleLinkedList.showNode();

        //插入已存在的节点
        singleLinkedList.addByOrder(hero3);
        //测试需要修改的节点
        HeroNode newHeroNode2 = new HeroNode(3,"鲁智深","花和尚");
        HeroNode newHeroNode1 = new HeroNode(8,"周通","小霸王");

        singleLinkedList.update(newHeroNode1);
        singleLinkedList.update(newHeroNode2);


        //显示修改后链表
        System.out.println("----------修改后链表--------");
        singleLinkedList.showNode();
        //删除节点
        singleLinkedList.delete(4);
        singleLinkedList.delete(8);
        singleLinkedList.showNode();

    }
}

4.结果

二、双向链表

双向链表逻辑结构示意图

1.定义一个英雄节点类（这次多了一个pre指针，指向前一个结点）

//定义一个HeroNode1，每个HeroNode对象就是一个节点
class HeroNode1{
    public int no;//编号
    public String name ;//姓名
    public String nickName ;//昵称
    public HeroNode1 next;//next指向下一个节点,默认为null
    public HeroNode1 pre;//pre指向上一个节点


    //构造器
    public HeroNode1(int 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 + '\'' +
                '}';
    }

}

2.定义一个双向链表，实现增删改操作，管理节点

class DoubleLinkedList{
   private HeroNode1 headNode = new HeroNode1(0,"","");



    //遍历
    public void showNode(){
        if (headNode.next == null){
            System.out.println("链表为空，没有数据！！");
            return;
        }else{
            HeroNode1 tempNode = headNode.next;
            while(true){
                //遍历到链表最后
                if (tempNode == null){
                    break;
                }else{
                    //输出节点信息
                    System.out.println(tempNode);
                    //指针后移
                    tempNode = tempNode.next;
                }
            }
        }
    }

    //添加节点
    public  void addNode(HeroNode1 heroNode1){
        HeroNode1 tempNode = headNode;
        //循环遍历找到最后一个节点
        while(true){
            //找到链表最后
            if (tempNode.next == null){
                tempNode.next = heroNode1;
                heroNode1.pre = tempNode;
                break;
            }
            //若不是最后一个节点则辅助指针后移
            tempNode = tempNode.next;
        }
    }

    //删除节点
    public void delNode(int no){
        //判断链表是否为空
        if (headNode.next == null){
            System.out.println("链表为空，没有要删除的节点数据！！");
            return;
        }else{
            //循环查找需要删除的节点编号
            HeroNode1 tempNode = headNode;
            boolean flag = false;
            //遍历
            while(true){
                if (tempNode.next == null){
                    break;
                }
                if (tempNode.no == no){
                    flag = true;
                    break;
                }
                //指针后移
                tempNode = tempNode.next;
            }
            if (flag){
                tempNode.pre.next = tempNode.next;
                tempNode.next.pre = tempNode.pre;
                System.out.printf("编号为%d的节点信息已被更新！！\n",no);
            }else{
                System.out.printf("没有找到需要编号为%d的节点，故无法跟新！！\n",no);
            }


        }
    }

    //修改节点信息
    public  void updateNode(HeroNode1 hero){
        //判断链表是否为空
        if (headNode.next ==null){
            System.out.println("链表为空！！没有数据！！！");

        }
        //定义辅助指针
        HeroNode1 tempNode = headNode.next;
        boolean flag = false;
        while(true){
            //遍历到末尾，没有找到该编号
            if (tempNode.next ==null){
                break;
            }
            if (tempNode.no == hero.no){
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }
        if (flag){
            tempNode.name = hero.name;
            tempNode.nickName = hero.nickName;
        }else {
            System.out.printf("索要添加编号为%d的节点信息不存在,无法执行修改操作\n",hero.no);
        }
    }

}

3.测试类

public class DoubleLinkedListTest {
    public static void main(String[] args){
        //创建一个双向链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();
        //创建3个节点
        HeroNode1 hero1 = new HeroNode1(1,"宋江","及时雨");
        HeroNode1 hero2 = new HeroNode1(2,"吴用","智多星");
        HeroNode1 hero3 = new HeroNode1(3,"李逵","黑旋风");
        HeroNode1 hero4 = new HeroNode1(4,"卢俊义","玉麒麟");
        HeroNode1 hero5 = new HeroNode1(5,"武松","豹子头");
        //链表添加节点
        doubleLinkedList.addNode(hero1);
        doubleLinkedList.addNode(hero2);
        doubleLinkedList.addNode(hero3);
        doubleLinkedList.addNode(hero4);
        doubleLinkedList.addNode(hero5);
        //显示链表
        System.out.println("---------修改前链表------");
        doubleLinkedList.showNode();
        //删除链表
        doubleLinkedList.delNode(6);
        System.out.println("---------修改后链表------");
        doubleLinkedList.showNode();

        //更新节点信息
        doubleLinkedList.updateNode(new HeroNode1(3,"苟哥哥","老好人"));
        System.out.println("---------修改后链表------");
        doubleLinkedList.showNode();


    }
}

4.结果

三、单项链表于双向链表的比较

1)单向链表， 查找的方向只能是一个方向，而双向链
表可以向前或者向后查找。
2)单向链表不能自我删除， 需要靠辅助节点，而双向
链表，则可以自我删除，所以前面我们单链表删除
时节点，总是找到temp的下一个节点来删除的