单链表、双链表以及环形单链表

1.单链表

import java.util.Stack;

public class SingleLinkedListDemo {
	public static void main(String[] args) {
		// 测试
		HeroNode h1 = new HeroNode(1,"a啊","a神");
		HeroNode h2 = new HeroNode(3,"b啊","b神");
		HeroNode h3 = new HeroNode(5,"c啊","c神");
		HeroNode h4 = new HeroNode(7,"d啊","d神");
		
		HeroNode a1 = new HeroNode(2,"r","r神");
		HeroNode a2 = new HeroNode(4,"nv啊","n神");
		HeroNode a3 = new HeroNode(6,"h啊","h神");
		HeroNode a4 = new HeroNode(8,"e啊","e神");

		SingleLinkedList single = new SingleLinkedList();
		SingleLinkedList single2 = new SingleLinkedList();
		SingleLinkedList single3 = new SingleLinkedList();
		//single.add(h1);
		//single.add(h2);
		//single.add(h3);
		//single.add(h4);
		
		single.addByOrder(h1);
		single.addByOrder(h3);
		single.addByOrder(h2);
		single.addByOrder(h4);
		single.list();
		
		single2.addByOrder(a1);
		single2.addByOrder(a3);
		single2.addByOrder(a2);
		single2.addByOrder(a4);
		single2.list();
		
		merge(single.getHead(),single2.getHead(),single3.getHead());
		System.out.println("合并");
		single3.list();
		
		System.out.println("链表逆序打印");
		printReverseLinkList(single.getHead());
	
		
		System.out.println("链表反转");
		reverseLinkList(single.getHead());
		single.list();
	
		System.out.println("修改链表后");
		HeroNode newHeroNode = new HeroNode(3,"k神","kk"); 
		single.update(newHeroNode);
		single.list();
		
		System.out.println("删除一个后");
		single.delete(2);
		single.list();
		
		System.out.println("有效节点数"+getLength(single.getHead()));
		
		HeroNode res = findLastIndexNode(single.getHead(), 1);
		System.out.println("倒数第1个节点"+res);
	}
	
	
	// 合并两个有序的单链表
	 public static void merge(HeroNode head1, HeroNode head2,HeroNode head3) {
		// 如果两个链表均为空，则无需合并，直接返回
		if(head1.next == null && head2.next == null) {
			return;
		}
		if(head1.next == null) {
			head3.next = head2.next;
		}else {
			head3.next = head1.next;
			HeroNode cur2 = head2.next;
			HeroNode cur3 = head3;
			HeroNode next = null;
			while(cur2 != null) {
				if(cur3.next == null) {
					cur3.next = cur2;
					break;
				}
				if(cur2.no < cur3.next.no) {
					next = cur2.next;
					cur2.next = cur3.next;
					cur3.next = cur2;
					cur2 = next;
				}
				cur3 = cur3.next;
			}
		}
	 }
	
	// 逆序打印单链表  利用栈 先进后出的特点来实现
	public static void printReverseLinkList(HeroNode head) {
		if(head.next == null) {
			return; // 空链表，不能打印
		}
		// 创建要给一个栈，将各个节点压入栈
		Stack<HeroNode> stack = new Stack();
		HeroNode cur = head.next;
		while(cur != null) {
			stack.push(cur);
			cur = cur.next;
		}
		while(stack.size() > 0) {
			System.out.println(stack.pop());
		}
	}
	
	// 将单链表反转
	public static void reverseLinkList(HeroNode head) {
		if(head.next == null || head.next.next == null) {
			return;
		}
		
		HeroNode cur = head.next;
		HeroNode next = null;  // 指向当前节点cur的下一个节点
		HeroNode reverseHead = new HeroNode(0,"","");
		
		// 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
		while(cur != null) {
			next = cur.next;
			cur.next = reverseHead.next;
			reverseHead.next = cur;
			cur = next;
		}
		head.next = reverseHead.next;
	}
	
