数据结构与算法（Java）—— 单链表

1. 什么是链表

• 链表是有序的列表，但是它在内存中是存储如下

---

小结上图:

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

单链表(带头结点)逻辑结构示意图如下

---

2. 单链表的应用举例

• 使用带 head头节点的单向链表实现–水浒英雄排行榜管理完成对英雄人物的增删改查操作，注:删除和修改,查找
• 1.第一种方法在添加英雄时，直接添加到链表的尾部

---

思路分析示意图:

---

• 2.第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

---

思路的分析示意图:

---

• 3.修改节点功能
• 思路
  (1)先找到该节点，通过遍历，
  (2) temp.name =newHeroNode.name ; temp.nickname=newHeroNode.nickname
  注：修改节点时，编号不变，名字和昵称改变。

---

• 4.删除节点
• 思路分析的示意图:
  

---

3. 方式一单链表实现参考代码

package datastructureexamples;




//定义测试类，用于测试所创建的链表是否符合逻辑
public class SingleLinkListTest {
	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(hero4);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);
		//显示输出
		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 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;
						
		}	
	}
	
}


class HeroNode{
	//定义HeroNode,每个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 + "]" ;
	}
	
}

---

运行结果：

HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=4, name=林冲, nickname=豹子头]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]

---

4. 方式二单链表实现参考代码

package myexcirse1;




//定义测试类，用于测试所创建的链表是否符合逻辑
public class SingleLinkListTest2 {

	public static void main(String[] args) {
		
		//进行测试
		//先创建节点
		HeroNode1 hero1 = new HeroNode1(1,"宋江","及时雨");	
		HeroNode1 hero2 = new HeroNode1(2,"卢俊义","玉麒麟");
		HeroNode1 hero3 = new HeroNode1(3,"吴用","智多星");
		HeroNode1 hero4 = new HeroNode1(4,"林冲","豹子头");
		
		
		//创建链表
		SingleLinkedList1 singleLinkedList1 = new SingleLinkedList1();
//		singleLinkedList.add(hero1);
//		singleLinkedList.add(hero4);
//		singleLinkedList.add(hero2);
//		singleLinkedList.add(hero3);
		
		singleLinkedList1.addByOrder(hero1);
		singleLinkedList1.addByOrder(hero4);
		singleLinkedList1.addByOrder(hero2);
		singleLinkedList1.addByOrder(hero3);

		
		
		
		//显示输出
		singleLinkedList1.list();
		
		
		//测试修改节点的代码
		HeroNode1 newHeroNode = new HeroNode1(2,"小卢","玉麒麟---");
		singleLinkedList1.update(newHeroNode);
		
		System.out.println("修改后的链表情况--");
		singleLinkedList1.list();
		
		
		
		//删除一个节点
		singleLinkedList1.del(1);
		singleLinkedList1.del(4);
		System.out.println("删除后的链表情况----");
		
		
		singleLinkedList1.list();
		

	}

}


//定义SingleLinkedList来管理我们的英雄
class SingleLinkedList1{
	//先初始化一个头结点，头结点不要动，不存放具体的数据
	private HeroNode1 head = new HeroNode1(0,"","");
	
	//功能一. 添加节点到单向链表
	//思路，当不考虑编号的顺序时
	//1. 找到当前链表的最后节点
	//2. 将最后这个节点的next指向新的节点
	public void add(HeroNode1 heroNode){
		//因为head节点不能动，因此我们需要一个辅助遍历temp
		HeroNode1 temp = head;
		//遍历链表，找到最后
		while(true){
			//找到链表的最后
			if(temp.next == null){
				break;
			}
			//如果没有找到最后，将temp后移
			temp = temp.next;
		}
	//当退出while循环时，temp就指向了链表的最后
	//将最后这个节点的next指向新的节点
		temp.next = heroNode;
		
	}
	
