单链表面试题:获取倒数第K个结点，反转以及逆序打印

---

一、获取倒数第K个结点

	思路：	
		先遍历出单链表个数的总数
		然后从头开始遍历到第 count - index 个就是倒数第K个结点

/**
    * @Author: yzh
    * @Description: 获得倒数第k个结点
    * @Param: [head, index]
    * @return: com.hao.demo.Node
    * @Date: 2021/7/30
    */
    public Node getLastIndex(Node head,int index){
        if (head.next == null) return null;
        //首先遍历出单链表总数
        int count = 0;
        Node cur = head.next;
        while (cur != null){
            count++;
            cur = cur.next;
        }
        //遍历count - index 个就是倒数第 index个
        cur = head.next;
        for (int i = 0; i < count - index; i++) {
            cur = cur.next;
        }
        return cur;
    }

二、单链表的反转

思路:
	首先创建一个新的头结点newHead,用于记录反转的链表
	然后通过头插法的形式将链表反转
	要通过画图来了解每个指针的指向
		next = cur.next;//保存cur的下一个结点
        cur.next = newHead.next;//让cur的下一个结点指向最前端：头插法
        newHead.next = cur;//头结点指向当前结点cur
        cur = next;//指针移动

/**
    * @Author: yzh
    * @Description: 单链表反转
    * @Param: [head]
    * @return: void
    * @Date: 2021/7/30
    */
    public void reverse(Node head){
        //如果单链表为空 或者 只有一个结点
        if (head.next==null || head.next.next == null)
            return ;
        //定义辅助指针cur和保存指针next 和新的头结点 newHead
        Node cur = head.next;
        Node next = null;
        Node newHead = new Node(0,"");
        //通过循环和头插法的方式，进行反转
        while (cur != null){
            next = cur.next;//保存cur的下一个结点
            cur.next = newHead.next;//让cur的下一个结点指向最前端：头插法
            newHead.next = cur;//头结点指向当前结点cur
            cur = next;//指针移动
        }
        head.next = newHead.next;//让原来的头结点指向反转的单链表
    }

三、单链表的逆序打印

思路：
	主要是用到了栈的先进后出特征进行实现

/**
    * @Author: yzh
    * @Description: 不改变结构逆序打印单链表
    * @Param: [head]
    * @return: void
    * @Date: 2021/7/30
    */
    public void reversePrint(Node head){
        if (head.next==null) return;
        //使用栈的特性来打印
        Stack<Node> stack = new Stack<>();
        Node cur = head.next;
        //压栈
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        //弹栈
        while (stack.size()>0){
            System.out.println(stack.pop());
        }
    }

四、单链表的有序合并

思路：

	1)获得head1和head2中数据值较小的节点,并设置为合并后链表的首节点
	2)通过循环,依次获得链表1和链表2中数据值较小的节点,并添加到合并后链表的末尾
	3)当步骤2执行完毕,如果某一个链表中的首节点不为null,则将该链表首节点及其之后节点添加到合并后链表的末尾.

/**
    * @Author: yzh
    * @Description: 两个单链表的有序合并
    * @Param: [node1, node2]
    * @return: com.hao.demo.Node
    * @Date: 2021/7/30
    */
    public static Node mergeList(Node node1, Node node2) {
        if (node1.next == null && node2.next == null) {
            return null;
        }
        if (node1.next == null) {
            return node2;
        }
        if (node2.next == null) {
            return node1;
        }
        Node newNode = new Node(0,"");//新的链表
        //临时变量
        Node node = newNode;
        Node temp1 = node1.next;
        Node temp2 = node2.next;
        while (temp1 != null && temp2 != null) {
            if (temp1.no < temp2.no) {
                //取出链表1的值加入到新的链表中
                node.next = temp1;
                temp1 = temp1.next;
            } else {
                //取出链表2的值加入到新的链表中
                node.next = temp2;
                temp2 = temp2.next;
            }
            node = node.next;
        }
        if (temp1 == null) {
            node.next = temp2;
        }
        if (temp2 == null) {
            node.next = temp1;
        }
        return newNode;
    }

总结

单链表就是看next域的指向，搞明白了啥都好说，一定要画图.