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

单链表类：

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

        //创建链表
        SingleLinkedList1 singleLinkedList=new SingleLinkedList1();
        teststack stackDemo=new teststack();
                //加入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);

        //有序加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);


        //删除
        singleLinkedList.del(1);

        //修改
        HeroNode newHeroNode=new HeroNode(2,"小吕","玉麒麟");
        singleLinkedList.update(newHeroNode);

        //统计单链表中的个数
        System.out.println(singleLinkedList.getlength(singleLinkedList.getHead()));

        //测试得到倒数第K个数值
        HeroNode res= singleLinkedList.getNodeK(singleLinkedList.getHead(),5);
        System.out.println(res);

        //链表反转
        singleLinkedList.returnNode(singleLinkedList.getHead());

        System.out.println("-------------------------------------");
        //不改变链表结构反转
        stackDemo.reversePrint(singleLinkedList.getHead());
        System.out.println("-------------------------------------");

        singleLinkedList.list();
    }
}
//定义SingleLinkedList1s
class SingleLinkedList1{
    //初始化头节点，不存放数值
    private HeroNode head = new HeroNode(0,"","");

    public HeroNode getHead() {
        return head;
    }

    //添加节点到单向链表
    public void add(HeroNode heroNode){
        //找到当前链表的最后节点，将这个节点的next指向新的节点
        HeroNode temp = head;
        //遍历链表
        while(true){
            if(temp.next==null) {
                break;
            }
            temp=temp.next;
        }
        temp.next=heroNode;
    }
    //第二种添加，按节点域排序
    public void addByOrder(HeroNode heroNode){
        //因为头节点不能动，仍然需要一个辅助节点
        //因为单链表，因此我们找的temp是位于添加位置的前一个节点，否则插入不了
        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;//后移遍历
        }
        //判断flag值，值为true不添加
        if(flag){
            System.out.printf("准备插入的英雄的编号%d已存在\n",heroNode.no);
        }else{//插入
            heroNode.next=temp.next;
            temp.next=heroNode;
        }

    }

    //删除节点，根据No删除
    public void del(int no){
        //判断是否为空
        HeroNode temp=head;
//        if(head.next==null){
//            System.out.println("链表为空");
//            return;
//        }
        boolean flag=false;//表示是否找到节点
        while(true){
            if(temp.next == null){
                break;//已经遍历完链表
            }
            if(temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断是否找到修改节点
        if(flag){
            temp.next=temp.next.next;
        }else {
            System.out.printf("编号为%d的节点不存在\n",no);
        }
    }

    //修改节点，根据no修改
    //1.根据newHeroNode的no修改
    public void update(HeroNode newHeroNode){
        //判断是否为空
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        //根据No找到需要修改的节点，
        HeroNode temp=head.next;
        boolean flag=false;//表示是否找到节点
        while(true){
            if(temp==null){
                break;//已经遍历完链表
            }
            if(temp.no==newHeroNode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        //根据flag判断是否找到修改节点
        if(flag){
            temp.name=newHeroNode.name;
            temp.nickname=newHeroNode.nickname;
        }else {//没找到
            System.out.printf("没找到编号%d的信息\n",newHeroNode.no);
        }
    }

    //获取链表长度
    public static int getlength(HeroNode head){
        if(head.next==null){
            return 0;
        }else{
            int length=0;
            HeroNode temp = head.next;
            while (temp!=null){
                length++;
                temp=temp.next;
            }
            return length;
        }
    }

    //获取倒数第K个节点
    public HeroNode getNodeK(HeroNode head,int k){
        if(head.next==null){
            return null;
        }
        int index=getlength(head)-k;
        if(k<=0 || k>getlength(head)){
            return null;
        }
        HeroNode cur = head.next;
        while (index!=0){
            cur=cur.next;
            index--;
        }
        return cur;
    }

    public void returnNode(HeroNode head){
        if (head.next==null || head.next.next==null){
            return;
        }
        HeroNode cur=head.next;
        HeroNode next=null;
        HeroNode reverseHead =new HeroNode(0,"","");
        while (cur!=null){
            next=cur.next;//保存当前节点的下一个节点
            cur.next=reverseHead.next;
            reverseHead.next=cur;
            cur=next;//后移
        }
        head.next=reverseHead.next;
    }

    //显示链表【遍历】
    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 = temp.next;
        }
    }
}

//定义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+"]";
    }
}

引用栈类：

import java.util.Stack;

class teststack{

    public void reversePrint(HeroNode head){
        if(head.next==null){
            return;
        }
        //创建栈，压栈
        Stack<HeroNode> stack=new Stack<HeroNode>();
        HeroNode cur=head.next;
        //将链表的所有节点压栈
        while(cur !=null){
            stack.push(cur);
            cur=cur.next;
        }
        while(stack.size()>0){
            System.out.println(stack.pop());
        }
    }
}