单向链表

单链表的添加（创建）思路：

1. 先创建一个head头节点，作用就是表示单链表的头
2. 后面每添加一个节点，就直接加入到链表的最后

遍历：通过一个辅助变量，帮助遍历整个链表

单向链表创建，直接添加到链表尾部，没有考虑排名：

单向链表添加数据，考虑顺序：

单链表修改数据：

1. 直接找到该节点，通过遍历
2. temp.name = newheronode.name; temp.nickname = newheronode.name;

单链表删除数据：

//单向链表创建，直接添加到链表尾部，第一种添加没有考虑排名，第二种添加考虑排名
class SingleLinkedListDemo 
{
	public static void main(String[] args) 
	{
		//进行测试
		//先创建节点
		HeroNode hero1 = new HeroNode(1,"宋江","及时雨");
		HeroNode hero2 = new HeroNode(2,"卢俊义","玉麒麟");
		HeroNode hero3 = new HeroNode(3,"吴用","智多星");
		HeroNode hero4 = new HeroNode(4,"公孙胜","双鞭");

		//创建链表
		SingleLinkedList singlelinkedlist = new SingleLinkedList();

		//加入链表
		singlelinkedlist.add(hero1);
		singlelinkedlist.add(hero2);
		singlelinkedlist.add(hero3);
		singlelinkedlist.add(hero4);

		//测试修改节点代码
		HeroNode newheronode = new HeroNode(2,"小卢","玉麒麟~~");
		singlelinkedlist.update(newheronode);  
		
		//测试删除节点
		singlelinkedlist.del(1);

		//显示链表
		singlelinkedlist.list();

	}
}

//定义SingleLinkedList类，管理英雄
class SingleLinkedList
{
	//先初始化头节点，头节点不要动
	private HeroNode head = new HeroNode(0,"","");

	//第一种方式添加节点到单向链表，不考虑顺序
	//思路：当不考虑编号顺序时
	//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) {
		//因为头节点不能动，需要一个辅助变量来找到添加的位置
		//temp是位于添加位置的前一个节点，否则插不了
		HeroNode temp = head;
		boolean flag = false;     //flag标识添加的编号是否存在，默认为false
		//找temp的位置
		while (true)
		{
			if (temp.next == null)        //说明temp已经在链表的最后
			{
				break;
			}
			if (temp.next.no > heronode.no)      //位置找到，就在temp的后面插入。如图：4 > 2
			{
				break;
			}else if (temp.next.no == heronode.no)    //说明希望添加的heronode编号位置存在
			{
				flag = true;          //编号存在
				break;
			}
		}
		//判断flag的值
		if (flag)
		{
			//已存在，不能添加
			System.out.println("准备插入的编号%d已经存在了" + 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;
		}
		//找到需要的节点，根据no编号，定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false;            //表示是否找到该节点
		while (true)
		{
			if (temp == null)            
			{
				break;       //已经遍历完链表
			}
			if (temp.no == newheronode.no)
			{
				//找到
				flag =true;
				break;
			}
		}
		if (flag)
		{
			temp.name = newheronode.name;
			temp.nickname = temp.nickname;
		}else 
			System.out.println("没有找到该%d节点"+ newheronode.no);
	}

	//删除节点思路
	//由于head头节点不能动，找到待删除节点的前一个节点temp
	//在比较时，是temp.next.no和n待删除节点的标识o进行比较
	public void del(int no) {
		HeroNode temp = head;
		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.next = temp.next;      //删除节点
		}else
			System.out.println("删除节点不存在");
	}

	//显示链表（遍历）
	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);
			//将temp后移
			temp = temp.next;
		}
	}
}

//定义HeroNode,每个HeroNode就是一个节点
class HeroNode
{
	public int no;
	public String name;
	public String nickname;
	public HeroNode next;         //定义变量next,类型为HeroNode,next目前值为null,指向下一个节点

	//构造方法
	public HeroNode(int no,String name,String nickname) {
		this.no = no;
		this.name = name;
		this.nickname = nickname;
	}

	//为了显示方便，重写toString()方法
	public String toString() {
		return "HeroNode [no =" + no + ",name =" + name + ".nickname =" + nickname + "]";
	}

}

//获取单链表的节点个数（不统计头节点）
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;
}
//查找单链表中倒数第k个节点
//1.编写一个方法，接收head节点，同时接收index为k
//2.index就是倒数第index个节点
//3.先把链表从头到尾遍历一遍，得到链表节点个数（getLength()方法）
//4.得到个数size后，从链表的第一个开始遍历size-index个就可以得到
//5.如果找到了，就返回节点，否则返回null
public static HeroNode findLastIndexNode(HeroNode head,int index){
	//判断如果链表为空，返回null
	if (head.next == null)
	{
		return null;
	}
	//第一次遍历得到链表的长度节点个数
	int size = getLength(head);
	//第二次遍历size - index位置，就是倒数的第k个节点
	//判断index是否合理
	if (index <= 0 || index > size)
	{
		return null;
	}
	//定义辅助变量，for循环定位到倒数的index
	HeroNode cur = head.next;
	for (int i = 0;i < size - index ;i++ )   //size若为3，3-1=2，刚好循环两次
	{
		cur = cur.next;
	}
	return cur;
} 

反转单向链表【面试题】

思路：

1. 先定义一个节点reverseHead = new HeroNode();
2. 从头到尾遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead最前端
3. 原来的链表head.next = reverseHead.next;
   

	//反转单向链表
	public static void reverseList(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;    //将cur.next指向新的链表最前端(这两步就类似于插入)
			reverseHead.next = cur;
			cur = next;                //将cur后移
		}
		//将head.next指向reverseHead.next 实现链表反转
		head.next = reverseHead.next;
	}

逆序打印单链表

1. 先将单链表反转，再逆序打印即可，这样会破坏结构，不建议
2. 利用栈，先进后出的特点，实现逆序打印