学习用Java实现一个单向链表

学习用Java实现一个单向链表

用Java实现一个单向链表，完成链表的创建、以及对节点的增删改查

案例：用108个梁山好汉组成链表中的节点

1.用一个对象HeroNode表示单个节点

节点属性除了本身需要保存的数据id、名字、称号外，还需要一个指针指向链表中的下一个节点

（这里并不需要对属性的访问进行特殊控制，直接用了public简化演示代码）

/**
 * 一个HeroNode对象就是一个单向链表中的节点
 */
class HeroNode{

    /**
     * 英雄排名
     */
    public int no;
    /**
     * 名字
     */
    public String name;
    /**
     * 称号
     */
    public String nickname;
    /**
     * 下一个英雄
     */
    public HeroNode next;

    /**
     * 构造器 创建一个梁山好汉
     * @param no 排名
     * @param name 姓名
     * @param nickname 称号
     */
    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 + '\'' +
                '}';
    }
}

2.用一个对象SingleLinkedList表示整个单向链表

在设计单项链表的时候，必须要能够找到头结点，可以选择使用一个不存放具体数据的头节点用一个指针指向它，如果不使用头节点也必须用一个指针指向第一个节点。这里采用有头节点的方式，创建链表的时候就直接初始化一个头节点，好处是头结点绝大多数场景都不需要动

下面案例代码中也有最基础的对链表增删改的操作

• 不写构造器会默认存在一个无参构造器，new一个SingleLinkedList对象即创建了一个单向链表，是包含一个初始化头结点的空链表

• 方法add，表示添加节点到链表中，采用的是尾插方式（将节点插入到链表的末尾，遍历链表找到最后一个节点，将该节点的next指针指向新插入的节点即可）。

  头插方式下面案例中没有，但很简单可以自行思考实现（将新节点的next指针指向插入前的第一个节点head.next，再将head.next指向这个新节点即可）

  头插尾插比较：

  头插无需遍历时间复杂度为常数级O(1)，尾插进行了一次遍历时间复杂度是线性级O(n)

  头插效率更高但插入顺序和遍历顺序相反，尾插效率低但插入顺序和遍历顺序相同

  两种方式各有千秋，可在实际使用时自行判断

  实例中没有进行对no不可重复的判断，可以自行实现作为练习

• 方法addByOrder，也是添加节点到链表中，但是插入是按节点对象的属性no进行排序，思路也非常简单，先确定好排序规则（从小到大、从大到小、是否允许重复、如果允许重复按先后按插入的先后排序等）这里案例采用一个从小到大排序不允许重复的规则，首先还是遍历链表，从头节点开始，如果有下一个节点就进入循环遍历，将新节点no属性值和遍历到的节点的next节点no属性值进行比较，直到发现新节点no小于遍历节点next的no，就将新节点放到当前遍历节点temp和原来temp.next的中间

• 方法update，根据编号修改单向链表中的一个节点，本案例中no不可重复，相当于主键。遍历链表找到no相同的节点进行属性修改即可。

• 方法delete，根据编号删除节点，同理修改，也是遍历找到no相同的节点，但需要注意的是删除时要找到遍历节点的上一个，所以用于遍历的辅助指针要指向正在遍历节点的上一个。找到后，删除时需要将该节点的上一个节点next指针指向它的下一个表示删除（此时被删除的节点没有任何指针指向它，Java的垃圾回收机制会将它从内存中删除）

• 方法show，用来遍历打印链表，方便测试时看到效果

/**
 * 定义SingleLinkedList(单向链表)，用于管理英雄
 */
class SingleLinkedList{

    /**
     * 先初始化一个头节点，头结点不动，也不存放具体数据
     */
    private final HeroNode head = new HeroNode(0,"","");

    /**
     * 添加节点到单向链表（该方法会按添加的顺序排序）
     */
    public void add(HeroNode heroNode){
        //找到当前链表最后一个节点，把next指向这个新的节点
        //遍历链表的临时变量，指向当前正遍历到的节点，从head开始
        HeroNode temp = head;
        //判断当前temp是否存在next不存在说明当前temp指向的节点就是最后一个节点
        while (temp.next != null) {
            //存在就会进入循环，继续遍历，将temp指向当前temp的next
            temp = temp.next;
        }
        //当退出了循环之后，当前temp就是当前链表最后一个节点,将他的next指向正在新增的节点
        temp.next = heroNode;
    }

