java模拟单链表

package com.xdt.linkedlist;

import java.util.Stack;

public class SingLeLinkedListDemo {
    public static void main(String[] args) {
        HeroNode head1 = new HeroNode(1, "小明", "打篮球");
        HeroNode head2 = new HeroNode(2, "小红", "听音乐");
        HeroNode head3 = new HeroNode(3, "小绿", "网易云");
        HeroNode head4 = new HeroNode(4, "小样", "坐飞机");
        SingLeLinkedList link = new SingLeLinkedList();
        link.add(head1);
        link.add(head2);
        link.add(head4);
        link.add(head3);

        link.list();
        System.out.println("link的节点的个数为：" + link.getLength(link.getHead()));
        System.out.println("反转后的结果：");
        link.linkTurnOver(link.getHead());
        link.list();
        System.out.println();
        System.out.println("下面使用addByOrder来添加");
        System.out.println();
        SingLeLinkedList link2 = new SingLeLinkedList();
        link2.addByOrder(head1);
        link2.addByOrder(head2);
        link2.addByOrder(head4);
        link2.addByOrder(head4);
        link2.addByOrder(head3);
        HeroNode head5 = new HeroNode(4, "小样", "我就是小样");
        link2.update(head5);
//        link2.delete(3);
        link2.list();
        System.out.println("link2的节点的个数为：" + link2.getLength(link2.getHead()));
        System.out.println("倒数第二个是："+link2.findLastIndexNode(link2.getHead(), 2));
        System.out.println("反向打印后的结果是:");
        link2.printLinkTurnOver(link2.getHead());
    }
}

///定义 singleLinkedList管理我们的英雄
class SingLeLinkedList {
    //先初始化一个头节点,头节点不要动
    private HeroNode head = new HeroNode(0, "", "");

    public HeroNode getHead() {
        return head;
    }

    //添加节点到单向链表
    //思路,当不考虑编号顺序时
    //1.找到当前链表的最后节点
    //2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode) {
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                break;
            }
            //后移一位
            temp = temp.next;
        }
        //当退出whi1e循环时,temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }

    //第二种方式在添加人物时,根据排名将人物插入到指定位置
    public void addByOrder(HeroNode heroNode) {
        //辅助用
        HeroNode temp = head;
        //判断是否存在，默认false不存在
        boolean flag = false;
        while (true) {
            if (temp.next == null) {
                break;//到最后了
            } else if (temp.next.no == heroNode.no) {
                flag = true;
                break;//编号存在
            } else if (temp.next.no > heroNode.no) {
                //要插入的位置找到了
                break;
            }
            temp = temp.next;//如果都没找到，继续下一个
        }
        if (flag) {
            System.out.println("你要插入的" + heroNode.no + "编号  " + heroNode.name + "  已经存在了！");
        } else {
            heroNode.next = temp.next;//当前节点的位置指向下一个节点的位置。用于连接
            temp.next = 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.no == heroNode.no) {
                //找到了
                flag = true;
                break;
            }
            if (temp.next == null) {
                //没找到
                break;
            }
            temp = temp.next;//否则就继续找下一个
        }
        if (flag) {//找到了
            temp.no = heroNode.no;
            temp.name = heroNode.name;
            temp.nickname = heroNode.nickname;
        } else {
            System.out.println("没有" + heroNode.no + "号节点,无法修改");
        }
    }

    //删除
    public void delete(int no) {
        if (head.next == null) {
            //节点一个元素都没有
            return;
        }
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                //没找到
                System.out.println("没找到" + no + "号数据！");
                break;
            }

            if (temp.next.no == no) {
                //找到了,下一个就是
                temp.next = temp.next.next;
                System.out.println("删除成功！！！");
                break;
            }
            temp = temp.next;
        }
    }

    //查询
    public void list() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //因为头节点,不能动,因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true) {
            //输出节点信息
            System.out.println(temp);
            if (temp.next == null) {
                break;
            }
            //后移一位
            temp = temp.next;
        }
    }


    /**
     * @param heroNode 节点的头
     * @return 节点个数
     */
    //获取单链表的节点个数
    public int getLength(HeroNode heroNode) {
        int length = 0;
        if (head.next == null) {
            return length;
        }
        HeroNode temp = head.next;
        while (temp != null) {
            length++;
            temp = temp.next;
        }
        return length;
    }

    //编写一个方法接受倒数第k个节点
    public HeroNode findLastIndexNode(HeroNode head, int k) {
        if (head.next == null) {
            return null;
        }
        int size = getLength(head);
        if (k <= 0 || k > size) {
            return null;//不合法
        }
        size=size-k;
        HeroNode temp=head.next;
        if (size==0){
            return temp;
        }
        for (int i = 0; i < size; i++) {
            temp=temp.next;
        }
        return temp;
    }
    //单链表的反转
    public void linkTurnOver(HeroNode heroNode){
        if (heroNode.next==null|| heroNode.next.next==null){
            return ;
        }
        HeroNode cur=heroNode.next;
        HeroNode next=null;//指向当前节点的下一个节点
        HeroNode linkTurnOver=new HeroNode(0,"","");
        while (cur!=null){
            next=cur.next;//保存下一个节点
            cur.next=linkTurnOver.next;//连接到最前端
            linkTurnOver.next=cur;//连接到新的链表上
            cur=next;
        }
        heroNode.next=linkTurnOver.next;
    }
    //不破坏原始数据反向打印数据
    public void printLinkTurnOver(HeroNode heroNode){
        if (heroNode.next==null) {
            return;
        }
        Stack<HeroNode> stack = new Stack<HeroNode>();
        HeroNode temp=heroNode.next;
        while (temp!=null){
            stack.push(temp);
            temp=temp.next;
        }
        while (stack.size()>0){
            System.out.println(stack.pop());//pop出栈
        }
    }
}

//定义 HeroNode,每个 HeroNode对象就是一个节点
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 + '\'' +
                '}';
    }
}