单链表面试题(新浪、百度、腾讯)合并两个有序的单链表，合并之后的链表依然有序

1. 求单链表中有效节点的个数
2. 查找单链表中的倒数第 k 个结点 【新浪面试题】
3. 单链表的反转【腾讯面试题】
4. 从尾到头打印单链表 【百度】
5. 合并两个有序的单链表，合并之后的链表依然有序

package com.example.dataStructureAndAlgorithm.LinkedList;

import java.util.Stack;

public class SingleLinkedListTest {
    public static void main(String[] args) {
//        NodeTest node1 = new NodeTest(1, "1");
//        NodeTest node2 = new NodeTest(2, "2");
//        NodeTest node3 = new NodeTest(3, "3");
//        NodeTest node4 = new NodeTest(4, "4");
//        SingleLinkedListA singleLinkedList = new SingleLinkedListA();
//        singleLinkedList.addNode(node1);
//        singleLinkedList.addNode(node3);
//        singleLinkedList.addNode(node2);
//        singleLinkedList.addNode(node4);
//        singleLinkedList.show();
//        System.out.println("有效节点个数" + singleLinkedList.getLength());
//        System.out.println();
//        System.out.println(singleLinkedList.getByIndex(1).toString());
//        System.out.println(singleLinkedList.getByIndex(2).toString());
//        System.out.println(singleLinkedList.getByIndex(3).toString());
//        System.out.println(singleLinkedList.getByIndex(4).toString());
        singleLinkedList.getByIndex(5).toString();
//        //       singleLinkedList.reversetList();
//        //     System.out.println("反转后");
//        //   singleLinkedList.show();
//        System.out.println("逆序打印");
//        singleLinkedList.reversePrint();
        NodeTest node1 = new NodeTest(1, "1");
        NodeTest node2 = new NodeTest(2, "2");
        NodeTest node3 = new NodeTest(3, "3");
        NodeTest node4 = new NodeTest(4, "4");
        SingleLinkedListA singleLinkedListA = new SingleLinkedListA();
        node1.next=node3;
        node2.next=node4;
        System.out.println("A===============");
       // singleLinkedListA.show();
 //       SingleLinkedListA singleLinkedListB= new SingleLinkedListA();
//        singleLinkedListB.addNode(node2);
//        singleLinkedListB.addNode(node4);
        System.out.println("b===============");
  //      singleLinkedListB.show();
        System.out.println("合并");
        SingleLinkedListA list=new SingleLinkedListA();
       NodeTest nodeTest= singleLinkedListA.merge( node1, node2);
        while (nodeTest != null) {
            System.out.print(nodeTest + " ");
            nodeTest = nodeTest.next;
        }

    }
}

class SingleLinkedListA {
     NodeTest head = new NodeTest(0, "");

    public void addNode(NodeTest node) {
        NodeTest temp = head;
        while (true) {
            if (temp.next == null) {
                temp.next = node;
                return;
            }
            temp = temp.next;
        }
    }

    //求单链表中有效节点的个数
    public int getLength() {
        if (head.next == null) {
            return 0;
        }
        int num = 0;
        NodeTest temp = head;
        while (temp.next != null) {
            num++;
            temp = temp.next;
        }
        return num;
    }

    //查找单链表中的倒数第 k 个结点 【新浪面试题】
    public NodeTest getByIndex(int index) {
        if (head.next == null) {
            return null;
        }
        NodeTest temp = head.next;
        int size = getLength();//获取有效节点数
        if (index < 1 || index > size) {
            return null;
        }
        //size-index 位置，就是我们倒数的第 K 个节点
        for (int i = 0; i < size - index; i++) {
            temp = temp.next;
        }
        return temp;
    }

    //单链表的反转【腾讯面试题
    public void reversetList() {
        //链表为空，或者就一个节点，就不需要反转
        if (head.next == null || head.next.next == null) {
            return;
        }
        NodeTest temp = head.next;
        NodeTest next = null;
        NodeTest newHead = new NodeTest(0, "");
        //遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表 reverseHead 的最前端
        while (temp != null) {
            next = temp.next;//先暂时保存当前节点的下一个节点
            temp.next = newHead.next;//将 temp的下一个节点指向之前的最前端的节点
            newHead.next = temp;//将 temp连接到新的链表上，放在链表的最前端
            temp = next;//temp后移，遍历链表
        }
        //将 head.next 指向 reverseHead.next , 实现反转
        head.next = newHead.next;
    }

    //从尾到头打印单链表 【百度，要求方式 1：反向遍历 。 方式 2：Stack 栈】
    public void reversePrint() {
        if (head.next == null) {
            return;
        }
        NodeTest temp = head.next;
        //利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出             的特点，就实现了逆序打印的效果
        Stack<NodeTest> stack = new Stack<NodeTest>();
        while (temp != null) {
            stack.push(temp);
            temp = temp.next;
        }
        while (stack.size() > 0) {
            System.out.println(stack.pop());
        }
    }

    //合并两个有序的单链表，合并之后的链表依然有序
    public NodeTest merge(NodeTest nodeA, NodeTest nodeB) {
        if (nodeA == null && nodeB == null) {
            return null;
        }
        if (nodeA == null) {
            return nodeB;
        }
        if (nodeB == null) {
            return nodeA;
        }
        NodeTest newHead = null;
        if (nodeA.no > nodeB.no) {
            newHead = nodeB;
            newHead.next = merge(nodeA, nodeB.next);
        } else {
            newHead = nodeA;
            newHead.next = merge(nodeA.next, nodeB);
        }
        return newHead;

    }


    public void show() {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        NodeTest temp = head.next;
        while (true) {
            if (temp.next == null) {
                System.out.println(temp);
                return;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
}

class NodeTest {
    public int no;
    public String name;
    NodeTest next;

    public NodeTest(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name=" + name +
                '}';
    }
}