链表

public class node {
    public static void main(String[] args) {
        singleLinkedlist s=new singleLinkedlist();
        node a1=new node(1,"doudou","d");
        node a2=new node(2,"guinv","g");
        node a3=new node(3,"zhangyu","z");
        s.add(a1);
        s.add(a2);
        s.add(a3);
        s.list();
        System.out.println("----");
        s.reverse1();
        s.list();



    }
    int no;
    String name;
    String nickname;
    node next;

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

    public node(int no, String name, String nickname){
        this.no=no;
        this.name=name;
        this.nickname=nickname;



    }


    //node head=new node( 0,"","");
    

}
class singleLinkedlist{
    //头节点不存放任何数据
    node head=new node( 0,"","");
    //添加节点到单链表
    //1.找到当前链表的最后节点
    //2.将这个节点的next指向新的节点
    public void add(node n){
        //添加一个辅助节点，因为head节点不能动
        node temp=head;
        while(true){
            //如果下一个节点是空的，那么就找到最后一个节点了。
            if(temp.next==null){
                break;

            }
            //如果不是最后一个节点，就往后移动
            temp=temp.next;
        }
        temp.next=n;

    }
    //遍历
    public void list(){
        if(head.next==null){
            System.out.println("空");
            return;
        }
        node temp=head.next;
        while(true){
            if(temp==null){
                break;
            }
            System.out.println(temp);
            temp=temp.next;
        }
    }
    public void insert(node n){
        node temp=head;
        boolean flag=false;
        while(true){
            if(temp.next==null){
                break;
            }
            if(temp.next.no>n.no){
                break;
            }
            else if(temp.next.no==n.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            System.out.println("有了");

        }
        else{
            n.next=temp.next;
            temp.next=n;
        }
    }
    public void update(node newnode){
        if(head.next==null){
            System.out.println("null");
            return;
        }

        node temp=head.next;
        boolean flag=false;
        while(true){
            if(temp==null){
                break;//遍历结束链表，退出
            }
            if(temp.no==newnode.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.name=newnode.name;
            temp.nickname=newnode.nickname;

        }

    }
    public void delete(int no){
        node temp=head;
        boolean flag=false;
        while(true){
            if(temp.next==null){
                break;
            }
            if(temp.next.no==no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if(flag){
            temp.next=temp.next.next;
        }else{
            System.out.println("cannot find it");
        }

    }
    //求有效节点的个数,既不包括头节点的节点数量
    public int num(){
        node temp=head.next;
        int number=0;
        if(head.next==null){
            return 0;
        }
       while(temp!=null){
           number++;
           temp=temp.next;
       }
       return number;

    }
    //查找链表中的倒数第K个节点
    public void find(int k){
        node temp=head.next;
        int length=num();
        int target=length-k;
        //boolean flag=false;
        System.out.println(target);
        if(temp==null){
            System.out.println("null");
        }
        if(temp.no==target){
           System.out.println(temp.next);
        }



    }
    public void reverse(){
       node cur=head.next;

       node next=null;
       node newnode=new node(0 ,"","");
        if(cur==null||cur.next==null){
            System.out.println("null");
        }
        while(cur!=null){
            next=cur.next;
            cur.next=newnode.next;//当前新拿出的节点指向前一个拿出的节点，右线
            newnode.next=cur;//头节点指向新拿出的节点，左线
            cur=next;//节点向后移动

        }
    }

    public void reverse1(){
       node cur=head.next;
      // node next=null;
        node newnode=new node(0 ,"","");
        if(cur==null||cur.next==null){
            System.out.println("null");
        }
        while(cur!=null){
            newnode.next=cur;
            cur=cur.next;


        }
        head.next=newnode.next;
    }

}



定义node:

public class ListNode {
    // 结点的值
    int val;

    // 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}



删除节点：（若有重复数字的节点用这个，上面那个删除方法只能删除非重复数字的节点）

 public ListNode removeElements(ListNode head, int val) {

        ListNode heads=new ListNode(-1);

        heads.next=head;

        ListNode cur=heads;

        while(true){

            if(cur.next==null){

                break;

            }

            if(cur.next.val==val){

               cur.next=cur.next.next;

            }else{

                cur=cur.next;

            }

            

        }

        return heads.next;

        

    

    

    }