单链表结构经典习题

定义一个链表

        private T data; //数据域名
        private Node<T> next; //next引用域

        public Node(T data){
   
            this.data = data;
        }
        public void setNext(Node<T> next){
   
            this.next = next;
        }
       public void setData(T data) {
   
            this.data = data;
        }
        public T getData() {
   
            return data;
        }
        public Node<T> getNext() {
   
            return next;
        }

1.尾插法

public void addTail(T value){
   
        //尾插法
        Node<T> newNode = new Node(value);
        if(head == null){
   
            //特殊情况下，当前链表是一个空链表，不存在任何节点
            head = newNode;
        }else{
   
            //正常情况下
            Node<T> tmp = head;
            //tmp指向当前链表的最后一个节点
            while(tmp.next != null){
   
                tmp = tmp.next;
            }
            //tmp.next == null跳出while循环 指向最后一个节点
            tmp.next = newNode;
        }
    }

2.头插法

public void addHead(T value){
   
        //在head之后添加一个新节点
        Node<T> newNode = new Node(value);
        if(head == null){
   
            head = newNode;
        }else{
   
            newNode.next = head.next;
            head.next = newNode;
        }
    }

3.添加一个新节点到指定位置

   public boolean addPos(T value, int pos){
   
        //new一个新节点 pos-1的节点 在pos-1位置之后链上当前的newNod
        Node<T> newNode = new Node(value);
        if(pos < 0 || pos >= getLength()){
   
            return false;
        }
        if(pos == 0){
   
            newNode.next = head;
            head = newNode;
            return true;
        }
        //pos-1位置的节点
        Node<T> tmp = head;
        for(int i=0; i<=pos -1; i++){
   
            tmp = tmp.next;
        }
        //i>pos- 1 tmp刚好指向pos-1位置的节点
        newNode.next = tmp.next;
        tmp.next = newNode;
        return true;
    }

4.删除某个中间指定节点

 public boolean remove(T value){
   
        //利用equals方法判断是否为头节点
        if(head.data.equals(value)){
   
            head = head.next;
            return true;
        }
        //删除中间某一个节点
        //要保存删除节点之前的节点和删除节点之后的节点
        Node<T> tmp = head;
        while(tmp.next != null){
   
            if(tmp.next.data.equals(value)){
   
                //说明tmp.next为所要删除的节点
                //tmp是删除节点之前的节点
                //tmp.next.next是删除节点之后的节点
                tmp.next = tmp.next.next;
                return true;
            }
            tmp = tmp.next;
        }
        return false;
    }

5.找到中间某个指定节点

 public T findNode(int index){
   
        //根据index找到index所对应的节点的data域
        // 合法性判断index不能小于0, index不能大于节点个数
        if(index < 0 || index >= getLength()){
   
            return null;
        }
        Node<T> tmp = head;
        //遍历找到index点
        for(int i=0; i<index; i++){
   
            tmp = tmp.next;
        }
        //返回index点所对应的data域
        return tmp.data;
    }

6.找出链表长度

 public int getLength(){
   
        //给定一个数纪录链表长度
        int length = 0;
        Node<T> tmp = head;
        //循环直到结尾，每次循环对应的length加一
        while(tmp != null){
   
            length++;
            tmp = tmp.next;
        }
        return length;
    }

7.查找单链表中倒数第k个节点

 public static <T> MySingleList<T>.Node<T> findKNode(MySingleList