单链表创建、遍历、插入、修改

class HeroNode

package DataStructures.linkedList;

/**
 * @author coffee
 * @date 2021-03-29 17:13
 */
public 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;
        this.nickName = nickName;
    }

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

class singleLinkedList

package DataStructures.linkedList;

import java.util.Stack;

/**
 * @author coffee
 * @date 2021-03-29 17:04
 */
public class singleLinkedList {
    //初始化头节点
    private HeroNode head = new HeroNode(0,"","");

    /**
     * 添加节点到单向链表
     * @param heroNode
     */
    public void add(HeroNode heroNode){
        HeroNode temp = head;
        while (true){
            if (temp.next == null)
                break;
            temp = temp.next;//如果没找到，temp向后移
        }
        //当推出while循环时，表示temp指向了链表的最后
        temp.next = heroNode;
    }

    /**
     * 根据排名将英雄插入到指定位置
     * @param heroNode
     */
    public void addByOrder(HeroNode heroNode){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                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("准备插入的英雄编号已存在");
        }else{
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    /**
     * 显示链表
     */
    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.next;
        }
    }
    /**
     * 修改链表节点的信息
     * 根据编号no来修改，编号no不能改变
     * @param heroNode
     */
    public void update(HeroNode heroNode){
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        HeroNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp == null)
                break;
            if (temp.no == heroNode.no){
                //找到相应的编号
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        }else{
            System.out.println("没有找到");
        }
    }

    /**
     * 需要通过辅助节点找到待删除节点的前一个节点
     * @param n
     */
    public void delete(int n){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no == n){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next = temp.next.next;
        }else {
            System.out.println("未找到需删除节点");
        }
    }

    /**
     * 获取单链表的节点个数（如果是带头结点的链表，需求不统计头节点）
     * @param heroNode
     * @return
     */
    public static int getLength(HeroNode heroNode){
        if (heroNode.next == null){
            return 0;
        }
        int len = 0;
        HeroNode temp = heroNode.next;
        while(temp != null){
            len++;
            temp = temp.next;
        }
        return len;
    }

    /**
     * 查找单链表中的倒数第K个节点【新浪面试题】
     * @param heroNode
     * @param index
     * @return
     */
    public static HeroNode findLastIndexNode(HeroNode heroNode,int index){
        if (heroNode.next == null) {
            return null;
        }
        int size = getLength(heroNode);
        if (index <= 0 || index > size) {
            return null;
        }
        HeroNode temp = heroNode.next;
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    /**
     * 反转单链表
     * 如果当前链表为空，或者只有一个节点，无需反转直接返回
     * 定义一个辅助变量，用来遍历原来的链表
     * 定义一个变量来指向当前节点的下一个节点
     * 定义一个反转节点头
     * 遍历原来的链表，每遍历一个节点，就将其取出
     * 并放在新的链表reverseHead的最前端
     * @param head
     */
    public  static  void  reverseList(HeroNode head){
        if (head.next == null || head.next.next == null){
            return;
        }

        HeroNode temp = head.next;
        HeroNode next = null;
        HeroNode reverseHead = new HeroNode(0, "", "");

        while (temp != null){
            next = temp.next;//取出当前节点的下一个节点
            temp.next = reverseHead.next;//将当前节点的下一个节点指向新链表的最前端
            reverseHead.next = temp;//将新链表头节点指向最新的遍历出来的节点
            temp = next;//将下一个节点赋值给此指针用来遍历
        }
        head.next = reverseHead.next;//将新的头节点赋给旧的头节点，实现反转
    }

    /**
     * 从尾到头打印单链表 方式1：反向遍历  2：stack栈
     * @param head
     */
    public static void reversePrint(HeroNode head){
        if (head.next == null){
            return;
        }
        Stack<HeroNode> stack = new Stack<>();
        HeroNode temp = head.next;
        while (temp != null){
            stack.push(temp);
            temp = temp.next;
        }
        while (stack.size() > 0){
            System.out.println(stack.pop());
        }
    }

    /**
     * 合并两个有序的单链表，合并之后的链表依然有序
     * @param heroNode1
     * @param heroNode2
     */
    public static void linkedListTogether(HeroNode heroNode1,HeroNode heroNode2){

    }
}