Java数据结构|单向链表（Single Linked List，含完整代码以及面试真题）

链表介绍

链表是有序的列表，但是它在内存中的实际存储结构如下：

从上图不难看出：

1. 链表是以节点的方式来存储，是链式存储；
2. 每个节点包含data域，next域：指向下一个节点；
3. 如图所示，链表的各个节点不一定是连续存储；
4. 链表的带头结点的链表和没有头结点的链表，根据实际的需求来确定；
   单链表（带头结点）的逻辑结构示意图（注意不是实际内存中的结构）：
   

从比较简单的不用考虑英雄排名与链表位置对应的单向链表

我们以水浒传中的英雄排名管理为例说明对链表的应用。首先明确这些数据的特点：108个英雄各自有姓名昵称以及对应的座次。通过这个简单的实例将从单向链表的节点定义、链表建立、链表的增删改和显示实现。

分析

以管理梁山好汉英雄为例：
1.定义节点HeroNode，每一个HeroNode就是一个节点
- 数据：编号no、姓名、昵称
- next：指向下一个节点
2.定义单链表SingleLinkedList
- 先初始化一个头结点，头结点不能动且不存放具体的数据
- 添加节点到单向列表
- 当不考虑英雄编号的顺序时，找到当前列表的最后节点，将最后节点的next指向新的节点
- 以内头节点不能动，所以需要一个辅助节点temp来遍历
判断遍历到最后：temp.nest == null
如果没有找到最后：temp = temp.next，将temp后移
- 当退出循环时即判断到最后一个节点时：temp.next = heronode(新的节点)
- 显示链表：也要通过遍历
- 判断是否为空：head.next == null
- 判断是否遍历到最后：temp.next == null
- 遍历的时候每次打印信息后记得将.next后移
此时只能将英雄直接添加到链表尾部，不能按照英雄的实际排名存储，
比如，当已经存储了4个新英雄时，这时候要加入排名第3的吴用，
应该让他存在第3个位置，而不是第5个位置（链表尾）

代码实现

1.定义一个链表的节点

注意：链表的节点所包含的关键信息是数据域和next域。在本例中，数据为各路英雄的编号、姓名以及昵称。

// 定义HeroNode，每个HeroNode就是一个节点
class HeroNode {
	public int no; // 座次排名
	public String name; // 姓名
	public String nickname; // 昵称
	public HeroNode next; // 指向下一个节点

	// 定义构造器
	public HeroNode(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}
	// 为了显示方法，重写toString

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

2.定义单向链表

另写一个单向链表的类，初始化头结点：没有数据域，只有指向头数据的.next域，此外包含链表的增删改操作以及显示链表数据的方法。
代码结构：

• 初始化头结点；

• 在链表尾部加入节点；
  

• 根据英雄编号插入节点；
  

• 修改指定编号的节点信息；

• 删除指定编号的节点；
  

• 显示链表信息。

**注意：**修改节点是找到该节点的本身，而插入和删除节点在遍历的时候都是找到该节点的前一个节点，

• 否则将无法操作（链表只有指向下一个的，没有指向上一个的）

// 定义单向链表SingleLinkedList，管理英雄列表
class SingleLinkedList{
	// 先初始化头结点，头结点不能动且不存放任何数据，只是next指向后一个节点
	private HeroNode head = new HeroNode(0, "我是头结点", "I am head");
	
	public void isNull(){
		if(head.next == null){
			System.out.println("该单链表为空链表");
			return;
		}
	}
	
	// 添加节点到链表
	// 第一种方式
	// 在不考虑英雄的编号顺序时，找到链表最后一个位置，将新的节点加入即可，即：最后一个节点的next指向新节点
	// 最后一个节点需要遍历实现，因为head不能动，所以定义一个辅助变量temp来遍历
	// 判断是否最后节点：temp == null;
	public void addData(HeroNode heroNode){
		HeroNode temp = head;
		while(true){
			if(temp.next == null){
				
				break;
			}
			temp = temp.next;
		}
		temp.next = heroNode;
	}
	
