单链表进阶学习

单链表进阶学习

                  写题思路都在代码里

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

public class SingleLinkedListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 第一阶段测试代码
		// 创建节点
		HeroNode hero1 = new HeroNode(1, "呼保义", "宋江");
		HeroNode hero2 = new HeroNode(2, "玉麒麟", "卢俊义");
		HeroNode hero3 = new HeroNode(3, "智多星", "吴用");
		HeroNode hero4 = new HeroNode(4, "入云龙", "公孙胜");
		HeroNode hero5 = new HeroNode(5, "大刀", "关胜");

		// 创建单链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		// 加入操作

//		singleLinkedList.add(hero1);
//		
//		singleLinkedList.add(hero2);
//		
//		singleLinkedList.add(hero3);
//		
//		singleLinkedList.add(hero4);
//		
//		singleLinkedList.add(hero5);

		singleLinkedList.addByOrder(hero1);

		singleLinkedList.addByOrder(hero2);

		singleLinkedList.addByOrder(hero4);

		singleLinkedList.addByOrder(hero3);

		singleLinkedList.addByOrder(hero5);

		singleLinkedList.list();
		System.out.println("单链表中有效节点的个数:" + GetNumber(singleLinkedList.GetHead()));

	}

//获取单链表节点的个数（如果带头结点，计数时要取消头结点的计数，因为头节点不存储数据）
	public static int GetNumber(HeroNode head) {
		if (head.next == null) {
			return 0;
		}
		int number = 0;
		// 定义一个辅助变量
		HeroNode cur = head.next;// 这里就是没有统计头结点的微操作
		while (cur != null) {
			number++;
			cur = cur.next;
		}
		return number;
	}
}

//定义一个SingleLinkedList(单链表)，管理英雄
class SingleLinkedList {
	// 一开始要初始化一个头节点，保持不动否则会找不到剩下的节点，***不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");// no初始化为0，姓名和称号也不写

	// 返回头节点
	public HeroNode GetHead() {
		return head;
	}

// 添加节点到单向链表
	// 当不考虑编号顺序时：
	// 把节点添加进去的操作是首先找到当前链表的最后一个节点，next域原本是NULL，要把next域指向新添的节点

	public void add(HeroNode heroNode) {
		// 由于头节点不能动，所以需要辅助变量
		HeroNode temp = head;// temp是辅助变量一开始指向头节点，因为单向链表不是顺序存储，所以每一次找最后一个节点都需要遍历整个链表
		// 开始遍历
		while (true) {// 死循环
			if (temp.next == null) {// 找到链表的尾节点了
				break;
			}
			// 如果当前节点不是末节点

			// temp后移一位
			temp = temp.next;// 要清楚temp是一个移动辅助变量，每遍历到一个不是尾节点的点temp就会指向当前节点的下一个节点

		}
		// 当退出这个死循环的时候，temp就指向了单链表的尾节点
		// 这个时候就可以把尾节点的next域指向传入的新节点，这个新传入的节点就连上了
		temp.next = heroNode;
	}

// 增添节点，按照顺序显示出来
	// 如果已经有这个编号，则添加失败并给出提示
	public void addByOrder(HeroNode heroNode) {// heroNode为传入的新节点
		// 由于头节点不能动，所以需要辅助变量
		// 单链表要添加节点，temp一定是指向要插入位置的前一个节点，然后temp.next就指向新节点，这样第一步就完成了
		HeroNode temp = head;
		boolean flag = false;// 判断要添加的节点是否已存在
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.next.no > heroNode.no) {
				break;
			} else if (temp.next.no == heroNode.no) {
				flag = true;// 说明已经有了
				break;
			} else {
				temp = temp.next;// 如果上述情况都不符合的话，那么继续遍历找下一个节点
			}
		}
		// 退出循环的时候要看flag的值
		if (flag) {
			System.out.printf("已有编号%d，添加失败~~~\n", heroNode.no);
		} else {
			// 可以插入到链表中，temp后移
			heroNode.next = temp.next;// 新节点的next域指向下一个节点
			temp.next = heroNode;// 前一个节点的next域指向新节点
		}
	}

