数据结构与算法(三)——单链表

概述

1. 链表是以节点的方式来存储
2. 每个节点包含data域（存储有效数据），next域（指向下一个节点）
3. 链表的各个节点不一定是连续存储的
4. 链表分带头节点的链表和没有头节点的链表，根据实际的需求确定

逻辑结构

代码实现

/***
 * 单链表
 * 
 * @author laowa
 *
 */
class SingleLinkedList {
	/**
	 * 链表的头节点，不存放任何数据，作用就是作为链表的头
	 */
	private Node head = new Node(0, "", "");

	/**
	 * 增加节点(增加到链表尾部)
	 * 
	 * @param node
	 *            节点
	 */
	public void add(Node node) {
		// 要找到链表的最后一个节点，然后将最后一个节点的next指向新节点
		// 遍历链表之前，需要创建一个辅助节点helper，因为头节点不能移动，头节点一旦移动链表就无法使用了
		Node helper = head;
		while (true) {
			// 如果下一个不为空，则指向下一个节点
			if (helper.next != null) {
				helper = helper.next;
			} else {
				// 最后一个节点为空，找到最后一个节点跳出循环
				break;
			}
		}
		// 将最后一个节点的next指针指向新的节点
		helper.next = node;
	}

	/**
	 * 打印链表信息
	 */
	public void list() {
		// 链表判空
		if (head.next == null) {
			System.out.println("链表为空");
			return;
		}
		Node helper = head.next;
		while (true) {
			// 打印节点信息
			System.out.println(helper);
			if (helper.next != null) {
				helper = helper.next;
			} else {
				break;
			}
		}
	}

	/**
	 * 按照编号顺序条件添加
	 * 
	 * @param node
	 *            待添加的节点
	 */
	public void addByOrder(Node node) {
		Node helper = head;
		boolean isExist = false;// 作为标志量，标志当前链表是否已经存在该节点
		while (true) {
			if (helper.next == null) {
				break;
			}
			// 当下一个节点比新节点的编号大时，将新节点插在下一个节点之前
			if (helper.next.no > node.no) {
				break;
			} else if (helper.next.no == node.no) {
				// 如果下一个节点和新节点编号一样，说明该节点已存在
				isExist = true;
				break;
			}
			// 如果下一个节点比新节点的编号小，则新节点应该在下一个节点的后面，所以继续往后找
			helper = helper.next;
		}
		// 存在则不插入
		if (isExist) {
			System.out.printf("编号为%d节点已存在\n",node.no);
		} else {
			// 不存在该节点，则表示当前helper几点的后一个位置就是需要插入的位置，先把新节点指向helper.next再将helper.next指向新节点
			node.next = helper.next;
			helper.next = node;
		}
	}
	
	/**
	 * 通过节点编号修改链表中的节点
	 * @param node 新节点
	 */
	public void update(Node node) {
		Node helper = head;
		boolean isExist = false;//标志量，判断链表中是否存在待修改的这个节点
		while(true) {
			//如果链表为空，则表示不存再该节点
			if(helper.next==null) {
				break;
			}else if(helper.next.no==node.no) {
				//如果下一个节点的编号与待修改的节点编号相同，则表示已存在该节点，跳出循环
				isExist = true;
				break;
			}
			//否则继续往下找 
			helper = helper.next;
		}
		if(isExist) {
			helper.next.name = node.name;
			helper.next.nickName = node.nickName;
		}else {
			System.out.printf("没有找到编号为%d的节点\n",node.no);
		}
	}
	
	/**
	 * 通过编号删除节点
	 * @param no 节点编号
	 */
	public void delete(int no) {
		Node helper = head;
		boolean isExist = false;//标志量，判断节点是否存在
		while(true) {
			if(helper.next==null) {
				break;
			}else if(helper.next.no==no) {
				//当下一个节点的编号是待删除的节点编号时，跳出循环
				isExist=true;
				break;
			}
			helper = helper.next;
		}
		if(isExist) {
			//将待删除的节点前一个节点直接指向待删除节点的下一个节点，待删除的节点失去了栈空间的指针，将被垃圾回收机制回收
			helper.next = helper.next.next;
		}else {
			System.out.printf("编号为%d的节点不存在",no);
		}
	}
}

/***
 * 节点
 * 
 * @author laowa
 *
 */
class Node {
	int no;
	String name;
	String nickName;
	/**
	 * 指向下一个节点
	 */
	Node next;

	public Node(int no, String name, String nickName) {
		this.no = no;
		this.name = name;
		this.nickName = nickName;
		this.next = null;
	}

	@Override
	public String toString() {
		return "no=" + no + "\tname=" + name + "\tnickName=" + nickName;
	}

}

单链表相关面试题

