单链表的各种操作实现

废话不多说直接上代码
主函数测试代码：

public static  void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        //先创建节点
        HeroNode hero1=new HeroNode(1,"宋江","及时雨");
        HeroNode hero2=new HeroNode(2,"卢俊义","玉麒麟");
        HeroNode hero3=new HeroNode(4,"吴用","智多星");
        HeroNode hero4=new HeroNode(7,"林冲","豹子头");

        //创建要给链表
        SingleLinkedList singleLinkedList=new SingleLinkedList();
        //添加数据
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        //显示
        System.out.println("第一个单链表的内容为:");
        singleLinkedList.list(singleLinkedList.getHead());
        //测试修改节点的代码
//        HeroNode heroNode=new HeroNode(2,"小卢","玉麒麟~~");
//        singleLinkedList.updataData(heroNode);
//        //显示
//        System.out.println("修改后的链表为：");
//        System.out.println("head:");
//        singleLinkedList.list();
//        //测试删除信息
//        singleLinkedList.deleteData(1);
//        //显示
//        System.out.println("删除后的链表为：");
//        singleLinkedList.list();
//        //测试顺序添加数据
//        HeroNode hero6=new HeroNode(9,"花花","小花");
//        singleLinkedList.orderAdd(hero6);
//        System.out.println("顺序添加数据后的链表为：");
//        singleLinkedList.list();
//        //链表的有效长度
//        int n=singleLinkedList.sum(singleLinkedList.getHead());
//        System.out.printf("该链表内的有效个数为：%d\n",n);
//        //查找单链表中的倒数第k个节点
//        System.out.println(singleLinkedList.kNode(singleLinkedList.getHead(),0));
        //测试单链表的反转
//        System.out.println("以下为单链表的反转后的链表：");
//        singleLinkedList.reverseNode(singleLinkedList.getHead());
        //测试从尾到头打印单链表[百度  要求：方式一：反向遍历；方式二：stack栈]
        /**
         * 思路：一：先反转再打印（破坏了原来的链表，不建议）
         * 二：使用栈
         */
//        System.out.println("从尾到头打印单链表的内容为：");
//        singleLinkedList.reverseprintNode(singleLinkedList.getHead());
//        System.out.println("链表内容为：");
//        singleLinkedList.list();
        /*
        合并两个有序的单链表，合并之后的链表依然有序
         */
        SingleLinkedList singleLinkedList1=new SingleLinkedList();
        HeroNode hero5=new HeroNode(3,"林梅","小林");
        HeroNode hero6=new HeroNode(4,"赵健","小赵");
        HeroNode hero7=new HeroNode(8,"张三","小张");
        HeroNode hero8=new HeroNode(10,"刘志","小刘");
        singleLinkedList1.add(hero5);
        singleLinkedList1.add(hero6);
        singleLinkedList1.add(hero7);
        singleLinkedList1.add(hero8);
        System.out.println("第二个单链表的内容为：");
        singleLinkedList1.list(singleLinkedList1.getHead());
        System.out.println("两个链表合并后的结果为：");
        singleLinkedList.mergeNode(singleLinkedList.getHead(),singleLinkedList1.getHead());

    }

单链表类：

//定义SingleLinkedList管理我们的英雄
class SingleLinkedList{
    //先初始化一个头节点，头节点不能动，不存放具体的数据
    private HeroNode head=new HeroNode(0,"","");

    public HeroNode getHead() {
        return head;
    }

    public void setHead(HeroNode head) {
        this.head = head;
    }
    //1.合并两个有序链表
    public void mergeNode(HeroNode head1,HeroNode head2){
        HeroNode temp1=head1.next;
        HeroNode temp2=head2;
        while(true){
            if(temp1==null){
                break;
            }else{
                if(temp1.no<temp2.next.no){
                    HeroNode temp0=temp1.next;
                    temp1.next=temp2.next;
                    temp2.next=temp1;
                    temp2=temp2.next;
                    temp1=temp0;
                }else{
                    if(temp2.next.next==null){
                        temp2.next.next=temp1;
                        break;
                    }else{
                        temp2=temp2.next;
                    }
                }
            }

        }
        list(head2);
    }
    //2.从尾到头打印单链表
    public void reverseprintNode(HeroNode head){
        if(head.next==null){
            return;
        }
        HeroNode temp=head.next;
        Stack<HeroNode> stack=new Stack<>();
        while (temp!=null){
            stack.push(temp);
            temp=temp.next;
        }
        while (!stack.empty()){
            System.out.println(stack.pop());
        }
    }
    //3.单链表的反转

