1.4 单向链表

  • 基本介绍

    • 链表是一个有序的列表,以节点的方式存储,是链式存储
    • 每个节点包含data域和next域,指向下一个节点
    • 链表的各个节点不一定是连续存储
    • 链表分为带头节点的链表和不带头结点的链表
  • 代码实现

  • public 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(hero3);
          // singleLinkedList.add(hero2);
          // singleLinkedList.add(hero4);
    
          // 有序添加
          singleLinkedList.addByOrder(hero1);
          singleLinkedList.addByOrder(hero2);
          singleLinkedList.addByOrder(hero4);
          singleLinkedList.addByOrder(hero3);
          singleLinkedList.list();
    
          // 根据编号修改节点
          HeroNode newHero = new HeroNode(2,"小卢","玉麒麟~~");
          singleLinkedList.update(newHero);
          System.out.println("修改后的链表");
          singleLinkedList.list();
    
          // 删除节点
          singleLinkedList.delete(1);
          System.out.println("删除后的链表");
          singleLinkedList.list();
       }
    }
    // 链表操作类
    class SingleLinkedList {
       // 创建头节点 不能动
       private HeroNode head = new HeroNode(0,"","");
    
       public HeroNode getHead() {
          return head;
       }
    
       // 添加节点
       public void add(HeroNode heroNode) {
          // 存放指针 并寻找最后一个节点
          HeroNode temp = head;
          while (null != temp.next) {
              // 指针后移
              temp = temp.next;
          }
          temp.next = heroNode;
       }
    
       // 添加节点并排序
       public void addByOrder(HeroNode heroNode) {
          HeroNode temp = head;
          boolean flag = false;
          while (null != temp.next) {
              if (temp.next.no > heroNode.no) {
                  break; // 找见要插入的位置
              } else if (temp.next.no == heroNode.no) {
                  flag = true;
                  break; // 插入的位置已存在
              }
              temp = temp.next;
          }
          if (flag) {
              System.out.printf("准备插入的英雄的编号 %d 已经存在了,不能加入\n",heroNode.no);
          } else {
              // 注意顺序不能变 如果先变前面的指针 就获取不到后一个指针的位置了
              heroNode.next = temp.next;
              temp.next = heroNode;
          }
       }
    
       // 根据序号修改节点
       public void update(HeroNode newHeroNode) {
          // 直接从第一个节点查找
          HeroNode temp = head.next;
          boolean flag = false;
          while (null != temp) {
              if (temp.no == newHeroNode.no) {
                  flag = true;
                  break; // 找见要修改的位置
              }
              temp = temp.next;
          }
          if (flag) {
              temp.name = newHeroNode.name;
              temp.nickname = newHeroNode.nickname;
          } else {
              System.out.printf("没有找到 编号 %d 的节点,不能修改\n",newHeroNode.no);
          }
       }
    
       // 根据序号删除节点
       public void delete(int no) {
          // 不能删除头结点(只能从头结点开始寻找 否则不能找见第一节点)
          // 找要删除节点的前一个节点 不能寻找本身 因为寻找到本身就会丢失上一个节点
          HeroNode temp = head;
          boolean flag = false;
          while (null != temp.next) {
              if (temp.next.no == no) {
                  flag = true;
                  break; // 找见要删除的前一个的位置
              }
              temp = temp.next;
          }
          if (flag) {
              temp.next = temp.next.next;
          } else {
              System.out.printf("要删除的 %d 节点不存在\n",no);
          }
       }
    
       // 显示链表
       public void list() {
          if (null == head.next) {
              return;
          }
          HeroNode temp = head.next;
          while (null != temp) {
              System.out.println(temp);
              temp = temp.next;
          }
       }
    }
    // 链表节点类
    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;
       }
       @Override
       public String toString() {
          return "HeroNode{" +
                  "no=" + no +
                  ",name='" + name + '\'' +
                  ",nickname='" + nickname + '\'' +
                  '}';
       }
    }
    

相关文章

背景:计算机内部用补码表示二进制数。符号位1表示负数,0表...
大家好,我们现在来讲解关于加密方面的知识,说到加密我认为不...
相信大家在大学的《算法与数据结构》里面都学过快速排序(Qui...
加密在编程中的应用的是非常广泛的,尤其是在各种网络协议之...
前言我的目标是写一个非常详细的关于diff的干货,所以本文有...
对称加密算法 所有的对称加密都有一个共同的特点:加密和...