	// 第二种方式
	// 根据英雄排名插入到指定位置（如果有这个排名则添加失败并给出提示）
	// 因为是单链表，因此找的temp是位于添加节点位置的前一个节点
	public void addDataByOrder(HeroNode heroNode){
		HeroNode temp = head;
		HeroNode temp2;
		while(true){
			if(temp.next == null){
				break;
			}
			if(temp.next.no > heroNode.no){
				break;
			}else if(temp.next.no == heroNode.no){
				System.out.printf("已存在该节点%d，不能添加\n", heroNode.no);
				return;			
			}
			temp  = temp.next;
		}
		heroNode.next = temp.next;
		temp.next = heroNode;
	}
	//修改节点的信息
	// 根据编号修改，即no不能变
	public void update(HeroNode heroNode){
		// 判断链表是否为空
		HeroNode temp = head;
		isNull();
		boolean flag = false;
		while(true){
			if(temp == null){
				break;
			}
			if(temp.no == heroNode.no){
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(!flag){
			System.out.println("没有找到该节点，无法完成修改");
		}else{
//			temp = heroNode;//这种形式传递的只是地址
			temp.name = heroNode.name;
			temp.nickname = heroNode.nickname;
		}
	}
	
	// 删除节点
	// 根据节点的信息删除
	public void deleteData(int no){
		HeroNode temp = head;
		isNull();
		boolean flag = false;
		while(true){
			if(temp.next == null){
				break;
			}
			if(temp.next.no == no){
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag){
			temp.next = temp.next.next;
		}else{
			System.out.printf("未找到该节点%d", no);
		}
	}
	
	// 显示单链表节点内容
	public void showData(){
		// 通过遍历显示数据
		HeroNode temp = head; // 通过辅助变量temp来遍历
		// 如果打印的时候不显示头结点的话，定义temp = head.next
		if(head.next == null){
			System.out.println("空单向链表，无数据！");
			return;
		}
		while(true){
			if(temp == null){		
				break;
			}
			System.out.println(temp);
			temp = temp.next;
		}	
	}
}

3.测试代码

public class SingleLinkedListText {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		// 测试单链表不考虑英雄编号
		// 先定义几个节点
		HeroNode heroNode1 = new HeroNode(1, "宋江", "及时雨");
		HeroNode heroNode2 = new HeroNode(2, "卢俊义", "玉麒麟");
		HeroNode heroNode3 = new HeroNode(3, "吴用", "智多星");
		HeroNode heroNode4 = new HeroNode(4, "公孙胜", "入云龙");
		HeroNode heroNode5 = new HeroNode(5, "关胜", "大刀");
		HeroNode heroNode6 = new HeroNode(2, "修改", "我是修改测试");
		
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		
		// 添加节点
//		singleLinkedList.addData(heroNode1);
//		singleLinkedList.addData(heroNode3);
//		singleLinkedList.addData(heroNode2);
//		singleLinkedList.addData(heroNode4);
//		singleLinkedList.addData(heroNode5);
		
		// 按排名插入
		singleLinkedList.addDataByOrder(heroNode1);
		singleLinkedList.addDataByOrder(heroNode3);
		singleLinkedList.addDataByOrder(heroNode2);
		singleLinkedList.addDataByOrder(heroNode5);
		// 显示单向链表中所有数据
		singleLinkedList.showData();
		System.out.println("********************************");
		
		singleLinkedList.update(heroNode6);

		singleLinkedList.showData();
		System.out.println("********************************");

		singleLinkedList.deleteData(1);
		singleLinkedList.showData();
		System.out.println("********************************");

	}

}

测试结果

1.从链表尾插入节点

2.按英雄座次插入节点

3.修改指定编号的节点信息

4.删除指定编号的节点

面试真题

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

思路：遍历，临时变量储存遍历次数

代码

	// 方法：获取单链表的有效节点个数，如果是带有头结点的链表不统计头结点
	public static int getLength(HeroNode head){
		if(head.next == null){
			return 0;
		}
		int len = 0;
		HeroNode cur = head.next;
		while(cur != null){
			len++;
			cur = cur.next;
		}
		return len;
	}

2.查找单链表中倒数第K个节点（新浪面试题）

思路：
* 先把链表从头到尾完整遍历一遍，得到链表的长度size = getLength
* 然后在从头开始遍历至size - index个即为到数index个节点
* 找到返回该节点，未找到则返回null

代码

	public static HeroNode findLastIndexNode(HeroNode head, int index){
		int size = getLength(head);
		if(head.next == null || index <= 0 || index >size){
			return null;
		}
		HeroNode cur = head.next;
		for(int i = 0; i < size - index; i++){
			cur = cur.next;
		}
		return cur;
		
	}

3.单链表的反转（腾讯面试题，有点难度）

思路：
* 先定义一个新的头结点reverseHead；
* 开始遍历原始节点，每遍历到一个新的节点，就将这个节点指向reverseHead.next
* 并且将reverseHead.next指向该节点；
* 最后令原始链表的head.next = reverseHead.next。

代码

注意工具：import java.util.Stack;
	public static void reverseSingleLinkedList(HeroNode head){
		if(head.next == null || head.next.next == null){
			System.out.println("空链表");
		}
		HeroNode reverseHead = new HeroNode(0, "反转链表", "我是反转链表的临时头结点");
		HeroNode cur = head.next;
		HeroNode temp;
		int size = getLength(head);
		for(int i = 0; i < size; i++){
			temp = cur.next;
			cur.next = reverseHead.next; // 这里cur.next已经指向的不是原始链表中的节点了，
			//所以上一步要先用temp保存一下，用来遍历原始链表
			//将原始的cur的next指向反转链表的最前方
			reverseHead.next = cur;
			cur = temp;
		}
		head.next = reverseHead.next;
	}

4.从尾到头打印单链表（百度面试，要求1：反向遍历。方式2：Stack栈）

思路：
* 1.反转之后再打印，这样做会破坏原始节点的结构，所以不推荐；
* 2.stack栈：将各个节点压入到栈中，利用栈的先进后出的特点就实现了逆序打印的效果

代码

   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; //cur 后移，这样就可以压入下一个节点
		   }
	 //将栈中的节点进行打印,pop 出栈
	   while (stack.size() > 0) {
		   System.out.println(stack.pop()); //stack 的特点是先进后出
		   }
	   
   }

测试代码

		// 测试输出链表的有效节点个数
		System.out.println("该链表的有效节点个数为：" + getLength(singleLinkedList.getHead()));
		System.out.println("********************************");
		// 查找倒数第K个节点
		System.out.println("该链表的倒数第K个节点为：" + findLastIndexNode(singleLinkedList.getHead(), 1));
		System.out.println("********************************");
		
		
		reverseSingleLinkedList((singleLinkedList.getHead()));
		System.out.println("显示反转后的单向链表：");
		singleLinkedList.showData();
		System.out.println("********************************");
		
		
		System.out.println("逆序打印：");
		reversePrint(singleLinkedList.getHead());

测试结果