	// 查找单链表中的倒数第k个节点
	// 1.编写一个方法接收head节点，同时接收一个index
	// 2.index 表示倒数第index个节点
	// 3.先把链表从头到尾遍历，得到链表的总长度 getLength
	// 4.得到总长度后，我们从链表的第一个开始遍历（getLength()-index）个
	public static HeroNode findLastIndexNode(HeroNode head, int index) {
		if(head.next == null) {
			return null;
		}
		// 第一次遍历得到链表的长度
		int size = getLength(head);
		// 第二次遍历 getLength()-index，就是倒数第k个
		if(index <= 0 || index > size) {
			return null;
		}
		HeroNode temp = head.next;
		for(int i = 0; i < size - index; i++) {
			temp = temp.next;
		}
		return temp;
	}
	
	// 方法：获取到单链表的节点的个数（如果是带头结点的链表，需求不统计头节点
	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;
	}
	
}



// 定义SingleLinkedList 管理我们的Hero
class SingleLinkedList {
	// 先初始化一个头节点，头节点不要动
	private HeroNode head = new HeroNode(0,"","");
	
	// 返回头结点
	public HeroNode getHead() {
		return head;
	}
	
	// 添加节点到单项链表
	// 1.找到当前链表的最后节点
	// 2.将最后的这个节点的next 指向 新的节点
	public void add(HeroNode heroNode) {
		
		// 因为head不能动，我们需要一个辅助遍历temp
		HeroNode temp = head;
		// 遍历链表，找到最后
		while(true) {
			// 找到链表的最后
			if(temp.next == null) {
				break;
			}
			// 如果没有找到最后，将temp后移
			temp = temp.next;
		}
		// 当退出while循环时，temp指向了链表的最后
		// 将最后这个节点的next指向新的节点
		temp.next = heroNode;
	}
	
