数据结构与算法（3）单链表的四道面试题

1. 求单链表中有效节点个数

/**
     * 方法：获取到单链表的节点个数（如果是带头节点的链表，需求不统计头结点）
     * 
     * @param head：链表的头结点
     * @return：length 有效节点个数
     */

    public static int getLength(HeroNode head){
        if (head.next == null){
            return 0;
        }
        int length = 0;
        //定义一个辅助变量，这里没有统计头结点
        HeroNode cur = head.next;
        while (cur != null){
            length++;
            cur = cur.next;
        }

        return length;
    }

2. 查找单链表中的倒数第k个节点【新浪】

/**
     * 思路：
     * 1.编写一个方法，接受head节点，同时接受一个index
     * 2.index表示倒数第index个节点
     * 3.先把链表从头到尾遍历，使用getLength()方法得到链表的总长度size
     * 4.得到size后，从链表的第一个开始遍历(size - index)个，就可以得到
     * 5. 如果找到了，就返回该节点，否则返回null
     */

    public static HeroNode findLastIndexNode(HeroNode head,int index){
        //首先判断链表是否为空
        if (head.next == null){
            return null;
        }

        //先得到链表的长度(节点个数)
        int size = getLength(head);

        //遍历到 (size - index) 位置，就是倒数第k的节点
        //首先先做一个index的校验
        if (index <= 0 || index > size){
            return null;
        }

        //定义一个辅助变量，for循环定位到倒数的index
        HeroNode cur = head.next;
        for (int i = 0; i < (size - index); i++) {
            cur = cur.next;
        }
        return cur;
    }

3. 单链表的反转【腾讯】

1. 分析思路图解

2. 思路
（1）先定义一个节点reverseHead = new HeroNode();
（2）从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
（3）原来的链表的head.next = reversrHead.next

3. 代码实现

public static void reverseList(HeroNode head){
        //链表为空，则直接返回
        if (head.next == null || head.next.next == null){
            return;
        }        
        //定义一个辅助变量，帮助遍历原来的链表
        HeroNode cur = head.next;
        HeroNode next = null;  //指向当前节点[cur]的下一个节点
        HeroNode reverseHead = new HeroNode(0,"","");

        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead的最前端
        while (cur != null){
            next = cur.next;   //先暂时保存当前节点的下一个节点，因为后面需要使用
            cur.next = reverseHead.next;  //将cur的下一个节点指向新的链表的最前端
            reverseHead.next = cur;   //将cur连接到新的链表上
            cur = next;  //cur向后移
        }

        //将head.next指向reverseHead.next，实现单链表的反转
        head.next = reverseHead.next;
    }

4. 从尾到头打印单链表

1. 思路分析
（1）可以先将链表进行反转，然后在遍历，但是这样会破坏原来的单链表结构【不建议】
（2）可以使用栈这个数据结构，将各个节点压入栈中，利用栈先进后出的特点，就实现了逆序打印的效果

2. 关于栈的一个小demo

public class StackDemo {
    public static void main(String[] args) {
        Stack<String> stack = new Stack<>();

        //入栈
        stack.push("java");
        stack.push("python");
        stack.push("c++");

        //出栈
        while (stack.size() > 0){
            System.out.println(stack.pop());    //c++ python java
        }
    }
}

3. 代码实现

public static void reversePrint(HeroNode head){
        if (head.next == null){
            return;
        }

        //创建一个栈，将各个节点压入栈
        Stack<HeroNode> stack = new Stack<>();
        HeroNode cur = null;

        //将链表的所有节点压入栈
        while (cur != null){
            stack.push(cur);
            cur = cur.next;
        }
        
        //取出节点
        while (stack.size() > 0){
            System.out.println(stack.pop());
        }
    }