    /**
     * 添加节点到单向链表（该方法会按排名的顺序排序）
     */
    public void addByOrder(HeroNode heroNode){
        //找到当前链表最后一个节点，把next指向这个新的节点
        //遍历链表的临时变量，指向当前正遍历到的前一个节点，从head开始
        HeroNode temp = head;
        //判断当前temp是否存在next不存在说明当前temp指向的节点就是最后一个节点
        while (temp.next != null) {
            //存在就会进入循环，先判断排名关系。如果和遍历到的节点排名和新插入的相同，抛出异常提示
            if (temp.next.no == heroNode.no){
                throw new RuntimeException("不能插入排名相同的节点");
            }
            //如果遍历到的节点排名大于当前插入节点的排名，说明新节点刚好应该在上一个节点和正在遍历的节点之间，执行插入操作后返回结束方法
            if (temp.next.no > heroNode.no){
                heroNode.next = temp.next;
                temp.next = heroNode;
                return;
            }
            //如果排名比正在遍历的大说明还需要继续遍历，将temp指向当前temp的next进行下一次循环
            temp = temp.next;
        }
        //当退出了循环之后还没有找到应该存放的位子，当前temp就是当前链表最后一个节点,将他的next指向正在新增的节点
        temp.next = heroNode;
    }

    /**
     * 根据编号，修改节点，编号不能修改
     * @param newHeroNode 修改后的英雄信息
     */
    public void update(HeroNode newHeroNode){
        //1.遍历链表，找到要修改的编号no对应的节点
        HeroNode temp = head.next;
        while (temp != null){
            //有节点等待遍历，判断no是否相同
            if (temp.no == newHeroNode.no){
                //相同进行修改，打印修改成功提示，并直接结束方法
                temp.name = newHeroNode.name;
                temp.nickname = newHeroNode.nickname;
                System.out.println("修改成功");
                return;
            }
            //不相同继续遍历下一个
            temp = temp.next;
        }
        //全部遍历完都没有成功修改退出方法，表示没有找到要修改的编号
        System.out.println("未找到编号"+newHeroNode.no+"的英雄，如有需要请直接填加");
    }

    /**
     * 根据编号删除节点
     * @param no 要删除的节点编号
     */
    public void delete(int no){
        //遍历，让指针指向要遍历的上一个
        HeroNode temp = head;
        while (temp.next!=null){
            //判断当前遍历的节点是否是要删除的节点，如果是进行删除，给出删除成功提示，并结束方法，如果不是继续遍历下一个
            if (temp.next.no == no) {
                temp.next = temp.next.next;
                System.out.println("删除成功");
                return;
            }
            temp = temp.next;
        }
        //退出循环后还没有结束，表示没有找到要删除的节点
        System.out.println("未找到要删除的节点"+no);
    }

    /**
     * 显示链表【遍历】
     */
    public void show(){
        //先判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //遍历链表的临时变量，指向当前正遍历到的节点，从head的next开始，也就是从第一个开始
        HeroNode temp = head.next;
        //当前正遍历到的节点不为空的时候，打印当前节点，并将temp指向next继续参与遍历，知道temp为空表示遍历结束
        while (temp != null){
            System.out.println(temp);
            temp = temp.next;
        }
    }

}

3.进阶

至此就已经用Java完成了一个简单的单向链表，下面再完成几个面试题

下面案例实现都是笔者自己的思路，答案并不唯一，大家也可以尝试思考一些新的思路来完成

• 新浪面试题：查找单链表中的倒数第k个节点

  这个问题可以有两个思路

  编写一个方法，接收一个参数index，表示题目中的k

  思路1：首先遍历得到总节点数length，用length-index就能得到所需节点正着数的位置，正着遍历，只需要一个fori循环去寻找对应节点就容易了

  思路2：双指针遍历，第一个指针先进行遍历，当指向第k个元素时，第二个指针指向第一个节点加入遍历，然后开始同时继续向下一个节点遍历，判断当第一个指针遍历到最后一个节点时，第二个指针停留的位置就是指向所需找到的倒数第k个节点

  效率分析：

  思路1的时间复杂度，应该是T(n)=2n-k=O(n)

  思路2的时间复杂度，因为两个指针同时在遍历，开始到结束相当于是一次完整的遍历循环T(n)=n=O(n)

      /**
       * 先写一个方法，求单链表中的节点个数,不含头节点
       *
       * @return 链表节点个数
       */
      public int getLength(){
          //如果头结点没有下一个指向，说明是空链表
          if (head.next==null) {
              return 0;
          }
          //用来记录节点个数的变量
          int length = 0;
          //辅助变量，用来指向即将遍历到的节点
          HeroNode cur = head.next;
          //遍历链表，每个节点给length+1
          while (cur !=null){
              length++;
              cur = cur.next;
          }
          //遍历结束后返回length就是节点个数
          return length;
      }   
  	/*再进行解题*/
  
  	/**
  	 * 思路1
  	 */
  	public HeroNode getLastIndexNode(int index){
          //getLength方法获取当前链表总长度，判断如果小于index，返回null表示找不到
          int length = getLength();
          if (length <index){
              return null;
          }
          //总长度如果等于index，直接返回第一个节点
          if (length==index){
              return head.next;
          }
          //否则就遍历length-index次
          HeroNode curNode = head.next;
          for (int i = 0; i < length - index; i++) {
              curNode = curNode.next;
          }
          return curNode;
      }
  
  	/**
  	 * 思路2
  	 */
      public HeroNode getLastIndexNode2(int index){
          //定义一个快指针,一个慢指针，初始都指向头节点
          HeroNode fastPointer = head;
          HeroNode slowPointer = head;
          //快指针先出发，多前进index-1次，此后两指针一同前进，直到快指针指向了最后一个节点跳出循环
          while (fastPointer.next!=null){
              if (index-1>0){
                  fastPointer = fastPointer.next;
                  index--;
              }else {
                  fastPointer = fastPointer.next;
                  slowPointer = slowPointer.next;
              }
          }
          //此时的慢指针就是倒数第k个节点，但是如果慢指针还是指向头节点说明总节点数小于k，返回空
          if (slowPointer==head){
              return null;
          }
          return slowPointer;
      }
  

