【尚硅谷_数据结构与算法】三、链表

参考资料

https://www.bilibili.com/video/BV1E4411H73v?p=16&spm_id_from=pageDriver

1. 链表介绍

  • 链表是有序的列表,它在内存中是存储如下
    在这里插入图片描述
  1. 链表是以节点的方式来存储,是链式存储
  2. 每个节点包含data域, next域:指向下一个节点.
  3. 链表的各个节点不一定是连续存储.
  4. 链表分带头节点的链表和没有头节点的链表,根据实际的需求来确定

2. 单链表(带头结点)

  • 逻辑结构
    在这里插入图片描述

2.1 应用实例

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

2.1.1 添加方式1

  1. 第一种方法在添加英雄时,直接添加到链表的尾部
    1. 先创建一个head头节点,作用就是表示单链表的头
    2. 后面我们每添加一个节点,就直接加入到链表的最后
  1. 遍历
    通过一个辅助变量temp帮助遍历整个链表,temp一开始赋值为head

在这里插入图片描述

2.1.2 添加方式2

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

  • 思路的分析示意图:
    在这里插入图片描述

  • 添加

    1. 首先找到新添加的节点的位置,是通过辅助变量(指针),通过遍历来搞定
    2. 新的节点.next = temp.next
    3. temp.next=新的节点

2.1.3 删除

在这里插入图片描述

  • 从单链表中删除一个节点的思路
    1. 我们先找到需要删除的这个节点的前一个节点temp
    2. temp.next = temp.next.next
    3. 被删除的节点,将不会有其它引用指向,会被垃圾回收机制回收

2.1.4 修改节点

通过临时指针temp遍历,找到要修改的节点,然后修改数据即可:temp.data=modifyNode.data.

2.2 实现步骤总结

  1. 首先创建节点(java中节点可以用类的形式呈现,即创建一个节点类,包含相关的data信息和next域)

  2. 创建一个head头节点,作用就是表示单链表的头,无具体数据。head节点不能动

  3. 添加节点:由于head节点不能动,因此我们需要一个辅助指针temp用来遍历:Node temp = head;

    • 方式一:直接在链表尾部添加:
      1)遍历链表,找到当前链表的最后节点;
      //遍历链表
      while(temp.next!=null){
          temp=temp.next;
      }
      //当退出while循环时, temp就指向了链表的最后
      
      2)将最后这个节点的next指向新的节点:
      temp.next=newNode;
    • 方式二:在指定位置添加
      1)如果temp一开始便是链表的最后节点,则退出循环;否则遍历链表temp=temp.next;,根据所要插入节点的序号确定temp位置,最终找到的temp是位于所要添加位置的前一个节点。
      2)新的节点.next = temp.next
      3)temp.next=新的节点
      4)如果节点已存在,则不再添加
  4. 修改节点

    1. 通过使用临时指针temp遍历链表,找到所要修改的节点;
    2. temp.data=modifyNode.data
  5. 删除节点

    1. 找到需要删除的这个节点的前一个节点temp
    2. temp.next = temp.next.next
    3. 被删除的节点,将不会有其它引用指向,会被垃圾回收机制回收

2.3 单链表常见面试题(新浪,腾讯,百度)

  1. 求单链表中有效节点的个数
  2. 查找单链表中的倒数第k个结点【新浪面试题】
  3. 单链表的反转【腾讯面试题,有点难度】
  4. 从尾到头打印单链表【百度,要求方式1:反向遍历。方式2: Stack栈】
  5. 合并两个有序的单链表,合并之后的链表依然有序

2.3.1 求单链表中有效节点的个数

 /**
  * 获取有效节点个数,不包括头节点
  * @return
  */
 public int getLength(){
     Node temp=head.next;
     int len =0;
     while(temp!=null){
         temp = temp.next;
         len++;
     }
     return len;
 }

2.3.2 查找单链表中的倒数第k个结点

    /**
     * 获取有效节点个数,不包括头节点
     * @return
     */
    public int getLength(){
        Node temp=head.next;
        int len =0;
        while(temp!=null){
            temp = temp.next;
            len++;
        }
        return len;
    }

    /**
     *  查找单链表中的倒数第k个结点
     * @param k 倒数第k个结点
     * @return 查找到的节点
     */
    public Node findNode(int k){
        //倒数第k个结点即为正数n-k个节点,n为链表长度
        Node temp = head;
        for(int i=0;i<getLength()+1-k;i++){
            temp = temp.next;
        }
        return temp;
    }

2.3.3 链表的反转

在这里插入图片描述

思路:

  1. 定义一个辅助指针temp,用于遍历原来的链表;temp开始时指向head.nextNode temp = head.next;

  2. 定义一个节点reverseHead = new HeroNode();

  3. 从头到尾遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表reverseHead的最前端

     //暂时保存当前节点的下一节点
     next = temp.next;
     //将temp的下一节点指向新的链表的最前端
     temp.next = reverseHead.next;
     //将temp连接到新的链表上
     reverseHead.next = temp;
     //将temp连接到新的链表上
     temp = next;
    
  4. 原来的链表的head.next = reverseHead.next
    在这里插入图片描述

    /**
     * 反转链表
     */
     public void reverseList(){
         //如果当前链表为空,或者只有一个节点,无需反转,直接返回
         if(head.next==null||head.next.next==null){
             return;
         }
         Node temp = head.next;
         // 指向当前节点的下一个节点
         Node next = null;
         //定义新的头节点作为反转后链表的头节点
         Node reverseHead = new Node();
         //从头到尾遍历原来的链表,每遍历一个节点,就将其取出,并放在新的链表`reverseHead`的最前端
         while(temp!=null){
             //暂时保存当前节点的下一节点
             next = temp.next;
             //将temp的下一节点指向新的链表的最前端
             temp.next = reverseHead.next;
             //将temp连接到新的链表上
             reverseHead.next = temp;
             //将temp后移
             temp = next;
         }
         //将head.next指向reverseHead.next,实现单链表的反转
         head.next = reverseHead.next;
    
     }
    

