数据结构-单链表增删改查实现

单链表概念：
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
单链表的结构：

模拟代码实现：
1）创建实体类：Hero

public class Hero {
    private int number;
    private String name;
    private String nickName;
    //节点下一节点
    public Hero next;

    public Hero(int number, String name, String nickName) {
        this.number = number;
        this.name = name;
        this.nickName = nickName;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    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;
    }

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

2）创建 链表实体类

package datastructure;


/**
 * 链表
 *
 * @author 张润东
 * @date 20191211
 * @since v1.0
 */
public class HeroLinkedList {
    //初始化链表头指针
    private Hero head=new Hero(0,"","");
    //添加数据到尾部
    public void addToTail(Hero hero){
        //思路：找到链表的最后一个节点，将最后一个节点的next 设置为hero
        Hero temp = head;
        while (true){
            if(temp.next == null){
                //最后一个节点
                break;
            }
            temp = temp.next;
        }
        temp.next = hero;
    }
    //列表
    public void list(){
        Hero temp = head.next;
        while (true){
            if(temp.next == null){
                System.out.println(temp);
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }

    //按顺序添加数据
    public void addByNum(Hero hero){
        /**思路：循环链表，找到待插入的前一个节点，
         * 将前一节点preNode的next指向hero,将hero的next指向preNode的next.
         */
        Hero temp = head;
        boolean flag = false;
        while(true){
            if(temp.next == null){
                //链表最后一个元素
                break;
            }
            if(temp.next.getNumber()>hero.getNumber()){
               //找到链表的插入位置
                break;
            }else if(temp.next.getNumber() == hero.getNumber()){
                //已经存在
                flag = true;
                break;
            }
            //指针后移
            temp = temp.next;
        }
        //插入
        if(flag){
            System.out.println("待添加数据编号已经存在");
            return;
        }
        hero.next = temp.next;
        temp.next = hero;
    }

    //修改
    public void update(Hero hero){
        //思路：使用指针循环遍历链表，找到需要更改的前一节点修改
        Hero temp = head;
        boolean flag = true;
        while (true){
            //需判断是否是最后一个节点,没找到退出
            if(temp.next == null && temp.next.getNumber() != hero.getNumber()){
                flag = false;
                break;
            }
            if(temp.next.getNumber() == hero.getNumber()){
                //找到待修改节点
                break;
            }
            //指针后移
            temp = temp.next;
        }
        if(!flag){
            System.out.println("修改节点不存在");
            return;
        }
        //修改
        temp.next.setName(hero.getName());
        temp.next.setNickName(hero.getNickName());
    }
    //删除节点
    public void del(Hero hero){
        //思路：找到待删除节点的前一节点preNode,
        // 将preNode 的next 指向 hero 的next,待删除的数据就会被GC回收
        Hero temp = head;
        boolean flag = true;
        while (true){
            if(temp.next == null && temp.next.getNumber() != hero.getNumber()){
                //没找到需要删除的数据
                flag = false;
                break;
            }
            if(temp.next.getNumber() == hero.getNumber()){
                //找到待修改节点
                break;
            }
            temp = temp.next;
        }

        //删除
        temp.next = temp.next.next;
    }
    //求单链表中节点的个数
    public int size() {
        //链表长度
        int size = 0;
        Hero temp = head;
        while (true) {
            if (temp.next == null) {
                //最后一个
                break;
            }
            size++;
            temp = temp.next;
        }
        return size;
    }

    //查找单链表中指定index的节点
    public Hero getNodeByIndex(int index) {
        int size = size();
        if (index > size) {
            throw new RuntimeException("下标越界");
        }
        Hero temp = head;
        //这种处理方式不是很好~~~~~~
        Map<Integer, Hero> map = new HashMap<>();
        int increment = 1;
        while (true) {
            if (temp.next == null) {
                break;
            }
            map.put(increment, temp.next);
            temp = temp.next;
            increment++;
        }
        Hero hero = map.get(index);
        return hero;
    }

    //单链表的反转 ~~~~~有问题
    public void reverse() {
        //思路：循环遍历链表，每取出一个将其放在头部位置
        Hero temp = head;
        Hero reverse = new Hero(0, "", "");
        //表示当前节点的下一个节点
        Hero next = null;
        if (temp.next == null || temp.next.next == null) {
            //空链表和只有一个值
            return;
        }
        while (true) {
            if (temp.next ==null){
                break;
            }
            //取出链表值
            reverse.next = temp.next;
            reverse.next.next = next;
            next = temp.next;
            //指针后移
            temp = temp.next;
        }
        temp.next = reverse.next;
    }

    //从尾到头打印单链表，要求方式一:反向遍历（先反转，在遍历，缺点：破坏了链表原有结构），
    // 方式二：stack栈（使用栈先进先出的原理）
    public void reverseList() {
        Hero temp = head;
        Stack<Hero> stack = new Stack<>();
        while (true){
            if(temp.next == null){
                break;
            }
            stack.push(temp.next);
            temp = temp.next;
        }
        //打印
        while(stack.size()>0){
            System.out.println(stack.pop());
        }
    }
    //合并两个单链表，合并之后依然有序~~~暂时没得思路，后面有时间在处理
}