//修改节点的信息
	// 根据编号no来修改称号和姓名，编号no不动（如果编号改变就相当于添加操作了）
	public void update(HeroNode newHeroNode) {
		// 判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空~~~");
			return;
		}
		// 找到需要修改的节点
		// 根据编号no来修改节点信息
		// 定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false;// 标识是否找到这个节点
		while (true) {
			if (temp == null) {// 这里和之前不一样，表示已经遍历完这个链表了（无残留，去干净）
				break;
			} else if (temp.no == newHeroNode.no) {// 表示已经找到要删除的节点
				flag = true;
				break;
			}
			temp = temp.next;
		}
		// 退出循环以后，根据flag的值来判断
		if (flag) {
			// flag=true；表示找到了要修改的点
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}
		// 还有一种情况就是没有找到要修改的点
		else {
			System.out.println();
			System.out.printf("没有找到编号为%d 的好汉，不能删除😔\n");
		}
	}

//删除节点
	/*
	 * 1.由于头节点不能动，所以需要辅助变量，需要用辅助变量temp找到待删除节点的前一个节点 比较时使用temp.next.no和待删除节点的编号no比较
	 *
	 */
	public void del(int no) {
		HeroNode temp = head;// 因为需要找到目标节点的前一个节点，所以这里不能把辅助节点定义为头节点之后第一个节点
		boolean flag = false;
		while (true) {
			if (temp.next == null) {// 到链表最后，最后一个节点的后面
				break;
			} else if (temp.next.no == no) {// 找到前一个节点
				flag = true;
				break;
			}
			temp = temp.next;// 每遍历一个节点就后移一位
		}
		if (flag) {// 找到了前一个节点
			// 删除操作
			temp.next = temp.next.next;
		} else {
			System.out.println();
			System.out.printf("删除的数据%d不存在呀不存在~~~\n", no);
		}
	}

// 显示单向链表
	public void list() {
		// 首先判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空~~~");
			return;
		}
		// 如果能进行到下面这一步就说明链表不为空，至少有一个节点

		// 由于头节点不能动，所以需要辅助变量
		HeroNode temp = head.next;// 至少有一个节点，所以就把辅助变量指向头节点后的第一个节点
		while (true) {// 死循环
			if (temp == null) {// 找到链表的尾节点了
				break;
			}
			// 如果当前节点不是末节点

			System.out.println(temp);// 因为之前已经重写过toString方法了，所以这里直接打印输出就行了
			// ************
			// 下面这点很重要，每打印输出一个节点，就需要将辅助变量temp后移，否则的话后果就是一直输出一个值而且是个死循环
			temp = temp.next;

		}
	}

}

//定义HeroNode，每个HeroNode都是一个节点
class HeroNode {
	public int no;// 定义编号
	public String name;// 定义姓名
	public String nickname;// 定义称号
	public HeroNode next;// 定义next域，指向下一个节点
	// 建一个构造器

	public HeroNode(int no, String nickname, String name) {
		this.no = no;

		this.nickname = nickname;

		this.name = name;
	}

	// 为了便于显示，重写toString方法
	/*
	 * @Override是伪代码,表示重写。(当然不写@Override也可以)，不过写上有如下好处: 1、可以当注释用,方便阅读；
	 * 2、编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错。
	 * 例如，你如果没写@Override，而你下面的方法名又写错了，这时你的编译器是可以编译通 过的，因为编译器以为这个方法是你的子类中自己增加的方法。
	 */
	@Override
	public String toString() {
		return "no=  " + no + "，nickname=  " + nickname + "，name =  " + name;
	}

}

二、查找单链表中倒数第index个节点

public class SingleLinkedListDemo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		 第一阶段测试代码
		// 创建节点
		HeroNode hero1 = new HeroNode(1, "呼保义", "宋江");
		HeroNode hero2 = new HeroNode(2, "玉麒麟", "卢俊义");
		HeroNode hero3 = new HeroNode(3, "智多星", "吴用");
		HeroNode hero4 = new HeroNode(4, "入云龙", "公孙胜");
		HeroNode hero5 = new HeroNode(5, "大刀", "关胜");

		// 创建单链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		// 加入操作

