单链表原理及应用举例
单链表是一种链式存取的数据结构，单链表中的数据是以结点的形式存在，每一个结点是由数据元素和下一个结点的存储的位置组成。单链表与数组相比的最大差别是：单链表的数据元素存放在内存空间的地址是不连续的，而数组的数据元素存放的地址在内存空间中是连续的，这也是为什么根据索引无法像数组那样直接就能查询到数据元素。
单链表的逻辑结构如下（带头节点）：
链表是有序的列表，他在内存中的存储结构如下：
1.链表是以节点的方式来存储，是链式存储
2.每个节点都包含data域和next域：指向下一个节点
3.链表的各个节点不一定是连续存储的
4.链表分带头节点的链表和没有头节点的链表（根据实际需求来确定）
5.head节点：不存放具体的数据，作用就是表示单链表的头
应用举例
使用带头节点的单链表实现水浒英雄排名，进行基本增删改查操作
添加思路分析：
第一种：直接在链表尾部添加新英雄
第二种：通过排名（no）来指定插入英雄位置
分析示意图如下：
1.head节点不能动，因此我们需要定义一个temp辅助节点找到待添加的节点的前一个节点，通过遍历实现
2.新节点.next=temp.next
3.temp.next=新节点.next
代码实现
package com.atxihua; import java.util.Stack; public class SingleLinkedListDemo { public static void main(String[] args) { //测试 //先创建节点 HeroNode hero4=new HeroNode(4,"林冲","豹子头"); HeroNode hero3=new HeroNode(3,"吴用","智多星"); HeroNode hero2=new HeroNode(2,"卢俊义","玉麒麟"); HeroNode hero1=new HeroNode(1,"宋江","及时雨"); SingleLinkedList singleLinkedList=new SingleLinkedList(); //添加到链表 // singleLinkedList.add(hero1); // singleLinkedList.add(hero2); // singleLinkedList.add(hero3); // singleLinkedList.add(hero4); //按照编号排序添加 singleLinkedList.addByOrder(hero1); singleLinkedList.addByOrder(hero2); singleLinkedList.addByOrder(hero3); singleLinkedList.addByOrder(hero4); //显示链表 singleLinkedList.list(); //测试修改节点信息 //修改吴用的nickname HeroNode newHeroNode=new HeroNode(3,"吴用","智多星偏偏无用"); singleLinkedList.update(newHeroNode); System.out.println("修改后的链表"); singleLinkedList.list(); //删除豹子头林冲 singleLinkedList.del(4); System.out.println("删除节点后的链表"); singleLinkedList.list(); //后面的测试方法为大厂面试题 System.out.println("求单链表的节点个数"); System.out.println(singleLinkedList.getLength(singleLinkedList.getHead())); //测试一下看看是否得到了倒数第K个节点 HeroNode res=singleLinkedList.findLastKNode(singleLinkedList.getHead(),1); System.out.println(res); //反转单链表 singleLinkedList.reverseList(singleLinkedList.getHead()); singleLinkedList.list(); System.out.println("逆向打印单链表"); singleLinkedList.reversePrint(singleLinkedList.getHead()); } } //定义HeroNode,每个HeroNode对象就是一个节点 class HeroNode{ public int no; public String name; public String nickname; //指向下一个节点 public HeroNode next; //构造器 public HeroNode(int hNo,String hName,String hNickName){ this.no=hNo; this.name=hName; this.nickname=hNickName; } //为了显示方便，重写toString @Override public String toString() { return "HeroNode{" + "no=" + no + ", name='" + name + '\'' + ", nickname='" + nickname + '\'' + ", next=" + next + '}'; } } //定义一个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){ //因为head节点不能动，因此我们需要一个辅助遍历temp HeroNode temp=head; //flag标志添加的编号是否存在，默认为false boolean 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){ //说明该位置排名已有其他英雄,该编号已存在 flag=true; break; } //如果没有找到，将temp后移 temp=temp.next; } if(flag){//不能添加，说明编号存在 System.out.println("该英雄排名的位置已有其他英雄！！！"+heroNode.no); }else { //插入到链表中，temp的后面 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; } //未找到，后移 temp=temp.next; } if(flag){ temp.name= newHeroNode.name; temp.nickname= newHeroNode.nickname; }else{ System.err.println("该英雄不存在！！！请检查输入排名是否正确"); } } //删除节点 //1.head不能动，因此我们需要定义一个temp辅助节点找到待删除的节点的前一个节点 //2.我们在比较时，是比较temp.next.no和需要删除节点的no public void del(int no){ //判断链表是否为空 if(head.next==null){ System.out.println("链表为空"); return; } HeroNode temp=head; //flag标志是否找到待删除的节点 boolean flag=false; //遍历链表，找到最后一个节点 while (true){ if(temp.next==null){ //说明temp已经在链表的最后 break; } if(temp.next.no>no){ //说明位置已找到 break; }else if(temp.next.no==no){ //说明找到待删除节点的前一个节点temp flag=true; break; } //如果没有找到，将temp后移,遍历 temp=temp.next; } if(flag){//找到，可以删除 temp.next=temp.next.next; }else { System.err.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; } } public HeroNode getHead() { return head; } //求链表的有效节点个数 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个节点（新浪面试题） //编写一个方法，接受head节点，同时接收一个K //先把链表从头到尾遍历，得到链表的总长度getLength //得到长度size后，我们从链表的第一个开始遍历(size-K)个就可以了 //如果找到，则返回该节点，否则返回null public static HeroNode findLastKNode(HeroNode head,int K){ //判断链表是否为空，返回null if(head.next==null){ return null;//没找到 } //遍历得到链表长度 int size=getLength(head); //第二次遍历size-K的位置 //先做校验 if(K<=0||K>size){ return null; } //定义给辅助变量，for循环定位到倒是K的位置 HeroNode cur=head.next; for(int i=0;i<size-K;i++){ cur=cur.next; } return cur; } /* 单链表的反转，腾讯面试题 * 思路： * 先定义一个节点reverseHead=new HeroNode(); * 从原来的链表从头遍历每一个节点，将其取出，并放在新的链表reverseHead的最前端 * 原来的链表的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,"",""); while (cur!=null){ next=cur.next;//先暂时保存当前节点的下一个节点，因为后面需要使用 cur.next=reverseHead.next;//将cur的下一个节点指向新的链表的最前端 reverseHead.next=cur;//将cur连接到新链表上 cur=next;//让cur后移 } //将head.next指向reveseHead.next,实现单链表的反转 head.next=reverseHead.next; } /* * 从头到尾打印单链表（百度） * 思路 * 1.先将单链表进行反转操作，然后遍历即可，这样做会破坏原来的单链表结构，不建议 * 2.可以利用栈这个数据结构，将各个节点压入到栈中，利用栈先进后出的特点，就实现了逆序打印 * */ public static void reversePrint(HeroNode head){ if(head.next==null){ return;//空链表，无法打印 } //创建一个栈，将各个节点压入栈中 Stack<HeroNode> stack=new Stack<HeroNode>(); HeroNode cur=head.next; //将链表中的所有节点压入栈中 while (cur!=null){ stack.push(cur); cur=cur.next;//cur后移，继续压入下一节点 } //将栈中的节点进行打印，pop出栈 while (stack.size()>0){ System.out.println(stack.pop());//先进后出 } } }
结果展示：
结果与预期结果一致，达到使用单链表实现的预期结果。
后面的大厂面试题结果没有展示，只有反转单链表有点麻烦。
思路分析图如下：
代码分析
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,"",""); while (cur!=null){ //先暂时保存当前节点的下一个节点，因为后面需要使用,此时，cur=数据2，next=数据5 next=cur.next; //将cur的下一个节点指向新的链表的最前端，此时，新的reverseHead头指针指向数据5 cur.next=reverseHead.next; //将cur连接到新链表上，此时reverHead的头指针指向数据5，在数据5之后增加了节点2，此时单链表为reverseHead=>5=>2 reverseHead.next=cur; //让cur后移,此时cur=5，重复上述操作，最终得到reverseHead=>9=>5=>2 cur=next; } //将head.next指向reveseHead.next,实现单链表的反转, // 此时reverseHead单链表已经实现反转， // 原来的单链表结构已经破坏，将原来的单链表的头指针，指向reverseHead的第一个节点，即得到反转后的单链表 head.next=reverseHead.next; }
