单链表面试题

一、单链表的介绍

1. 单链表的逻辑结构
   
2. 单链表的物理结构
   

二、单链表的创建、遍历

1. 尾插法
   思路分析：设置一个指针，从第一个结点遍历到最后一个结点，然后使最后一个结点的next指针域指向新插入的结点。
   
   代码实现

class Node {
	// 数据域
	// 排名
	public Integer order;
	// 姓名
	public String name;
	// 昵称
	public String nickname;
	
	// 指针域
	public Node next;
	
	// 构造器用于创建一个结点
	public Node(Integer order, String name, String nickname) {
		this.order = order;
		this.name = name;
		this.nickname = nickname;
	}

	@Override
	public String toString() {
		return "Node [order=" + order + ", name=" + name + ", nickname=" + nickname + "]";
	}
}

class SingleLinkedList {
	// 初始化一个头结点
	private Node head = new Node(0, "", "");
	
	public Node getHead() {
		return head;
	}
	
	public void setHead(Node head) {
		this.head = head;
	}
	
	// 尾插法
	public void addByTail(Node node) {
		Node temp = head;
		while(true) {
			if(temp.next == null) {
				break;
			}
			temp = temp.next;
		}
		temp.next = node;
	}
}

2 遍历单链表
思路分析：从第一个结点开始依次遍历，直到遍历到最后一个结点。

代码实现

class SingleLinkedList {
	// 初始化一个头结点
	private Node head = new Node(0, "", "");
	
	public Node getHead() {
		return head;
	}
	
	public void setHead(Node head) {
		this.head = head;
	}

	// 遍历单链表
	public void list() {
		// 如果单链表为空
		if(head.next == null) {
			System.out.println("该链表为空！！！");
			return;
		}
		Node temp = head.next;
		while(true) {
			System.out.println(temp);
			if(temp.next == null) {
				break;
			}
			temp = temp.next;
		}
	}
}

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

思路分析：设置一个变量length初始值为0,从第一个结点开始，每遍历一个结点，length的值加1，直到最后一个结点。

代码实现

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

四、查找单链表中的倒数第 index 个结点 【新浪面试题】

思路分析：先获得整个单链表的长度length，然后从第一个结点开始遍历length-index+1次，便得到倒数第index个结点。

代码实现

/**
	 * @param head 单链表的头结点
	 * @param index 查找倒数第几个结点
	 * @return 单链表中的倒数第index个结点
	 */
	public static Node findLastIndexNode(Node head, int index) {
		// 如果单链表为空
		if(head.next == null) {
			return null;
		}
		// 单链表的有效结点的个数
		int length = getSingleLinkedListLength(head);
		// 对index值得合法性进行校验
		if(index <= 0 || index > length) {
			return null;
		}
		Node node = head;
		if(index <= length) {
			for(int i = 1; i <= length + 1 - index; i++) {
				node = node.next;
			}
		}
		return node;
	}

五、单链表的反转【腾讯面试题】

思路分析：新创建一个单链表，将待反转的单链表进行遍历，每遍历一个结点，就利用头插法将该结点添加到新的单链表中，直到遍历完待反转的单链表，新创建的单链表即为原来单链表的反转链表。

代码实现：

/**
	 * 利用头插法将单链表进行反转
	 * @param head 待反转的单链表的头结点
	 */
	public static void reverseSingleLinkedList(Node head) {
		// 如果待反转链表为空或者只有一个结点，则退出
		if(head.next == null || head.next.next == null) {
			return;
		}
		// 创建一个反转链表的头结点
		Node reverseHead = new Node(0, "", "");
		// 遍历待反转链表
		Node curNode = head.next;
		// 指向当前结点的下一个结点
		Node nextNode = null;
		while(curNode != null) {
			// 记录当前结点的下一个结点
			nextNode = curNode.next;
			curNode.next = reverseHead.next;
			reverseHead.next = curNode;
			curNode = nextNode;
		}
		head.next = reverseHead.next;
	}

六、从尾到头打印单链表(不破坏单链表结构)【百度面试题】

思路分析：创建一个栈，从第一个结点到最后一个结点进行遍历，并将其压入栈中；然后从栈中依次取出，即实现了单链表的从尾到头打印并不破坏单链表的结构。

代码实现：

/**
	 * 利用栈数据结构逆序打印单链表
	 * @param head 单链表的头结点
	 */
	public static void reversePrintSingleLinkedList(Node head) {
		if(head.next == null) {
			return;
		}
		// 创建一个栈用于存放单链表的结点
		Stack<Node> stack = new Stack<>();
		// 指向当前的结点
		Node curNode = head.next;
		// 压栈
		while(curNode != null) {
			stack.push(curNode);
			curNode = curNode.next;
		}
		// 出栈
		while(stack.size() > 0) {
			System.out.println(stack.pop());
		}
	}

七、合并两个有序的单链表使之合并完的单链表依然有序

思路分析：创建一个单链表用于保存合并后的单链表结点，其头结点为newHead。为待合并的两个单链表分别创建两个指针结点curNode和nextNode用于记录遍历的结点。同时遍历两个单链表，取两个单链表中值小的结点添加到新创建的结点的尾部，依次类推，直到有一个单链表遍历完，然后把未遍历完的单链表的结点添加到新的合并单链表的尾部。

代码实现：

/**
	 * 合并两个有序的单链表
	 * @param head1 第一个有序单链表的头结点
	 * @param head2 第二个有序单链表的头结点
	 * @return 新生成的有序单链表的头结点
	 */
	public static Node mergeSingleLinkedList(Node head1, Node head2) {
		// 合并后单链表的头结点
		Node newHead = new Node(0, "", "");
		if(head1.next == null) {
			newHead.next = head2.next;
			return newHead;
		}
		if(head2.next == null) {
			newHead.next = head1.next;
			return newHead;
		}
		if(head1.next != null && head2.next != null) {
			// 指向链表的当前结点
			Node curNode1 = head1.next;
			Node curNode2 = head2.next;
			// 标记新生成链表的尾部，便于进行尾插
			Node tail = newHead;
			// 指向链表当前结点的下一个结点
			Node nextNode1 = null;
			Node nextNode2 = null;
			while(curNode1 != null && curNode2 != null) {
				if(curNode1.order >= curNode2.order) {
					nextNode2 = curNode2.next;
					tail.next = curNode2;
					curNode2 = nextNode2;
					tail = tail.next;
				}else{
					nextNode1 = curNode1.next;
					tail.next = curNode1;
					curNode1 = nextNode1;
					tail = tail.next;
				}
			}
			if(curNode1 != null) {
				tail.next = curNode1;
			}
			if(curNode2 != null) {
				tail.next = curNode2;
			}
		}
		return newHead;
	}
}