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

最新推荐文章于 2022-06-16 09:23:40 发布

CHH3213

最新推荐文章于 2022-06-16 09:23:40 发布

阅读量868

点赞数 2

分类专栏： # java基础数据结构与算法文章标签：链表数据结构算法

本文链接：https://blog.csdn.net/weixin_42301220/article/details/122726368

版权

java基础同时被 2 个专栏收录

34 篇文章 23 订阅

订阅专栏

数据结构与算法

12 篇文章 4 订阅

订阅专栏

参考资料

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

1. 链表介绍

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

链表是以节点的方式来存储,是链式存储
每个节点包含data域, next域:指向下一个节点.
链表的各个节点不一定是连续存储.
链表分带头节点的链表和没有头节点的链表,根据实际的需求来确定

2. 单链表(带头结点)

逻辑结构

2.1 应用实例

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

2.1.1 添加方式1

第一种方法在添加英雄时,直接添加到链表的尾部
1. 先创建一个head头节点,作用就是表示单链表的头
2. 后面我们每添加一个节点,就直接加入到链表的最后

遍历
通过一个辅助变量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 实现步骤总结

首先创建节点（java中节点可以用类的形式呈现，即创建一个节点类，包含相关的data信息和next域）
创建一个head头节点,作用就是表示单链表的头，无具体数据。head节点不能动
添加节点：由于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）如果节点已存在，则不再添加
修改节点
1. 通过使用临时指针temp遍历链表，找到所要修改的节点；
2. temp.data=modifyNode.data
删除节点
1. 找到需要删除的这个节点的前一个节点temp
2. temp.next = temp.next.next
3. 被删除的节点,将不会有其它引用指向,会被垃圾回收机制回收

代码实现

2.3 单链表常见面试题（新浪，腾讯，百度）

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

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 链表的反转

在这里插入图片描述

思路:

定义一个辅助指针temp，用于遍历原来的链表；temp开始时指向head.next：Node temp = head.next;
定义一个节点reverseHead = new HeroNode();

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

 //暂时保存当前节点的下一节点
 next = temp.next;
 //将temp的下一节点指向新的链表的最前端
 temp.next = reverseHead.next;
 //将temp连接到新的链表上
 reverseHead.next = temp;
 //将temp连接到新的链表上
 temp = next;

原来的链表的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;
            }
        }

    }

以上所有完整代码见于gitee仓库

3. 双向链表

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

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

在这里插入图片描述

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

遍历和单链表一样,只是可以向前,也可以向后查找
添加(默认添加到双向链表的最后)
1. 先找到双向链表的最后这个节点
2. temp.next = newHeroNode
3. newHeroNode.pre = temp
修改思路和原来的单向链表一样.
删除
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结束
删除节点与单链表思路一样
约瑟夫问题的思路分析
代码实现

CHH3213

关注

2
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
【尚硅谷_数据结构与算法】三、链表

文章目录参考资料1. 链表介绍2. 单链表(带头结点)2.1 应用实例2.1.1 添加方式12.1.2 添加方式22.1.3 删除2.1.4 修改节点2.2 实现步骤总结2.3 单链表常见面试题（新浪，腾讯，百度）2.3.1 求单链表中有效节点的个数2.3.2 查找单链表中的倒数第k个结点2.3.3 链表的反转参考资料https://www.bilibili.com/video/BV1E4411H73v?p=16&spm_id_from=pageDriver1. 链表介绍链表是有序的列表,
复制链接

扫一扫