• 腾讯面试题：反转单链表

  笔者想到两种思路

  思路1：创建一个新的链表，将原链表按顺序遍历，一个个拆下来用头插的方式插入新链表，即可完成链表的反转（也要注意拆下来之后原链表会断掉，需要辅助指针记录原链表的下一个作为下次遍历的节点）

  思路2：有点绕，不太好描述，看不明白就跟着代码读一下。需要使用到两个辅助指针，一个指向正在遍历节点的上一个，一个指向下一个要遍历的节点，每次遍历将遍历的节点指向上一个遍历的节点（要注意的就是，正在遍历的节点的next指向会改变为他的上一个节点，所以在改变前需要用两个变量记录好改变之前的上一个和下一个节点，还有对第一个节点和头节点的特殊处理）

  两种思路，时间复杂度是一样的，都是一次完整的循环，但空间复杂度上思路2会少创建一个链表

  这里只展示一个思路2，思路1比较简单大家可以自己练习

      public void reverseList(){
          //先判断是否是空链表,空链表什么也不操作
          if (head.next==null){
              return;
          }
          //一个指针指向第一个节点，用于遍历结束后将其next设置为空，否则会出现环
          HeroNode first = this.head.next;
          //辅助节点，指向要遍历节点反转前的上一个节点
          HeroNode last = this.head.next;
          //辅助节点，指向下一个要遍历的节点
          HeroNode cur = this.head.next.next;
          //开始从第二个节点进入遍历
          while (true){
              //如果cur为空，说明已经遍历结束，将头结点指向当前遍历的前一个节点，也就是最后一个节点，然后退出循环
              if (cur==null){
                  head.next = last;
                  break;
              }else {
                  //不为空说明需要继续遍历，先用临时变量t保存好正在遍历的节点下一个节点（就是下一次遍历的节点）
                  HeroNode t;
                  t = cur.next;
                  //然后将正在遍历节点的next设置为上一个节点
                  cur.next = last;
                  //再将正在遍历的节点设置为下一次循环时要用到的上一个节点
                  last = cur;
                  //最后将下一次循环要遍历的节点设置为之前存下的临时变量t
                  cur = t;
              }
          }
          //最后在循环结束后将反转前第一个节点的next置空（他已经是最后一个节点了）
          first.next = null;
      }
  

• 百度面试题：从尾到头打印单链表

  这里还是提供两种思路

  思路1：很简单，上一题做到了反转单向链表，可以先反转再顺序打印即可

  思路2：但是反正会破坏原来的链表，如果要求不能改变要打印的链表，就需要再反转回来…这时可以想到一个先进后出的数据结构——栈来辅助解决问题。顺序遍历链表将数据压入栈，再按出栈顺序打印即可完成逆序打印

  这里实现使用java.util包的Stack。后续会更新用Java写一个简单的栈实现

      /**
       * 借助栈，逆序打印链表
       */
      public void showReverseListByStack(){
          //判断链表为空直接结束
          if (head.next==null){
              return;
          }
          //创建一个栈，将节点遍历压入栈中
          Stack<HeroNode> stack = new Stack<>();
          HeroNode cur = head.next;
          while (cur!=null){
              stack.push(cur);
              cur = cur.next;
          }
          //将栈遍历弹出打印
          while (stack.size()>0) {
              System.out.println(stack.pop());
          }
      }
  

4.练习

大家可以做一个简单的小练习

练习：创建两个有序单链表a和b，将b合并到a，要求合并后a还是有序单链表

思路：将b顺序遍历，一个个拆下来，按照有序的插入方式插入到a中即可

可以关注公众号：

回复 单链表 即可获得练习题结果代码（包含在完整案例Demo演示代码中）