JAVA算法与数据结构——单链表的应用实例(1)

链表(Linked List)介绍

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

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

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

单链表的应用实例

使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作，

1. 第一种方法在添加英雄时，直接添加到链表的尾部 思路分析示意图:
   
2. 第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示) 思路的分析示意图:
   
3. 修改节点功能 思路(1) 先找到该节点，通过遍历，(2) temp.name = newHeroNode.name ; temp.nickname= newHeroNode.nickname
4. 删除节点 思路分析的示意图:
   

//定义 HeroNode ， 每个 HeroNode 对象就是一个节点 
class 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 + "]"; 
  } 
  }

//添加节点到单向链表 
//思路，当不考虑编号顺序时 
//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 
  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 的值 
 if(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(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; 
  }
  //根据 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) {
HeroNode 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);
    } 
    }

//显示链表[遍历] 
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; } 
 }
  }