2.3.4 从尾到头打印单链表

  • 方式1:先将单链表进行反转操作,然后再遍历即可,这样的做的问题是会破坏原来的单链表的结构,不建议

  • 方式2:可以利用栈这个数据结构,将各个节点压入到栈中,然后利用栈的先进后出的特点,就实现了逆序打印的效果.

     /**
         * 利用栈这个数据结构,将各个节点压入到栈中,
         * 然后利用栈的先进后出的特点,就实现了逆序打印的效果.**
         */
        public void reversePrint(){
            if(head.next==null){
                System.out.println("链表为空");
                return;
            }
            //创建一个栈,将各个节点压入栈
            Stack<Node> stack = new Stack<>();
            Node cur = head.next;
            //将链表所有的节点压入栈
            while(cur!=null){
                stack.push(cur);
                cur = cur.next;
            }
            //将栈中的节点pop出栈,并打印
            while (stack.size()>0){
                System.out.println(stack.pop());
    
            }
        }
    

2.3.5 合并两个有序的单链表,合并之后的链表依然有序

参考:合并两个有序的单链表,合并后依然有序

public void twoLinkedList(Node head1, Node head2, Node head3){
        // 如果两个链表均为空,则无需合并,直接返回
        if(head1.next==null&&head2.next==null){
            return;
        }
        // 如果链表1为空,则将head3.next指向head2.next,实现链表2中的节点连接到链表3
        if(head1.next==null){
            head3.next = head2.next;
        }else{
            // 将head3.next指向head1.next,实现链表1中的节点连接到链表3
            head3.next=head1.next;
            // 定义一个辅助的指针(变量),帮助我们遍历链表2
            Node cur2 = head2.next;
            // 定义一个辅助的指针(变量),帮助我们遍历链表3
            Node cur3 = head3;
            Node next =null;
            // 遍历链表2,将其节点按顺序连接至链表3
            while (cur2!=null){
                // 链表3遍历完毕后,可以直接将链表2剩下的节点连接至链表3的末尾
                if(cur3.next==null){
                    cur3.next=cur2;
                    break;
                }
                // 在链表3中,找到第一个大于链表2中的节点编号的节点
                // 因为是单链表,找到的节点是位于添加位置的前一个节点,否则无法插入
                if(cur2.rank<= cur3.next.rank){
                    // 先暂时保存链表2中当前节点的下一个节点,方便后续使用
                    next = cur2.next;
                    // 将cur2的下一个节点指向cur3的下一个节点
                    cur3.next = cur2.next;
                    // 将cur2连接到链表3上
                    cur3.next = cur2;
                    cur2 = next;
                }
                cur3 = cur3.next;
            }
        }

    }

3. 双向链表

3.1 管理单向链表的缺点分析:

  1. 单向链表,查找的方向只能是一个方向,而双向链表可以向前或者向后查找。
  2. 单向链表不能自我删除,需要靠辅助节点,而双向链表,则可以自我删除,所以单链表删除节点时,总是找到待删除节点的前一个节点。

在这里插入图片描述

3.2 遍历,添加,修改,删除的操作思路

  1. 遍历和单链表一样,只是可以向前,也可以向后查找
  2. 添加(默认添加到双向链表的最后)
    1. 先找到双向链表的最后这个节点
    2. temp.next = newHeroNode
    3. newHeroNode.pre = temp
  3. 修改思路和原来的单向链表一样.
  4. 删除
    1. 因为是双向链表,因此,我们可以实现自我删除某个节点
    2. 直接找到要删除的这个节点,比如用temp表示
    3. temp.pre.next = temp.next
    4. temp.next.pre = temp.pre; //如果是最后一个节点,就不需要执行这句话,否则出现空指针

4. 单向环形链表

4.1 应用场景(约瑟夫环问题)

  • Josephu 问题为:设编号为1, 2, …, n的n个人围坐一圈,约定编号为k (1<=k<=n)的人从1开始报数,数到m的那个人出列,它的下一位又从1开始报数,数到m的那个人又出列,依次类推,直到所有人出列为止,由此产生一个出队编号的序列。

  • 提示:用一个不带头结点的循环链表来处理Josephu问题:先构成一个有n个结点的单循环链表,然后由k结点起从1开始计数,计到m时,对应结点从链表中删除,然后再从被删除结点的下一个结点又从1开始计数,直到最后一个结点从链表中删除算法结束。

4.2 创建环形链表的思路

  • 构建一个单向的环形链表思路

    1. 先创建第一个节点,让first指向该节点,并形成环形。声明一个辅助指针cur,初始时cur指向first
       first = new_node;
       //构成环
       first.next=first;
       //让辅助指针指向第一个节点
       cur = first;
      
    2. 后面当我们每创建一个新的节点,就把该节点加入到已有的环形表中。
       cur.next=new_node;
       new_node.next=first;
       cur = new_node;
      
  • 遍历环形维表

    1. 先让一个辅助指针(变量) cur,指向first节点
    2. 然后通过一个while循环遍历该环形链表即可。cur.next ==first结束
  • 删除节点与单链表思路一样

  • 约瑟夫问题的思路分析
    在这里插入图片描述

  • 代码实现

  • 2
    点赞
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CHH3213

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值