//		singleLinkedList.add(hero1);
//		
//		singleLinkedList.add(hero2);
//		
//		singleLinkedList.add(hero3);
//		
//		singleLinkedList.add(hero4);
//		
//		singleLinkedList.add(hero5);

		singleLinkedList.addByOrder(hero1);

		singleLinkedList.addByOrder(hero2);

		singleLinkedList.addByOrder(hero4);

		singleLinkedList.addByOrder(hero3);

		singleLinkedList.addByOrder(hero5);

		// 修改操作
		HeroNode newHeroNode = new HeroNode(5, "写轮眼", "卡卡西");
		singleLinkedList.update(newHeroNode);

		// 显示
		System.out.println("删除前：");
		singleLinkedList.list();

		// 修改操作
		singleLinkedList.del(1);
		System.out.println("删除后：");
		singleLinkedList.list();
		// 获取单链表节点的个数
		System.out.println(GetNumber(singleLinkedList.GetHead()));

		HeroNode res = findLastIndexNode(singleLinkedList.GetHead(), 1);// 倒数第1个
		System.out.println();
		System.out.println("单链表中倒数第index个节点    " + res);

	}

	// 1.查找单链表中倒数第index个节点
	// 2.编写一个方法接收head节点，同时接受一个index（index数值代表单链表的倒数第index个节点）
	// 3.将链表遍历一遍，得到有效节点总数（GetNumber）
	// 4.单链表有效节点总数为size，直接遍历size-index个节点
	// 5.如果找到了这个节点就返回该节点，否则就返回NULL
	public static HeroNode findLastIndexNode(HeroNode head, int index) {
		// 如果链表为空返回NULL
		if (head.next == null) {
			return null;
		}
		// 第一次遍历得到单链表的节点个数
		int size = GetNumber(head);
		// 第二次遍历单链表，这次直接遍历size-index个节点，这就是要求的值

		// 在这里要做一个index的校验
		if (index <= 0 || index > size) {
			return null;
		}
		// 定义一个辅助变量，指向第一个有效节点（头节点后的第一个节点）
		HeroNode cur = head.next;
		// for循环定位到倒数index个节点
		for (int i = 0; i < size - index; i++) {
			cur = cur.next;
		}
		return cur;
	}

//获取单链表节点的个数（如果带头结点，计数时要取消头结点的计数，因为头节点不存储数据）
	public static int GetNumber(HeroNode head) {
		if (head.next == null) {
			return 0;
		}
		int number = 0;
		// 定义一个辅助变量
		HeroNode cur = head.next;// 这里就是没有统计头结点的微操作
		while (cur != null) {
			number++;
			cur = cur.next;
		}
		return number;
	}
}

//定义一个SingleLinkedList(单链表)，管理英雄
class SingleLinkedList {
	// 一开始要初始化一个头节点，保持不动否则会找不到剩下的节点，***不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");// no初始化为0，姓名和称号也不写

	// 返回头节点
	public HeroNode GetHead() {
		return head;
	}

// 添加节点到单向链表
	// 当不考虑编号顺序时：
	// 把节点添加进去的操作是首先找到当前链表的最后一个节点，next域原本是NULL，要把next域指向新添的节点

