Java编程：单链表面试题

基础链表结构

class NodeList {
    
    
    private Node head = new Node(0);

    public Node getHead() {
    
    
        return head;
    }

    public void add(Node node) {
    
    
        Node temp = head;
        while (temp.next != null) {
    
    
            temp = temp.next;
        }
        temp.next = node;
    }

    public void list() {
    
    
        if (head.next == null) {
    
    
            System.out.println("链表为空！");
            return;
        }
        Node temp = head.next;
        while (temp != null) {
    
    
            System.out.println(temp.toString());
            temp = temp.next;
        }
    }
}


class Node {
    
    
    public int num;
    public Node next;

    public Node(int num) {
    
    
        this.num = num;
    }

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

求单链表中有效节点的个数

/**
* 求单链表中有效节点的个数
*
* @param node 头结点
* @return 有效节点个数
*/
public static int getLength(Node node) {
    
    
   if (node.next == null) {
    
    
       return 0;
   }
   Node temp = node.next;
   int len = 0;
   while (temp != null) {
    
    
       len++;
       temp = temp.next;
   }
   return len;
}

查找单链表中的倒数第k个结点

思路：

1. 编写一个方法，接收head结点，同时接收index
2. index表示倒数index个结点
3. 先把链表从头到尾遍历，得到链表总长度（getLength）
4. 得到size后，从链表第一个遍历，遍历（size-index）个，就可以得到
   如果找到返回该节点，否则返回空

/**
 * 查找单链表中倒数第index个数
 *
 * @param index index
 * @param node  头结点
 * @return 倒数第index个结点
 */
public static Node findLastIndexNode(int index, Node node) {
    
    
    if (node.next == null) {
    
    
        return null;
    }
    int size = getLength(node);
    if (index <= 0 || index > size) {
    
    
        return null;
    }
    Node temp = node.next;
    for (int i = 0; i < size - index; i++) {
    
    
        temp = temp.next;
    }
    return temp;
}

单链表的反转

思路：

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

 /**
 *反转单链表
 *
 * @param node 头结点
 */
public static void reverseList(Node node) {
    
    
    if (node.next == null || node.next.next == null) {
    
    
        return;
    }
    Node temp = node.next;
    Node next = temp.next;
    Node result = new Node(0);
    while (temp != null) {
    
    
        next = temp.next;
        temp.next = result.next;
        result.next = temp;
        temp = next;
    }
    node.next = result.next;
}

从尾到头打印单链表

思路：
要求：逆序打印单链表

1. 方式1：先将单链表反转操作，然后再遍历即可。这样做的问题是会破坏原来单链表的结构，不建议
2. 方式2：利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果

/**
* 从头到尾打印单链表
 * 方法1：反转后打印
 * 方法2：利用栈
 *
 * @param node 头结点
 */
public static void reversePrint(Node node) {
    
    
    if (node.next == null) {
    
    
        return;
    }
    Stack<Node> stact = new Stack<>();
    Node temp = node.next;
    while (temp != null) {
    
    
        stact.add(temp);
        temp = temp.next;
    }
    while (stact.size() > 0) {
    
    
        System.out.println(stact.pop());
    }
}

合并两个有序的单链表，合并之后的链表依然有序

/**
* 两个有序单链表合并为有序单链表
* @param head1 表1头节点
* @param head2 表2头节点
* @return 合并后头节点
*/
public static Node merge(Node head1, Node head2) {
    
    
   Node h1 = head1.next;
   Node h2 = head2.next;
   if (h1 == null) return h2;
   if (h2 == null) return h1;
   Node res = new Node(0);
   Node flag = res;
   while (h1 != null && h2 != null) {
    
    
       if (h1.num < h2.num) {
    
    
           flag.next = h1;
           h1 = h1.next;
       } else if (h2.num < h1.num) {
    
    
           flag.next = h2;
           h2 = h2.next;
       } else {
    
    
           flag.next = h1;
           h1 = h1.next;
           h2 = h2.next;
       }
       flag = flag.next;
   }
   if(h1==null){
    
    
       flag.next = h2;
   }
   if(h2==null){
    
    
       flag.next = h1;
   }
   return res;
}