    /**
     * 思路：新建一个链表 遍历现在的链表每拿到一个现在链表的一个节点添加到新链表的前一个
     * @param head
     */
    public void reverseNode(HeroNode head){
        if(head.next==null||head.next.next==null){
            return;
        }
        HeroNode temp=head.next;
        SingleLinkedList linkedList=new SingleLinkedList();
        head.next=null;
        while (temp!=null){
            HeroNode temp2=temp.next;
            temp.next=head.next;
            head.next=temp;
            temp=temp2;
        }
        linkedList.add(head.next);
        linkedList.list(head);
    }

    //4.头部后面添加数据
    public void headAdd(HeroNode node){
        HeroNode temp=head.next;
        head.next=node;
        head.next.next=temp;

    }
    //5.查找单链表中的倒数第k个节点
    public HeroNode kNode(HeroNode head,int k){
        int n=sum(head);
        HeroNode temp=head;
        int length=0;
        if (temp.next==null){
            return null;
        }
        if(k>n&&k<1){
            System.out.println("请输入有效数据！");
            return null;
        }
        while(length!=(n-k+1)){
            temp=temp.next;
            length++;
        }
        System.out.printf("单链表中的倒数第%d个节点为：",k);
        return temp;
    }
    //6.查找链表当中有效个数
    public int sum(HeroNode head){
        HeroNode temp=head;
        int n=0;
        while(temp.next!=null){
            n+=1;
            temp=temp.next;
        }
        return n;
    }
    /**
     * 7.添加节点到单向链表
     * 思路：当不考虑编号顺序时
     * 1.找到当前链表的最后节点
     * 2.将最后这个节点的next指向新的节点
     */
    public void add(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp=head;
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if(temp.next==null){
                break;
            }
            //如果没有找到最后,就将temp后移
            temp=temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next=heroNode;
    }
    //8.按照顺序添加数据
    public void orderAdd(HeroNode heroNode){
        HeroNode temp=head;
        boolean flag=false;
        while(true){
            if (temp.next==null){
                temp.next=heroNode;
                break;
            }
            if (temp.next.no>heroNode.no){
                flag=true;
                heroNode.next=temp.next;
                temp.next=heroNode;
                break;
            }
            if (temp.next.no==heroNode.no){
                System.out.println("已存在该编号的数据，不可重复添加");
                break;
            }
            temp=temp.next;
        }

    }

    //9.显示链表【遍历】
    public void list(HeroNode head){
        //判断链表是否为空
        if (head.next==null){
            System.out.println("链表为空");
            return;
        }
       // System.out.println("head:"+head);
        //因为头节点不能动，因此我们需要一个辅助变量来遍历
        HeroNode temp=head.next;
        while (true){
            //判断是否到链表最后
            if (temp==null){
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将next后移
            temp=temp.next;
        }
    }

    //10.更新链表，找到需要修改的节点，根据no编写
    //定义一个中间变量
    public void updataData(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.printf("没有找到编号为%d的节点，不能修改\n",heroNode.no);
        }
    }
//11.删除节点
    public void deleteData(int no){
        if (head.next==null){
            System.out.println("链表为空，无法进行删除数据");
            return;
        }
        //第一种方式使用两个临时变量
//        HeroNode temp=head;
//        HeroNode temp1=temp.next;
//        boolean flag=false;
//
//        while(true){
//            if (temp1.no==no){
//                if (temp1.next==null){
//                    temp.next=null;
//                }else{
//                    temp.next=temp1.next;
//                }
//                flag=true;
//                break;
//            }
//            if (temp1.next==null){
//                break;
//            }
//            temp=temp1;
//            temp1=temp1.next;
//        }
//        if (flag) System.out.println("已经删除啦");
//        else System.out.println("没有找到要删除的信息");
//    }
//第二种方式：只是用一个临时变量
        HeroNode temp=head;
        while(true){
            if(temp.next!=null){
                if(temp.next.no==no){
                    temp.next=temp.next.next;
                    System.out.println("已经删除啦");
                    break;
                }
                temp=temp.next;
            }else {
                System.out.println("未找到要删除的信息，无法完成删除功能");
                break;
            }

        }

        }
}

实体类：

//定义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;
    }
//为了显示方法，我们重新toString
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                ", nickname='" + nickname +
                "'}";
    }
}

结果图:
只放一个合并的吧，其他自己运行即可。