链表

链表

概念：

1. 链表通过节点的方式来存储数据；
2. 分有两个域组成：data域（存储数据），next域（指向下一个节点的索引，链表结束的时候给next域赋值为NULL）；
3. 链表的各个节点不一定是连续存储的；
4. 链表分为带头结点（头节点不存放数据，在一个链表中只起到连接的作用）和不带头结点的链表。
   
   （注：这里虽然看起来是顺序的，但实际上next域指向的下一节点不一定都是连续的，这个图只是便于理解，但是不能被误导，我之前就是误以为顺序存储和链式存储没什么区别，希望同学们之后学习的时候就不要踩这个坑了！！！）

一、单链表

1. 添加数据：
   ①先创建一个head头节点，表示单链表的头；
   ②后面每添加一个节点，就直接添加在链表的最后。
2. 遍历链表：
   通过一个临时变量或者辅助指针来遍历整个单链表。
3. 定义一个链表的基本属性并构建一个构造器（为了方便显示可以重写toString函数，但是开发过程中不建议这样做）

一百单八将

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.list();

	}

}

//定义一个SingleLinkedList(单链表)，管理英雄
class SingleLinkedList {
	// 一开始要初始化一个头节点，保持不动否则会找不到剩下的节点，***不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");// no初始化为0，姓名和称号也不写
	// 添加节点到单向链表
	// 当不考虑编号顺序时：
	// 把节点添加进去的操作是首先找到当前链表的最后一个节点，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 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;
	}

}

以上代碼有一個缺點，在添加節點的時候你按照什麽順序加入的，就按照什麽順序打印出來

改進後的代碼，無論以什麽樣的順序添加，顯示時都會按照no的順序顯示！！！
改進後的思路：

1. 首先通過一個輔助變量找到新添加節點的位置（遍歷這個單鏈表）
2. 把新節點的next域指向辅助变量的next域
3. 新辅助变量的next域指向新的节点

改进后的源代码如下：

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();

	}

}

//定义一个SingleLinkedList(单链表)，管理英雄
class SingleLinkedList {
	// 一开始要初始化一个头节点，保持不动否则会找不到剩下的节点，***不存放具体数据
	private HeroNode head = new HeroNode(0, "", "");// no初始化为0，姓名和称号也不写
	// 添加节点到单向链表
	// 当不考虑编号顺序时：
	// 把节点添加进去的操作是首先找到当前链表的最后一个节点，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域指向新节点
		}
	}

	// 显示单向链表
	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;
	}

}

虽然添加节点的编号顺序改变了，但是运行时还是按照编号顺序显示的，改进成功~！！！