Java-数据结构系列五：单链表面试题

1.针对单向链表的操作，归纳整理常见面试题目，承接Java-数据结构系列四：链表（https://blog.csdn.net/money_yao/article/details/99408241）

2.求单链表中有效节点的数量

如果是带头节点的链表，不统计头节点

public class SingleLinkedListDemo {

    public static void main(String[] args) {
        System.out.println("有效节点的个数="+getLength(singleLinkedList.getHead()));
    }
//获取单链表节点数量（不包含头节点）
	/**
	 * @param head 链表的头节点
	 * @return 有效节点的个数
	 */
    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;	
}

3.查找单链表中倒数第k个节点

• 编写方法，接收head节点，同时接收index，index表示倒数第index个节点；
• 先把链表从头到尾遍历，得到链表的总长度getLength；
• 得到size后，从链表的第一个开始遍历（size-index）个，得到该节点返回。

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;
	}
	//定义辅助变量
	HeroNode cur=head.next;
	for(int i=0;i<(size-index);i++) {
		cur=cur.next;
	}
	return cur;
}

• 测试查找倒数第k个节点

main（）{  
  //测试查找单向链表倒数第k个节点
    HeroNode res=findLastIndexNode(singleLinkedList.getHead(), 3);
    System.out.println("单向链表倒数第2个节点是"+res);
}

4.单链表的反转

• 先定义一个新的节点（新的链表的头节点）reverseHead=new HeroNode();
• 遍历原来的链表，每遍历一个节点，将其取出，放到新的链表reverseHead的最前端；
• 原来的链表的head.next=reverseHead.next；

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, "", "");
	//遍历原来的链表，每遍历一个节点，将其取出放到新链表的最前端
	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;
}

测试反向链表：

main(){
    System.out.println("原链表：");
    singleLinkedList.list();
    System.out.println("反转后的链表：");
    reverseList(singleLinkedList.getHead());
    singleLinkedList.list();
}

5.从尾到头打印单链表

• 利用栈stack的数据结构，将各个节点压入栈中，然后利用栈的先进后出的特点，实现逆序打印的效果，优势在于不会改变原先单链表的结构。
• 栈stack的基本使用

package linkedlist;

import java.util.Stack;

//演示栈stack的基本使用
public class TestStack {

	public static void main(String[] args) {
		Stack<String> stack=new Stack<String>();
		//入栈
		stack.add("Jack");
		stack.add("Tom");
		stack.add("Smith");
		//出栈,先进后出
		while(stack.size()>0) {
			System.out.println(stack.pop());
		}
	}
}

从尾到头打印单向链表

//使用栈的数据结构实现逆序打印单向链表
public static void reversePrint(HeroNode head) {
    if(head.next==null) {
        return;//空链表，无法打印
	}
//创建栈，将各个节点压入栈中
    Stack<HeroNode> stack=new Stack<HeroNode>();
    HeroNode cur=head.next;
    while(cur!=null) {
        stack.push(cur);
	cur=cur.next;
	}
    while(stack.size()>0) {
	System.out.println(stack.pop());//stack栈的pop出栈
        }
}

5.合并两个有序的单链表，合并后的链表有序

• 编写方法接收两个链表的节点（该节点应该是head头节点以后的第一个节点）
• 判断如果有一个链表为空，则返回另外一个链表
• 否则，判断节点编号大小，保留小的，继续引用方法进行判断，直到有一个链表为空，返回排序好的节点；

//合并两个有序链表
public static HeroNode mergeTwoLists(HeroNode l1,HeroNode l2) {
    if(l1==null) {
	return l2;
	}
    if(l2==null) {
	return l1;
	}
    HeroNode newHead=null;
	if(l1.no<=l2.no) {
	    newHead=l1;
	    newHead.next=mergeTwoLists(l1.next, l2);
	}else {
	    newHead=l2;
	    newHead.next=mergeTwoLists(l1, l2.next);
	}
	return newHead;
}

测试合并两个有序链表

main(){
//测试合并两个有序链表
    System.out.println("合并两个有序链表输出：");
mergeLinkedList.add(mergeTwoLists(singleLinkedList.getHead().next,singleLinkedList2.getHead().next));
    mergeLinkedList.list();
}