【数据结构与算法(Java)】单链表（按顺序添加）面试题练习

1. 查找单链表中的倒数第k个节点（新浪）

- 思路：

• 找到倒数第k个节点 = 找到正数第(length - k + 1)个节点
  （1）获取length
  （2）循环遍历，找到第(length - k + 1)个节点
• eg.
  [head], 1, 2, 3, 4, 5, 6, <7>, 8, 9, 10
  k = 4, length = 10 -> 正数第 10 - 4 + 1 = 7个节点(7)

- 实现：

    public static Node findReciprocalNodeAt(OrderedSingleLinkedList orderedSingleLinkedList, int k){
        // 1. 获取单链表的长度并存入int变量 -> O(n)
        int length = orderedSingleLinkedList.countNodes();

        // 2. 判断k值是否超出length范围，超出则抛出异常
        if (k <= 0 || k > length) {
            throw new RuntimeException("k is illegal!");
        }

        // 3. 设置一个节点变量用来储存当前节点
        Node currentNode = orderedSingleLinkedList.getHeadPointer();

        // 4. 循环遍历，找到第(length - k + 1)个节点
        for (int i =0; i < length - k + 1; i++) {
            currentNode = currentNode.getNextNode();
        }

        return currentNode;
    }

2. 单链表的反转（腾讯）

- 思路：

（1）创建一新节点，作为新单链表的头节点
（2）遍历原链表，每移动一个节点就把这个节点存到新节点的下一节点

- 实现：

    public static OrderedSingleLinkedList reverseSingleLinkedList(OrderedSingleLinkedList originalOrderedSingleLinkedList) {
        // 1. 判断所给单链表是否为空，为空抛出异常
        if (originalOrderedSingleLinkedList.getHeadPointer().getNextNode() == null ||
                originalOrderedSingleLinkedList.getHeadPointer().getNextNode().getNextNode() == null) {
            return originalOrderedSingleLinkedList;
        }

        // 2. 创建新节点，作为反转后单链表的头节点
        Node newHeadNode = new Node(0);

        // 3. 遍历原链表，每移动一个节点就把这个节点存到新节点的下一节点
        Node currentNode = originalOrderedSingleLinkedList.getHeadPointer().getNextNode();
        while (currentNode != null) {
            // (1) 将当前节点的下一个节点赋值给一个临时节点变量nextNode
            Node nextNode = currentNode.getNextNode();

            // (2) 插入当前节点到newHeadNode的下一节点
            currentNode.setNextNode(newHeadNode.getNextNode());
            newHeadNode.setNextNode(currentNode);

            // (3) 移动当前节点到下一节点
            currentNode = nextNode;
        }

        // 4. 创建新的单链表，将newHeadNode设置为其头节点
        originalOrderedSingleLinkedList.setHeadPointer(newHeadNode);
        return originalOrderedSingleLinkedList;
    }

3. 从尾到头打印单链表（百度）:

- 思路：

(1) 方式1: 反向遍历 - 先反转，后遍历
(2) 方式2: 栈

- 实现

• 方式1: 反向遍历

    public static void printSingleLinkedListReverselyByReverseIt(OrderedSingleLinkedList originalOrderedSingleLinkedList) {
        // 1. 判断单链表是否为空
        if (originalOrderedSingleLinkedList.getHeadPointer().getNextNode() == null) {
            throw new RuntimeException("The single linked list is empty!");
        }

        // 反转原单链表
        Node newHeadNode = new Node(0);
        Node currentNode = originalOrderedSingleLinkedList.getHeadPointer().getNextNode();
        while (currentNode != null) {
            Node nextNode = currentNode.getNextNode();
            currentNode.setNextNode(newHeadNode.getNextNode());
            newHeadNode.setNextNode(currentNode);
            currentNode = nextNode;
        }
        OrderedSingleLinkedList reversedOrderedSingleLinkedList = new OrderedSingleLinkedList();
        reversedOrderedSingleLinkedList.setHeadPointer(newHeadNode);

        // 遍历反转后的单链表，并打印
        Node currentNodeForPrint = reversedOrderedSingleLinkedList.getHeadPointer().getNextNode();
        while (currentNodeForPrint != null) {
            System.out.println("node{" + currentNodeForPrint.getData() + "}");
            currentNodeForPrint = currentNodeForPrint.getNextNode();
        }
    }

