单链表的介绍及基础操作

单链表

1.单链表介绍

链表是有序的列表，但是它在内存中是存储如下

1. 链表是以节点的方式来存储,是链式存储
2. 每个节点包含 data 域， next 域：指向下一个节点.
3. 如图：发现链表的各个节点不一定是连续存储.
4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定

• 单链表(带头结点) 逻辑结构示意图如下
  

2.增删改查操作（有头结点）

• 增：
  不考虑编号时:1. 找到链表最后的结点2. 将这个结点的next指向这个新添加的结点

    //添加结点到单向链表
    //思路：当不考虑编号的时候
    //1.找到链表最后的结点
    //2.将这个结点的next指向这个新添加的结点
    public void add(HeroNode heroNode){
        //因为head结点不能动，所以通过一个辅助结点去找到当前链表的最后一个节点
        HeroNode temp = head;
        //通过遍历链表找到链表最后一个节点
        while (true){
            //找到链表的最后一个节点
            if(temp.next == null){
                break;
            }
            temp = temp.next;
        }
        //最后一个节点的next指向新添加的结点
        temp.next = heroNode;
    }

考虑编号时：

//在添加英雄时，根据排名将英雄插入到指定位置
    //如果有这个排名，则添加失败，并给出提示
    public void addByOrder(HeroNode heroNode){
        //因为头结点不能动，所以需要一个辅助变量temp用来找到新结点需要插入的位置
        //temp指向的是待插入结点的前一个位置
        HeroNode temp = head;
        boolean flag = false; //flag标志添加的编号是否存在，默认为false
        while (true){
            if(temp.next == null){ //temp已经是最后一个节点
                break;
            }
            if(temp.next.no > heroNode.no){ //找到新节点要插入的位置
                break;
            }else if(temp.next.no == heroNode.no){//新添加的结点的编号已经存在
                flag = true; //说明编号已经存在
                break;
            }
            temp = temp.next;
        }
       if(flag){
           System.out.println("新节点的编号" + heroNode.no + "已经存在，插入失败");
       }else {
           heroNode.next = temp.next;
           temp.next = heroNode;
        }
    }

• 删：1. head结点不能动，需要一个辅助变量，去找到待删除结点的前一个结点 2. 在比较no时，比较的是temp.next.no 和待删除结点的no

//删除结点
    //思路：
    //1.head结点不能动，需要一个辅助变量，去找到待删除结点的前一个结点
    //2.在比较no时，比较的是temp.next.no 和待删除结点的no
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false; //标记是否找到待删除的结点
        while (true){
            if(temp.next == null){ //temp已经指向链表最后
                break;
            }
            if(temp.next.no == no){ //找到待删除的结点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("没有待删除的结点" + no);
        }
    }

改：

//根据编号no 修改结点的信息
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next == null){
            return;
        }
        //需要一个辅助结点来帮助找到需要修改的结点的位置
        HeroNode temp = head;
        boolean flag = false; //表示是否找到该就结点
        while (true){
            if(temp.next == null){ //已经到链表的最后
                break;
            }
            if(temp.no == newHeroNode.no){ //找到该结点
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if(flag){
            temp.name = newHeroNode.name;
            temp.nikename = newHeroNode.nikename;
        }else {
            System.out.println("编号为"+ newHeroNode.no +"的结点不存在");
        }
    }

• 遍历链表

//遍历链表
    public void list(){
        //因为头结点不能动所以需要一个辅助结点
        HeroNode temp = head;
        //如果当前链表为空，则直接返回
        if(head.next == null){
            System.out.println("链表为空！");
            return;
        }
        //遍历输出链表
        /*while (true){
            //如果已经遍历到最后一个结点则直接退出循环
            if(temp == null){
                break;
            }
            System.out.println(temp.toString());
            //将辅助结点指向下一个结点
            temp = temp.next;
        }*/
        //上面的遍历输出也可以这样写
        while ((temp = temp.next) != null){
            System.out.println(temp.toString());
        }
    }

• 获取单链表结点的个数

 //方法：获得单链表结点的个数（如果是带头结点的单链表，需要不统计头结点）
    public static int getLength(HeroNode head){
        if(head.next == null){ //链表为空
            return 0;
        }
        int length = 0;
        //定义一个辅助变量用于遍历
        HeroNode cur = head.next;
        while (cur != null){
            length ++;
            cur = cur.next;
        }
        return length;
    }

• 查找单链表中的倒数第K个结点

//方法：查找单链表中倒数第K个结点
    //思路：
    //1.编写一个方法，接收头结点head，同时接收一个index（表示是倒数的第K个结点）
    //2.先把遍历链表，得到链表的长度length
    //3.得到size后，在从链表的第一个结点开始遍历（size-index）个，就可以得到单链表的倒数第K个结点
    //4.如果找到了则返回该结点，如果没有则返回null
    public static HeroNode findLastIndexNode(HeroNode head, int index){
        if(head.next == null){ //链表为空
            return null;
        }
        //获取单链表长度
        int size = getLength(head);
        //做index的校验
        if(index <= 0 || index > size){
            return null;
        }
        //定义一个辅助变量
        HeroNode cur = head.next;
        for (int i = 0; i < (size - index); i++) {
            cur = cur.next;
        }
        return cur;
    }

• 将链表进行反转输出（不改变单链表本身）

//将单链表进行反转
    public static void reverseList(HeroNode head){
        //如果当前链表为空或者当前链表只有一个节点则直接返回
        if(head.next == null || head.next.next == null){
            return;
        }
        //定义一个辅助变量 用于遍历单链表
        HeroNode cur = head.next;
        //用于指向当前结点的下一个节点
        HeroNode next = null;
        //重新定义一个头结点，用于存储反转过后的链表信息
        HeroNode reverseHead = new HeroNode(0,"","");
        //遍历原链表，每遍历一个节点，就将其取出并放在reverseHead的最前端
        while (cur != null){
            next = cur.next; //暂存当前结点的下一个节点，后面需要让cur重新指向next 用于遍历原链表
            cur.next = reverseHead.next; //让当前结点的next指向reverseHead的第一个结点
            reverseHead.next = cur; //让reverseHead的头结点指向当前结点
            cur = next; //cur后移
        }
        //将head.next指向已经反转的链表的next
        head.next = reverseHead.next;
    }