	//功能二.显示链表[遍历]
	public void list(){
		//判断链表是否为空
		if(head.next == null){
			System.out.println("链表为空");
			return;	
		}
		
	//因为头结点，不能动，因此我们需要一个辅助变量来遍历
		HeroNode1 temp = head.next;
		while(true){
			//判断是否到链表最后
			if(temp == null){
				break;
			}
			//输出节点信息
			System.out.println(temp);
			//将temp后移，一定小心
			temp = temp.next;
						
		}	
	}
	
	
	//功能三：添加节点到单向链表，考虑英雄排序，根据排名将英雄插入到指定位置
	//注意：（如果有这个排名，则添加失败，并给出提示）
	public void addByOrder(HeroNode1 heroNode){
		//因为头结点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
		//因为单链表，我们找到的temp是位于添加位置的前一个节点，否则插入不了
		HeroNode1 temp = head;
		boolean flag = false;//flag 标志添加的编号是否存在，默认为false
		while(true){
			
			if(temp.next == null){ //说明temp已经在链表的最后
				break;//				
			}
			
			if(temp.next.no > heroNode.no){//位置找到，就在temp的后面插入
				break;			
			}else if(temp.next.no == heroNode.no){//说明希望添加的heroNode的编号已经存在
				
				flag = true;//说明编号存在
				break;			
			}
			
			temp = temp.next;//后移，遍历当前链表
			
		}
		
		//判断flag的值，根据flag的值判断是否能够添加节点
		if(flag){   //如果flag为真，则说明编号已经存在，不能添加
			System.out.printf("准备插入的英雄的编号 %d 已经存在了，不能加入\n",heroNode.no);			
		}else{
			//插入到链表中，temp的后面
			heroNode.next = temp.next;
			temp.next = heroNode;
			
			
			
		}
		
		
	}
	
	
	
	//功能四：修改节点信息，根据no编号来修改，即no编号不能改
	//说明
	//1.根据 newHeroNode的 no 来修改即可
	public void update(HeroNode1 newHeroNode){
		//判断是否为空
		if(head.next == null){
			System.out.println("链表为空---");
			return;		
		}
		
		
		//找到需要修改的节点，根据no编号
		//定义一个辅助变量
		HeroNode1 temp = head.next;
		boolean flag = false;//表示是否找到该节点
		
		while(true){
			if(temp == null){
				break;//已经遍历完链表		
			}
			if(temp.no == newHeroNode.no){
				//找到
				flag = true;
				break;
			}
			temp = temp.next;
		}
		
		//根据flag判断是否找到要修改的节点
		if(flag){
			temp.name = newHeroNode.name;
			temp.nickname = newHeroNode.nickname;	
		}else{//没有找到
			System.out.printf("没有找到编好 %d 的节点，不能修改\n",newHeroNode.no);	
		}
		
	}
	
	
	
	
	//功能五：删除一个节点
	//思路
	//1.head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
	//2.说明我们在比较时，是temp.next.no和需要删除的节点的no比较
	
	public void del(int no){
		HeroNode1 temp = head;
		boolean flag = false;//标志是否找到待删除节点
		
		
		while(true){
			if(temp.next == null){//已经到链表的最后
				break;
			}
			if(temp.next.no == no){
				//找到的待删除节点的前一个节点temp
				flag = true;
				break;		
			}
			temp = temp.next;//temp后移，遍历
			
			
		}
		
		//判断flag
		if(flag){//找到
			//可以删除
			
			temp.next = temp.next.next;		
		}else{
			System.out.printf("要删除的%d 节点不存在\n",no);			
		}
			
	}

}











class HeroNode1{
	//定义HeroNode,每个HeroNode对象就是一个节点
	public int no;
	public String name;
	public String nickname;
	public HeroNode1 next;//指向下一个节点
	
	//
	public HeroNode1(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 + "]" ;
	}
	
}

运行结果：

HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=卢俊义, nickname=玉麒麟]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]
修改后的链表情况--
HeroNode [no=1, name=宋江, nickname=及时雨]
HeroNode [no=2, name=小卢, nickname=玉麒麟---]
HeroNode [no=3, name=吴用, nickname=智多星]
HeroNode [no=4, name=林冲, nickname=豹子头]
删除后的链表情况----
HeroNode [no=2, name=小卢, nickname=玉麒麟---]
HeroNode [no=3, name=吴用, nickname=智多星]

由此可见，已经实现了英雄人物按编号顺序存储，修改，删除的功能。

---