	public void add(HeroNode heroNode) {
		// 由于头节点不能动，所以需要辅助变量
		HeroNode temp = head;// temp是辅助变量一开始指向头节点，因为单向链表不是顺序存储，所以每一次找最后一个节点都需要遍历整个链表
		// 开始遍历
		while (true) {// 死循环
			if (temp.next == null) {// 找到链表的尾节点了
				break;
			}
			// 如果当前节点不是末节点

			// temp后移一位
			temp = temp.next;// 要清楚temp是一个移动辅助变量，每遍历到一个不是尾节点的点temp就会指向当前节点的下一个节点

		}
		// 当退出这个死循环的时候，temp就指向了单链表的尾节点
		// 这个时候就可以把尾节点的next域指向传入的新节点，这个新传入的节点就连上了
		temp.next = heroNode;
	}

// 增添节点，按照顺序显示出来
	// 如果已经有这个编号，则添加失败并给出提示
	public void addByOrder(HeroNode heroNode) {// heroNode为传入的新节点
		// 由于头节点不能动，所以需要辅助变量
		// 单链表要添加节点，temp一定是指向要插入位置的前一个节点，然后temp.next就指向新节点，这样第一步就完成了
		HeroNode temp = head;
		boolean flag = false;// 判断要添加的节点是否已存在
		while (true) {
			if (temp.next == null) {
				break;
			}
			if (temp.next.no > heroNode.no) {
				break;
			} else if (temp.next.no == heroNode.no) {
				flag = true;// 说明已经有了
				break;
			} else {
				temp = temp.next;// 如果上述情况都不符合的话，那么继续遍历找下一个节点
			}
		}
		// 退出循环的时候要看flag的值
		if (flag) {
			System.out.printf("已有编号%d，添加失败~~~\n", heroNode.no);
		} else {
			// 可以插入到链表中，temp后移
			heroNode.next = temp.next;// 新节点的next域指向下一个节点
			temp.next = heroNode;// 前一个节点的next域指向新节点
		}
	}

//修改节点的信息
	// 根据编号no来修改称号和姓名，编号no不动（如果编号改变就相当于添加操作了）
	public void update(HeroNode newHeroNode) {
		// 判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空~~~");
			return;
		}
		// 找到需要修改的节点
		// 根据编号no来修改节点信息
		// 定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false;// 标识是否找到这个节点
		while (true) {
			if (temp == null) {// 这里和之前不一样，表示已经遍历完这个链表了（无残留，去干净）
				break;
			} else if (temp.no == newHeroNode.no) {// 表示已经找到要删除的节点
				flag = true;
				break;
			}
			temp = temp.next;
		}
		// 退出循环以后，根据flag的值来判断
		if (flag) {
			// flag=true；表示找到了要修改的点
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;
		}
		// 还有一种情况就是没有找到要修改的点
		else {
			System.out.println();
			System.out.printf("没有找到编号为%d 的好汉，不能删除😔\n");
		}
	}

//删除节点
	/*
	 * 1.由于头节点不能动，所以需要辅助变量，需要用辅助变量temp找到待删除节点的前一个节点 比较时使用temp.next.no和待删除节点的编号no比较
	 *
	 */
	public void del(int no) {
		HeroNode temp = head;// 因为需要找到目标节点的前一个节点，所以这里不能把辅助节点定义为头节点之后第一个节点
		boolean flag = false;
		while (true) {
			if (temp.next == null) {// 到链表最后，最后一个节点的后面
				break;
			} else if (temp.next.no == no) {// 找到前一个节点
				flag = true;
				break;
			}
			temp = temp.next;// 每遍历一个节点就后移一位
		}
		if (flag) {// 找到了前一个节点
			// 删除操作
			temp.next = temp.next.next;
		} else {
			System.out.println();
			System.out.printf("删除的数据%d不存在呀不存在~~~\n", no);
		}
	}

// 显示单向链表
	public void list() {
		// 首先判断链表是否为空
		if (head.next == null) {
			System.out.println("链表为空~~~");
			return;
		}
		// 如果能进行到下面这一步就说明链表不为空，至少有一个节点

		// 由于头节点不能动，所以需要辅助变量
		HeroNode temp = head.next;// 至少有一个节点，所以就把辅助变量指向头节点后的第一个节点
		while (true) {// 死循环
			if (temp == null) {// 找到链表的尾节点了
				break;
			}
			// 如果当前节点不是末节点

			System.out.println(temp);// 因为之前已经重写过toString方法了，所以这里直接打印输出就行了
			// ************
			// 下面这点很重要，每打印输出一个节点，就需要将辅助变量temp后移，否则的话后果就是一直输出一个值而且是个死循环
			temp = temp.next;

		}
	}

}

//定义HeroNode，每个HeroNode都是一个节点
class HeroNode {
	public int no;// 定义编号
	public String name;// 定义姓名
	public String nickname;// 定义称号
	public HeroNode next;// 定义next域，指向下一个节点
	// 建一个构造器

	public HeroNode(int no, String nickname, String name) {
		this.no = no;

		this.nickname = nickname;

		this.name = name;
	}

	// 为了便于显示，重写toString方法
	/*
	 * @Override是伪代码,表示重写。(当然不写@Override也可以)，不过写上有如下好处: 1、可以当注释用,方便阅读；
	 * 2、编译器可以给你验证@Override下面的方法名是否是你父类中所有的，如果没有则报错。
	 * 例如，你如果没写@Override，而你下面的方法名又写错了，这时你的编译器是可以编译通 过的，因为编译器以为这个方法是你的子类中自己增加的方法。
	 */
	@Override
	public String toString() {
		return "no=  " + no + "，nickname=  " + nickname + "，name =  " + name;
	}

}

未完待续。。。。