	// 添加 根据排名插入指定位置
	public void addByOrder(HeroNode heroNode) {
		HeroNode temp = head;
		boolean flag = false; // 标志添加的编号是否存在
		while(true) {
			if(temp.next == null) {// 说明temp在最后
				break;
			}
			if(temp.next.no > heroNode.no) { // 添加在temp后面
				break;
			}
			if(temp.next.no == heroNode.no) { // 编号已存在
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) { // 编号已存在
			System.out.printf("准备插入的英雄的编号%d已存在，不能加入\n",heroNode.no);
		}else {
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}
	
	// 修改节点信息，根据no编号来修改，no编号不能改
	public void update(HeroNode newHeroNode) {
		// 是否为空
		if(head.next == null) {
			System.out.println("链表空");
			return;
		}
		// 找到需要修改的节点
		HeroNode temp = head.next;
		boolean flag = false; // 表示是否找到
		while(true) {
			if(temp == null) {
				break;
			}
			if(temp.no == newHeroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}else {
			System.out.println("没有找到编号%d的节点，不能修改"+newHeroNode.no);
		}
	}
	
	
	// 删除节点  head节点不能动
	public void delete(int no) {
		HeroNode temp = head;
		boolean flag = false; //是否找到
		if(temp.next == null) {
			System.out.println("链表为空");
			return;
		}
		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.println("没有找到编号%d的节点，不能修改"+no);
		}
	}
	
	// 显示链表（遍历）
	public void list() {
		// 判断链表是否为空
		if(head.next==null) {
			System.out.println("链表空");
			return;
		}
		// 因为head不能动，我们需要一个辅助遍历temp
		HeroNode temp = head.next;
		while(true) {
			// 判断是否到链表最后
			if(temp == null) {
				break;
			}
			System.out.println(temp);
			// 将next后移
			temp = temp.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.双向链表

// 双向链表
public class DoubleLinkedListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		HeroNode2 h1 = new HeroNode2(2,"a啊","a神");
		HeroNode2 h2 = new HeroNode2(1,"b啊","b神");
		HeroNode2 h3 = new HeroNode2(4,"c啊","c神");
		HeroNode2 h4 = new HeroNode2(3,"d啊","d神");
		
		
		DoubleLinkedList dou = new DoubleLinkedList();
		
		dou.addByOrder(h1);
		dou.addByOrder(h2);
		dou.addByOrder(h3);
		dou.addByOrder(h4);
		
		//dou.add(h1);
		//dou.add(h2);
		//dou.add(h3);
		//dou.add(h4);
		System.out.println("遍历所有");
		dou.list();
		
		HeroNode2 newHeroNode = new HeroNode2(4,"god","神");
		dou.update(newHeroNode);
		System.out.println("修改第四个");
		dou.list();
		
		dou.del(1);
		System.out.println("删除no=1的");
		dou.list();
	}

}

class DoubleLinkedList {
	private HeroNode2 head = new HeroNode2(0,"","");

	public HeroNode2 getHead() {
		return head;
	}
	
	// 按照编号添加
	public void addByOrder(HeroNode2 heroNode) {
		HeroNode2 temp = head;
		boolean flag = false; // 标志添加的编号是否存在
		while(true) {
			if(temp.next == null) {
				break;
			}
			if(temp.next.no > heroNode.no) {
				break;
			}
			if(temp.next.no == heroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			System.out.printf("准备插入的英雄的编号%d已存在，不能加入\n",heroNode.no);
		}else {
			if(temp.next != null) {
				heroNode.next = temp.next;
				temp.next.pre = heroNode;
			}
			temp.next = heroNode;
			temp.next.pre = temp;
		}
	}
	
	// 添加 默认添加到链表末尾
	public void add(HeroNode2 heroNode) {
		HeroNode2 temp = head;
		while(true) {
			if(temp.next == null) {
				break;
			}
			temp = temp.next;
		}
		// 形成双向链表
		temp.next = heroNode;
		heroNode.pre = temp;
	}
	
	// 修改一个节点的内容
	public void update(HeroNode2 newHeroNode) {
		if(head.next == null) {
			System.out.println("链表空");
			return;
		}
		HeroNode2 temp = head.next;
		boolean flag = false;
		while(true) {
			if(temp == null) {
				break;
			}
			if(temp.no == newHeroNode.no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}else {
			System.out.println("没有找到编号%d的节点，不能修改"+newHeroNode.no);
		}
	}
	
	// 删除一个节点
	// 双向链表可直接找到需要删除的点
	public void del(int no) {
		if(head.next == null) {
			System.out.println("链表空");
			return;
		}
		
		HeroNode2 temp = head.next;
		boolean flag = false;
		while(true) {
			if(temp == null) {
				break;
			}
			if(temp.no == no) {
				flag = true;
				break;
			}
			temp = temp.next;
		}
		if(flag) {
			temp.pre.next = temp.next;
			// 如果是最后一个节点，就不需要执行下面这句话，不然会出现空指针异常
			if(temp.next != null) {
				temp.next.pre = temp.pre;
			}
		}
	}

	// 遍历
	public void list() {
		if(head.next == null) {
			System.out.println("链表空");
			return;
		}
		HeroNode2 temp = head.next;
		while(true) {
			if(temp == null) {
				break;
			}
			System.out.println(temp);
			temp = temp.next;
		}
	}
	
}

class HeroNode2 {
	public int no;
	public String name;
	public String nickname;
	public HeroNode2 next;
	public HeroNode2 pre;
	
	public HeroNode2(int no, String name, String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

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

3.环形单链表（约瑟夫问题）

//约瑟夫问题 环形单链表
//约瑟夫(Joseph)问题的一种描述是：编号为 1，2，…,n 的 n 个人按顺时针方向围坐一圈，每人持有一个密码（正整数），
//一开始任选一个整数作为报数上限 m,从第一人开始按顺时针方向从自 1 开始顺序报数，报到 m 时停止报数。报 m 的人出列，
//将他的密码作为新的 m 值，从他的顺时针方向上的下一个人开始重新从 1 报数，如此下去，直至所有人全部出列为止，设计一个程序求出出列顺序。

public class Josepfu {
	public static void main (String[] args) {
		// 构建环形链表
		CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
		circleSingleLinkedList.addBoy(5);
		circleSingleLinkedList.showBoy();
		
		System.out.println("小孩出圈");
		circleSingleLinkedList.countBoy(1,2,5); // 2 4 1 5 3
	}
}

// 创建一个环形的单向链表
class CircleSingleLinkedList {
	// 创建一个first节点，当前没有编号
	private Boy first = null;
	
	// 添加小孩节点，构建成一个环形的链表
	public void addBoy(int nums) {
		// nums 做一个数据校验
		if(nums < 1) {
			System.out.println("数据nums不正确");
			return;
		}
		Boy curBoy = null; // 辅助指针，帮助构建环形链表
		// 使用for循环来创建环形链表
		for(int i = 1; i <= nums; i++) {
			// 根据编号，创建小孩节点
			Boy boy = new Boy(i);
			// 如果是第一个小孩
			if (i == 1) {
				first = boy;
				first.setNext(first); // 构成环
				curBoy = first; // 让curBoy指向第一个小孩
			}
				curBoy.setNext(boy);
				boy.setNext(first);
				curBoy = boy;
		}
	}
	
	// 遍历当前的环形链表
	public void showBoy() {
		// 判断链表是否为空
		if (first == null) {
			System.out.println("链表为空");
			return;
		}
		// 因为first不能动，因此我们仍然使用一个辅助指针完成遍历
		Boy curBoy = first;
		while(true) {
			System.out.printf("小孩的编号%d\n",curBoy.getNo());
			if(curBoy.getNext() == first) { // 说明已经遍历完毕
				break;
			}
			curBoy = curBoy.getNext(); // curBoy后移
		}
	}
	
	// 根据用户的输入，生成一个小孩出圈的顺序
	// 1.需求创建一个辅助指针 helper，事先应该指向环形链表的最后这个节点
	//  小孩报数前，先让first和helper移动k-1次
 	// 2.当小孩报数时，让first和helper指针同时的移动m-1次
	// 3.这是就可以将first指向的小孩节点出圈 
	//       first = first.next   helper.next = first 
	//  原来first指向的节点就没有任何引用，就会被回收
	/***
	 * 
	 * @param startNo 表示从第几个小孩开始数
	 * @param countNum 表示数几下
	 * @param nums 表示最初有几个小孩在圈中
	 */
	public void countBoy(int startNo, int countNum, int nums) {
		if(first == null || startNo < 1 || startNo > nums) {
			System.out.println("参数输入有误，请重新输入");
			return;
		}
		// 创建一个辅助指针，帮助小孩出圈
		Boy helper = first;
		while(true) {
			if(helper.getNext() == first) {
				break;
			}
			helper = helper.getNext();  // 用方法是因为next私有了
		}
		// 小孩报数前，先让first和helper移动k-1次
		for(int j = 0; j < startNo - 1; j++) {
			first = first.getNext();
			helper = helper.getNext();
		}
		// 当小孩报数时，让first和helper指针同时的移动m-1次,然后出圈
		while(true) {
			if(helper == first) { // 说明圈中只有一个节点
				break;
			}
			// 让first和helper指针同时的移动countNum - 1
			for(int j = 0; j < countNum - 1; j++) {
				first = first.getNext();
				helper = helper.getNext();
			}
			// 这时first指向的节点，就是要出圈的小孩节点
			System.out.printf("小孩%d出拳 \n", first.getNo());
			first = first.getNext(); // 出圈
			helper.setNext(first); // 构造环形
		}
		System.out.printf("最后留在圈中的小号编号%d\n",first.getNo());
	}
	
}


// 创建一个Boy类，表示一个节点
class Boy {
	private int no; // 编号
	private Boy next; // 指向下一个节点，默认null
	
	public Boy(int no) {
		this.no = no;
	}
	
	public int getNo() {
		return no;
	}
	public void setNo(int no) {
		this.no = no;
	}
	public Boy getNext() {
		return next;
	}
	public void setNext(Boy next) {
		this.next = next;
	}

}