数据结构与算法（三）

目录

单向链表

单链表的应用实例

遍历链表

 添加节点

 方法一：增加节点时，直接增加到尾部

方法二：根据一定的要求，将节点插入到指定位置

 修改节点

 删除节点

双向链表

遍历

添加（默认添加到双向链表的最后）

修改

删除

---

单向链表

 

单链表的应用实例

下面是具体的例子，按照添加的顺序，将数据在链表中排列，那么在遍历的时候，输出的顺序也是按照添加的顺序进行输出的

用到了三个类

HeroNode是在链表的节点里面所要存储的数据

SingleLinkedList是一个类，这个类的对象为单向链表

SingleLinkedList类用来进行测试

HeroNode类

class HeroNode{
    public int no;
    public String name;
    public String NickName;
    public HeroNode next;//指向下一个节点

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

    //重写ToString,方便输出对象信息
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", NickName='" + NickName + '\'' +
                '}';
    }
}

SingleLinkedList类 （在这里面存放一下对单向链表的操作，比如添加，删除，修改，遍历等方法）

public class SingleLinkedList {

    //创建一个头结点
   private HeroNode head=new HeroNode(0,"","");

//add方法
//del方法
//update方法
......
}

遍历链表

 //显示链表【遍历】
    public void list(){
        //判断链表是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //因为头结点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp=head.next;
        while (true){
            if (temp==null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移，一定要小心这一步
            temp=temp.next;
        }

    }

 添加节点

 方法一：增加节点时，直接增加到尾部

具体代码

//添加节点
    //思路，但不考虑编号顺序时
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode){
        //因为head节点不能动，所以我们需要一个辅助遍历temp
        HeroNode temp=head;
        //遍历链表，找到最后的节点
        while (true){
            if (temp.next==null){
                break;
            }
            //如果没有找到最后，那么将temp往后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next=heroNode;
    }

 测试结果 

方法二：根据一定的要求，将节点插入到指定位置

具体代码：

 //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    //（如果有这个排名，则添加失败，并给出提示）
    public void addByOrder(HeroNode heroNode) {
        //头结点不能动，所以要通过一个辅助变量来帮助查找到添加的位置
        //这里要用到插入位置的前一个节点，并且使用的是单向链表，所以temp只能指向插入位置的前一个节点
        HeroNode temp = head;
        boolean flag = false;//flag标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {//说明temp以及在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) {//位置找到，就在temp的后面插入
                break;

            } else if (temp.next.no == heroNode.no) {//说明希望添加的HeroNode的编号已经存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;//将temp指针后移，遍历当前链表
        }
        //判断flag的值
        if(flag){//此时编号已经存在,那么就会输出提示信息
            System.out.printf("待插入的英雄的编号%d已经存在，不能加入\n",heroNode.no);
        }else{//编号不存在，那么就插入到链表中,在temp的后面
            heroNode.next=temp.next;//把后一个节点（temp.next)赋值给新节点的next
            temp.next=heroNode;//把新节点赋值给前一个节点的next
        }
    }

 运行结果：

 修改节点

具体方法

//修改节点的信息，根据编号来修改，即no编号不能修改
    //1.根据newHeroNode的no来修改即可
    public  void  update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp=head.next;
        boolean flag=false;//表示是否找到该节点
        while (true){
            if(temp==null){
                break;//链表遍历结束，temp已经指到了最后一个元素的next
            }
            if(temp.no==newHeroNode.no){
                //找到了要修改的节点
                flag=true;
                break;
            }
            temp=temp.next;
        }
//根据flag判断是否找到要修改的节点
        if(flag){
            temp.name=newHeroNode.name;
            temp.NickName=newHeroNode.NickName;
        }else {//没有找到
            System.out.printf("没有找到编号%d的节点，不能修改\n",newHeroNode.no);

        }
    }

在这里我们需要警惕！！！！在方法的while(true)循环里面，只能判断temp是不是为空，不能判断temp.next是否为空。

 若是判断temp.next是否为空，那么会出现以下错误

 如果是判断temp是否为空，那么就不会出现上面那张图里的错误

 测试结果：

 删除节点

具体方法：

//删除节点
    //思路
    //1.Head节点不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2.说明我们在比较时，是temp.next.no和需要删除的节点的no比较
    public void del(int no){
        HeroNode temp=head;
        boolean flag=false;//判断是否在链表中找到待删除的节点
        while (true){
            if (temp.next==null){//已经到了链表的最后
                break;
            }
            if (temp.next.no==no){
                //找到的待删除节点的前一个节点temp
                flag=true;
                break;
            }
            temp=temp.next;//上面两种情况都不是的话，那么temp后移，遍历链表
        }
        if(flag){//找到了待删除的节点的前一个节点
            temp.next=temp.next.next;;
        }else{
            System.out.printf("要删除的%d号节点不存在\n",no);
        }
    }

 测试结果：

双向链表

遍历

方法可以和单向链表一样，只是可以向前，也可以向后查找

添加（默认添加到双向链表的最后）

思路与单向链表的一样

与单向链表的不同点在于在进行对next和pre进行具体操作的时候，双向链表要把新加的节点的pre指向链表遍历到的最后一个节点。

单向链表的是这样 

 

修改

思路与单向链表的一样，代码也可以一样

删除

因为是双向链表，所以我们可以实现自我删除某个节点

直接找到这个节点即可

注意：如果需要删除的节点是双向链表的最后一个元素，那么就会有点不同，只需要把temp.pre.next==temp.next（把待删除节点的前一个节点的next指向待删除节点的下一个节点）即可，不需要执行temp.next.pre=.pre（把待删除节点的下一个节点的前一个节点改为待删除节点的前一个节点）

    //从双向链表中删除节点
    //1.对于双向链表，我们可以直接找到要删除的节点，而单向链表则是找到要删除的节点的前一个节点
    public void del(int no){
        //判断当前链表是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp=head.next;//辅助变量（指针）
        boolean flag=false;//判断是否在链表中找到待删除的节点
        while (true){
            if (temp==null){//已经到了链表的最后节点的next
                break;
            }
            if (temp.no==no){
                //找到的待删除节点的前一个节点temp
                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);
        }
    }