单向链表之增删改查

单项链表实现增删改啥

思路分析：

该算法的核心在于对链表的数据操控，借助指针，实现对数据的增删改啥，其实是next地址的修改

因为是单向链表，所以进行操作时候，辅助节点（指针）必须位于要操作元素的前一个节点（遍历可以是每个元素的本身）

1.带头节点的单向链表，元素节点分为data域和next域，将next域指向下一个节点的地址

2.创建指针temp，通过指针移动来读取各个节点的元素

3.添加，更新，删除，查看的逻辑，指针的向后移动来进行增删改查

1.新增

        1.不做逻辑判断，向末尾添加      

public void addHero(HeroNode heroNode){
    //创建辅助节点
    HeroNode temp;
    temp = head;
    while (true){
        //因为这是单向链表，所以添加的时候，temp需要指到要添加数据的前一个节点
        if (temp.next == null){
            break;
        }
        temp = temp.next;
    }
    temp.next = heroNode;
}

        2.根据顺序，向元素添加

        空链表，直接追加到头节点后面

        该no大于链表任何数据，追加到最后

        找到大于该no的元素，然后将该数据next域指向大于该域的地址，temp的next域指向该元素

/*
* 按顺序添加元素
* */
public void addBiraryHero(HeroNode heroNode){
    HeroNode temp;
    temp = head;
    boolean flag = false;
    while (true) {
        if (temp.next == null) {
            temp.next = heroNode;
            break;
        }
        if (temp.next.no > heroNode.no) {
            flag = true;
            break;
        } else if (temp.next.no == heroNode.no) {
            System.out.println("该no以存在，添加失败");
            flag = false;
            break;
        }
        temp = temp.next;
    }
    if (flag) {
        heroNode.next = temp.next;
        temp.next = heroNode;
    }
}

2.遍历

/*
* 遍历添加的数据
* */
public void showHero(){
    //遍历的时候，直接绕过头节点，指向要遍历的节点
    HeroNode temp = head.next;
    while (true){
        if (head.next == null) {
            System.out.println("该链表为空");
            break;
        }
        if (temp == null){
            break;
        }
        System.out.println(temp);
        temp = temp.next;
    }
}

3.更新

public void updateHero(HeroNode heroNode){
    HeroNode temp = head;
    boolean flag = false;
    while (true){
        //1.先判断头节点，如果head.next == null 则该链表为空
        if (head.next == null){
            System.out.println("该链表为空！");
            break;
        }
        //2.判断temp指针是否到了结尾，如果到了结尾，该元素不存在
        if (temp.next == null){
            System.out.println("更新元素不存在");
            break;
        }
        //3.判断链表中的元素是否是要更新的元素
        if (temp.next.no == heroNode.no){
            flag = true;
            break;
        }
        // 4.如果不是，指针后移
        temp = temp.next;
    }
    if (flag){
        HeroNode temp1 = temp.next.next;
        temp.next = heroNode;
        heroNode.next = temp1;

    }
}

4.删除

        删除的思路是断开元素连接，让该元素的前一个元素和后一个元素直接连接在一起

public void deleteHero(int no){
    HeroNode temp = head;
    boolean flag = false;
    while (true){
        //1.先判断头节点，如果head.next == null 则该链表为空
        if (head.next == null){
            System.out.println("该链表为空！");
            break;
        }
        //2.判断temp指针是否到了结尾，如果到了结尾，该元素不存在
        if (temp.next == null){
            System.out.println("删除元素不存在");
            break;
        }
        //3.判断链表中的元素是否是要删除的元素
        if (temp.next.no == no){
            //如何相当，则把flag置为true
            flag = true;
            break;
        }
        // 4.如果不是，指针后移
        temp = temp.next;
    }
    if (flag){
        temp.next = temp.next.next;
    }

}

 思路：采用正序遍历原来链表，然后采用头插法将元素依次插入，最后修改头节点为原来头节点。注意，要将最后一个元素的的next域清空，即正序第一个元素的next域清空为null

/*
* 反转输出
* */
public void reverseHero() throws InterruptedException {
    HeroNode temp = head.next;
    HeroNode temp1;
    HeroNode reverseNode = new HeroNode(0,"","");
    while (true){

        if (temp == null){
            break;
        }
        temp1 = temp;
        temp = temp.next;


        if (reverseNode.next == null){
            reverseNode.next = temp1 ;
            reverseNode.next.next = null;

        }else {
            temp1.next= reverseNode.next;
            reverseNode.next = temp1;

        }


    }
    showHero1(reverseNode);

}