• 方式2: 栈

    public static void printSingleLinkedListReverselyByStack(OrderedSingleLinkedList originalOrderedSingleLinkedList) {
        // 判断单链表是否为空
        if (originalOrderedSingleLinkedList.getHeadPointer().getNextNode() == null) {
            throw new RuntimeException("The single linked list is empty!");
        }

        // 创建栈
        Stack<Node> nodeStack = new Stack<>();

        // 循环遍历单链表，将节点按顺序加入stack
        Node currentNode = originalOrderedSingleLinkedList.getHeadPointer().getNextNode();
        while (currentNode != null) {
            nodeStack.add(currentNode);
            currentNode = currentNode.getNextNode();
        }

        // 遍历stack，逐个取出并打印每个节点的数值
        while (nodeStack.size() > 0) {
            System.out.println("node -> {" + nodeStack.pop() + "}");
        }
    }

4. 合并两个有序单链表，合并后依然有序

- 思路

(1) 设置两个节点变量分别充当两个单链表循环时的当前节点；并新建一个节点充当新链表的头节点
(2) 同时遍历两个单链表，比较每个节点值的大小，按顺序放入新建的节点
(3) 新建一个单链表，将新建的节点设置为其头节点

- 实现

    public static OrderedSingleLinkedList mergeTwoOrderedSingleLinkedLists(OrderedSingleLinkedList orderedSingleLinkedList1, OrderedSingleLinkedList orderedSingleLinkedList2) {
        // 1. 判断单链表是否为空
        if (orderedSingleLinkedList1.getHeadPointer().getNextNode() == null) {
            return orderedSingleLinkedList2;
        } else if (orderedSingleLinkedList2.getHeadPointer().getNextNode() == null){
            return orderedSingleLinkedList1;
        } else if (orderedSingleLinkedList1.getHeadPointer().getNextNode() == null
                && orderedSingleLinkedList2.getHeadPointer().getNextNode() == null){
            throw new RuntimeException("Both of them are empty!");
        }

        // 2. 设置4个节点变量分别充当：
        //      新链表的头节点
        //      添加节点到新链表时的当前节点
        //      两个单链表循环时的当前节点；
        Node newHeadNode = new Node(0);
        Node newCurrentNode = newHeadNode;
        Node currentNode1 = orderedSingleLinkedList1.getHeadPointer().getNextNode();
        Node currentNode2 = orderedSingleLinkedList2.getHeadPointer().getNextNode();

        // 3. 同时遍历两个单链表，比较每个节点值的大小，按顺序放入新建的节点
        while (currentNode1 != null || currentNode2 != null) {
            if (currentNode1 == null) {
                newCurrentNode.setNextNode(currentNode2);
                break;
            } else if (currentNode2 == null) {
                newCurrentNode.setNextNode(currentNode1);
                break;
            } else {
                if (currentNode1.getData() < currentNode2.getData()) {
                    Node nextNode1 = currentNode1.getNextNode();
                    newCurrentNode.setNextNode(currentNode1);
                    newCurrentNode = currentNode1;
                    currentNode1 = nextNode1;
                } else {
                    Node nextNode2 = currentNode2.getNextNode();
                    newCurrentNode.setNextNode(currentNode2);
                    newCurrentNode = currentNode2;
                    currentNode2 = nextNode2;
                }
            }
        }

        // 4. 新建一个单链表，将新建的节点设置为其头节点
        OrderedSingleLinkedList mergedOrderedSingleLinkedList = new OrderedSingleLinkedList();
        mergedOrderedSingleLinkedList.setHeadPointer(newHeadNode);

        return mergedOrderedSingleLinkedList;
    }