在单链表中删除倒数第k个节点

实现方式不少，在这里只说两种实现方式。看不懂时候，你们能够画画图，对理解为何颇有帮助。
第一种方式：
1.首先判断K值和链表是否为空，若是k<=0,或链表为空，直接返回head；
2.知足上面条件后，定义ListNode P=head，重头开始遍历链表，走k步后，退出循环(在此循环中，若是没到k，p就为null了，说明没有倒数第K个节点，k大于表长度了，直接返回head)。
3.定义ListNode q = head，与p同步向后走，直到p的next为空时候，节点为要删除节点的前一个结点。

第二种方式：
1.首先判断K值和链表是否为空，若是k<=0,或链表为空，直接返回head；
2.遍历一遍链表，每走一步，让k值减1.

3.遍历完后，若是k大于零，说明k大于链表长度，直接返回head；若是k等于0，要删除的节点就是头结点，直接返回head.next;若是k小于0的时候就第4步。
4.定义q=head，重新遍历节点，每走一步k加1，直到k=0时候，退出循环，此时q的下一个节点就是要删除的节点。

（4.解析：在这部分，为何这样作，可能不是很容易理解，给你们举个例子，假如如今有一链表有8个节点，k=3.那么，前三步后，k=-5。你们 想想，k等于三是要删除倒数第3个节点，咱们只要从头走5步就能够到达删除节点的前一个节点了，为啥是5，由于8 = 3+5。

 

package cglib;
import java.util.Hashtable;  

 

public class StringNumber {
    // 2.在单链表中删除倒数第k个节点(方法一)
    public static ListNode removeLastKthNode(ListNode head, int k) {
        if (k <= 0 || head == null)
            return head;
        ListNode p = head;
        for (int i = 0; i < k; i++) {
            if (p.nextNode != null)
                p = p.nextNode;
            else
                return head;
        }
        ListNode q = head;
        while (p.nextNode != null) {
            p = p.nextNode;
            q = q.nextNode;
        }
        q.nextNode = q.nextNode.nextNode;
        return head;
    }

    // 2.在单链表中删除倒数第k个节点(方法二)
    public static ListNode removeLastKthNode2(ListNode
    head, int k) {
        if(k <= 0 ||head == null)return head;
        ListNode p = head;
        while(p!=null){
            p = p.nextNode;
            k--;
        }
        if(k==0)return head.nextNode;
        if(k<0){
            ListNode q = head;
            while(++k!=0){ //这里注意，先自加，再判断
                q=q.nextNode;
            }
            q.nextNode=q.nextNode.nextNode;
        }
        return head;
    }
    // 建立链表
    public static ListNode creatListNode(int data[]) {
        ListNode head = new ListNode (data[0]);
        ListNode temp = head;
        for (int i = 1; i < data.length; i++) {
            ListNode headNext = new ListNode(data[i]);
            temp.nextNode = headNext;
            temp = temp.nextNode;
        }
        return head;
    }

    // 测试
    public static void main(String[] args) {
        int[] data1 = { 1, 2, 4, 5, 6, 7 };
        ListNode head1 = creatListNode(data1);
        //在单链表中删除倒数第k个节点
        ListNode head = removeLastKthNode2(head1, 1);
        while (head != null) {
            System.out.println(head.values);
            head = head.nextNode;
        }
    }
}

// 链表节点类
class ListNode {
    public int values;
    public ListNode nextNode;

    public ListNode(int data) {
        this.values = data;
    }
    
}
      

输出：

1 2 4 5 6