求单链表中有效节点个数

	/**
	 * 求一个单链表有效节点个数（不包括头节点）
	 * @param node 单链表的头节点
	 * @return 有效节点个数
	 */
	public static int getSize(Node node) {
		Node helper = node;
		int num = 0;
		while(true) {
			//如果下一个节点不为空，才会增加num，否则跳出循环，表示不统计头节点
			if(helper.next==null) {
				break;
			}
			num++;
			helper = helper.next;
		}
		return num;
	}

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

	/**
	 * 求一个单链表有效节点个数（不包括头节点）
	 * @param node 单链表的头节点
	 * @return 有效节点个数
	 */
	public static int getSize(Node node) {
		Node helper = node;
		int num = 0;
		while(true) {
			//如果下一个节点不为空，才会增加num，否则跳出循环，表示不统计头节点
			if(helper.next==null) {
				break;
			}
			num++;
			helper = helper.next;
		}
		return num;
	}
	/**
	 * 删除链表倒数第n个元素
	 * @param node 链表的头节点
	 * @param index 需要删除的索引
	 */
	public static void deleteByLastIndex(Node node,int index) {
		if(node.next==null) {
			System.out.println("链表为空");
			return;
		}
		int size = getSize(node);
		if(index<1||index>size) {
			System.out.printf("倒数第%d个节点不存在",index);
			return;
		}
		Node helper = node;
		//标志当前遍历到第几个节点，最开始为头节点，则current=0表示第零个
		int current=0;
		while(true) {
			//当前数到的current个元素为倒数第index个时，删除当前的节点的下一个节点
			//比如五个有效数据，倒数第二个为正数第四个，正数到第三个的时候恰好满足current==size-index，此时删除第四个即helper下一个
			if(current==size-index) {
				helper.next = helper.next.next;
				break;
			}
			helper = helper.next;
			current++;
		}
	}

将链表反转

/**
	 * 反转单链表
	 * 创建一个新的头节点，遍历原链表依次插在新的头节点之前，得到一个新的链表就是已被反转的链表，再用原头节点替代新的头节点
	 * @param head 待反转的链表的头节点
	 */
	public  static void reverseLinkedList(Node head) {
		//新的头节点
		Node newHeadNode = new Node(0,null,null);
		//当前遍历到的节点,最初为第一个有效节点
		Node current = head.next;
		//当前节点插入反转链表的辅助节点
		Node helper = null;
		while(current!=null) {
			//先将当前节点存储起来，留给之后插入反转链表
			helper = current;
			//再将current指向下一个位置，因为反转之后current.next就改变为了newHeadNode.next所以这一步一定要在插入反转链表之前进行
			current = current.next;
			//将当前节点的next设置为newHeadNode.next
			helper.next = newHeadNode.next;
			//将新的头节点的next设置为当前节点，至此插入完成
			newHeadNode.next = helper;
		}
		//原头节点的next指向新的头节点的next，局域变量newHeadNode在方法执行完毕后会被垃圾回收机制回收，至此反转完成
		head.next = newHeadNode.next;
	}

从尾到头打印单链表

1. 方式一：先将链表反转，再遍历，但这种方式破环了链表的原有结构，或是可以克隆原有节点创建一个新的反转的链表，但是会损耗大量空间
2. 方式二：使用栈结构，先依次将链表中的所有元素入栈，再将栈中的元素依次出栈打印，利用栈的先进后出的特点，来实现链表的逆序打印

/**
	 * 从尾到头打印单链表
	 * @param head
	 */
	public static void reversePrint(Node head) {
		if(head.next==null) {
			System.out.println("链表为空");
			return;
		}
		//创建一个节点栈
		Stack<Node> stack = new Stack<>();
		//辅助指针来遍历链表，最初为头节点，依次将下一个节点入栈
		Node helper = head;
		while(helper.next!=null) {
			//入栈
			stack.add(helper.next);
			helper = helper.next;
		}
		//出栈打印
		System.out.println("逆序打印的结果为");
		while(!stack.isEmpty()) {
			System.out.println(stack.pop());
		}
	}

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

/**
	 * 有序合并两个单链表
	 * 
	 * @param head1
	 *            链表1的头节点
	 * @param head2
	 *            链表2的头节点
	 * @return 合并之后的链表头节点
	 */
	public static Node orderMerge(Node head1, Node head2) {
		//表示遍历到链表1的当前的节点
		Node current1 = head1.next;
		//表示遍历到链表2的当前节点
		Node current2 = head2.next;
		//辅助节点1，用于将原链表的几点加入新链表
		Node helper = null;
		//新链表的头节点
		Node newHead = new Node(0, null, null);
		//辅助节点2，用于保存新链表的尾部
		Node helper2 = newHead;
		//当两个链表都还有数据时，需要对比后取出一方插入新链表
		while (current1 != null && current2 != null) {
			//如果节点1编号大于2，表示节点2在1的前面，将节点2加入新链表，并后移
			if (current1.no > current2.no) {
				helper = current2;
				current2 = current2.next;
			} else {
				//反之将节点1取出插入新链表，并后移
				helper = current1;
				current1 = current1.next;
			}
			//将新节点插入新链表的尾部，并将辅助节点2后移到尾部
			helper.next = helper2.next;
			helper2.next = helper;
			helper2 = helper2.next;
		}
		//如果有一方链表没有节点了，而另一方还有，则直接将另一方接在新链表的尾部
		//因为两个链表都是有序的，所以可以直接接，不用排序
		if (current1 != null) {
			helper2.next = current1;
		}
		if (current2 != null) {
			helper2.next = current2;
		}
		return newHead;
	}