一、单链表的介绍
- 单链表的逻辑结构
- 单链表的物理结构
二、单链表的创建、遍历
- 尾插法
思路分析:设置一个指针,从第一个结点遍历到最后一个结点,然后使最后一个结点的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;
}
}