package jiegou;

import com.sun.corba.se.spi.protocol.RequestDispatcherDefault;
import sun.tools.tree.ThisExpression;

import java.util.List;
import java.util.Stack;

// 单链表
public class SingleLinkDemo {
    public static void main(String[] args) {
        HeroNode heroNode1 = new HeroNode(1, "松江", "及时雨");
        HeroNode heroNode2 = new HeroNode(2, "吴用", "智多星");
        HeroNode heroNode3 = new HeroNode(3, "林冲", "豹子头");

        SingleLinkList linkList = new SingleLinkList();


        linkList.addByOrder(heroNode3);
        linkList.addByOrder(heroNode2);
        linkList.addByOrder(heroNode1);

//        HeroNode heroNode4 = new HeroNode(3, "林冲", "豹子头tou");
//
//        linkList.editNode(heroNode4);

        // 删除节点
        //linkList.list();

//        System.out.println("删除节点后");
//        linkList.delete(heroNode1);
//        linkList.delete(heroNode2);
//        System.out.println("翻转之前");
//        linkList.list();

//        int numbers = getNodes(linkList.getHead());
//        System.out.println(numbers);
//
//        HeroNode lastNode = findLastNode(linkList.getHead(), 4);
//        System.out.println(lastNode);

        // 链表翻转
//        reverseList(linkList.getHead());
//        System.out.println("翻转后的链表");
//        linkList.list();

        System.out.println("之前");
        linkList.list();

        reversePrint(linkList.getHead());
    }

    public static void reversePrint(HeroNode head)
    {
        if(head.next == null){
            System.out.println("空链表");
            return ;
        }

        HeroNode temp = head.next;
        Stack<HeroNode> stack = new Stack<>();

        while(temp != null) {
            stack.push(temp); // 压栈
            temp = temp.next;
        }

        System.out.println("逆序打印");
        while(stack.size() >0) {
            System.out.println(stack.pop());
        }

    }

    // 查找单链表中的倒数第 k个节点
    // 接受 head index 倒数第 index个节点
    // 先把链表从头到尾遍历 得到总数 从第一个开始遍历 size-index

    public static HeroNode findLastNode(HeroNode head,int index)
    {
        if(head.next == null) {
            return head;
        }

        int sum = getNodes(head); // 总数
        if(index <=0 || index > sum){
            return null;
        }

        HeroNode temp = head.next;

        for(int i=0;i<sum-index;i++){
            temp =temp.next;
        }

        return temp;
    }

    // 求单链表有效节点个数
    public static int getNodes(HeroNode head) {
        int sum = 0;
        if (head.next == null) {
            return 0;
        }
        HeroNode node = head.next;
        while (node != null) {
            System.out.println(node.name);
            sum++;
            node = node.next;
        }

        return sum;
    }

    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;
            // 相当于 reverhead 与 reverhaed.next中间要插入一个节点 新节点
            // 的 next
            temp.next = reverseHead.next;// 将 temp 的下一个节点指向新的最前端
            reverseHead.next = temp;
            temp = next;// 相当于以前的 temp =temp.next
        }

        head.next = reverseHead.next;

    }
}

// 链表管理节点
class SingleLinkList {
    public HeroNode getHead() {
        return head;
    }

    // 初始化一个头节点
    private HeroNode head = new HeroNode(0, "", "");


    // 添加节点到单向链表
    public void add(HeroNode heroNode) {
        // 找到链表最后
        //将最后节点的 next 指向这个新节点
        HeroNode temp = head;
        //遍历链表
        while (true) {
            // 当 temp.next== null
            if (temp.next == null) {
                break;
            }

            // 没有找到最后  temp 后移
            temp = temp.next;
        }

        temp.next = heroNode;
    }

    // 编号不能改
    public void editNode(HeroNode heroNode) {
        if (this.head.next == null) {
            return;
        }
        HeroNode temp = head.next;
        Boolean flag = false;
        while (true) {
            if (temp == null) {
                flag = false;
                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.printf("未找到编号=%d的节点\n", heroNode.no);
        }

    }

    public void delete(HeroNode heroNode) {
        if (this.head.next == null) {
            System.out.println("没有节点");
            return;
        }


        HeroNode temp = head;
        boolean flag = false;

        while (true) {

            if (temp.next == null) { // 找到最后都没找到
                break;
            }

            if (temp.next.no == heroNode.no) { // 找到的是要删除的前一个节点
                flag = true;
                break;
            }

            temp = temp.next; // 后移
        }

        if (flag) {
            temp.next = heroNode.next;// 跨过要删除的
        }

    }


    // 按顺序添加节点  如果有排名 添加失败
    public void addByOrder(HeroNode heroNode) {
        // 头结点不能动
        // 因为是单链表 temp是位于添加位置的前一个节点 否则插入不了
        HeroNode temp = head;
        boolean flag = false; // 标识添加的编号是否存在 默认 false

        while (true) {
            if (temp.next == null) {
                // 链表结尾
                break;
            }

            if (temp.next.no > heroNode.no) // 在 temp 后面插入
            {
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;// 编号存在
                break;
            }

            temp = temp.next; // 后移 直到找到
        }

        //temp 就是在他后面添加
        if (flag) {
            System.out.printf("编号%d存在\n", heroNode.no);
        } 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;
        }
    }


}

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

    // 构造方法
    public HeroNode(int hNo, String HName, String HNickName) {
        this.no = hNo;
        this.name = HName;
        this.nickname = HNickName;
    }

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

}