数组和链表 (From Day 2 & Day 3)

最新推荐文章于 2022-11-14 21:43:48 发布
最新推荐文章于 2022-11-14 21:43:48 发布
阅读量98 收藏
点赞数
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luotianyi1/article/details/105407730
版权

1.数组

1）数组的三个问题
  1. 数组我们都很熟悉，那你理解的数组是什么样的呢？它的最主要特点是什么呢？

A1:数组的本质是固定大小的连续的内存空间，并且这片连续的内存空间又被分割成等长的小空间。
   它最主要的特点是随机访问。
   
   数组的缺点：

   1.数组的长度是固定的
   2.数组只能存储同一种数据类型的元素

注意：在Java中只有一维数组的内存空间是连续，多维数组的内存空间不一定连续。

那么数组又是如何实现随机访问的呢？

通过寻址公式：i_address = base_address + i * type_length
  1. 为什么数组的索引是一般都是从0开始的呢？

假设索引不是从0开始的，而是从1开始的，那么我们有两种处理方式：

1.寻址公式变为： i_address = base_address + (i – 1) * type_length

2.浪费开头的一个内存空间，寻址公式不变。

在计算机发展的初期，不管是CPU资源，还是内存资源都极为宝贵，
所以在设计编程语言的时候，索引就从0开始了，而我们也一直延续了下来。
  1. 为什么数组的效率比链表高？

CPU、内存和IO设备，它们传输数据的速率是存在很大差异的，怎么个差异呢？
     举个例子，CPU一天，内存一年；内存一天，IO十年。

根据木桶理论：木桶能装多少水，取决于最短的那块木板。
那么程序的性能主要取决于IO设备的性能？也就是说，我们提升CPU和内存的传输速率收效甚微。

实际是这样的吗？当然不是！那我们是怎么解决它们之间的速率差异的呢？

1.CPU 和 内存
      高速缓存
      编译器的指令重排序

2.内存和 IO
      缓存：将磁盘上的数据缓存在内存。

3.CPU 和 IO
      中断技术

数组可以更好地利用CPU的高速缓存！
2）数组的效率和特点
数组的基本操作

1.添加 (保证元素的顺序)
      最好情况：O(1)

      最坏情况：移动n个元素，O(n)

      平均情况：移动 n/2 个元素，O(n)

2.删除 (保证元素的顺序)
     最好情况：O(1)

     最坏情况：移动n-1个元素，O(n)

     平均情况：移动(n-1)/2个元素，O(n)


3.查找
     a. 根据索引查找元素：O(1)

     b. 查找数组中与特定值相等的元素

           1.大小无序：O(n)

           2.大小有序：O(log2n)    

总结: 数组增删慢，查找快。

数组的基本操作

2.链表

1）概念

在这里插入图片描述

2）分类

在这里插入图片描述

3）单链表和双向链表的特点和效率
  1. 单链表
 循环链表我们用的一般比较少，但是当处理的数据具有环形结构时，就特别适合用循环链表，
 比如约瑟夫问题。接下来我们讨论下单链表和双向链表。

单链表：

1.增加(在某个结点后面添加)

2.删除(在某个结点后面删除)

3.查找
      a. 根据索引查找元素           

      b. 查找链表中与特定值相等的元素

           1.元素大小有序              

           2.元素大小无序

总结：链表增删快，查找慢。

在这里插入图片描述

  1. 双向链表
双向链表：

很容易验证，前面那些操作，双向链表和单链表的时间复杂度是一样的。
那为什么在工程上，我们用的一般是双向链表而不是单链表呢 
(比如JDK中的 LinkedList & LinkedHashMap)？

那自然是双向链表有单链表没有的独特魅力——它有一条指向前驱结点的链接。

1.增加 (在某个结点前面添加元素)
2.删除 (删除该结点)

3.查找
      a. 查找前驱结点

      b. 根据索引查找元素

      c. 查找链表中与特定值相等的元素

          1. 元素大小无序

          2. 元素大小有序

总结：虽然双向链表更占用内存空间，但是它在某些操作上的性能是优于单链表的。

思想：用空间换取时间。

在这里插入图片描述

4）缓存
缓存就是一种用空间换取时间的技术。

内存大小是有限的，所以缓存不能无限大。那么当缓存满的时候，再向缓存中添加数据，该怎么办呢？

缓存淘汰策略：

         1 FIFO (First In First Out)

         2 LFU (Least Frequently Used)

         3 LRU (Least Recently Used)

LRU算法中我们就用到了链表！

1.添加 (认为尾节点是最近最少使用的数据)
      a. 如果缓存中已经存在该数据

          删除该结点，添加到头结点

      b. 如果缓存中不存在该数据

          1. 缓存没满

                添加到头结点

          2. 缓存满了

                删除尾节点, 在头结点添加

用链表实现LRU算法：
在这里插入图片描述

5）链表的3个练习题
  1. 求单链表的中间元素
/*
求单链表的中间元素
示例1：
输入：1 --> 2 --> 3
输出: 2
示例2：
输入：1 --> 2 --> 3 --> 4
输出：2

思路：
    如果是数组，我们可以怎么求中间元素. arr[(arr.length - 1)/2]
    a. 求链表的长度
    b. 从头开始遍历链表，并计数
 */
public class Ex1 {
    public static int middleElement(Node head) {
        // 求链表的长度
        int length = 0;
        Node x = head;
        while (x != null) {
            length++;
            x = x.next;
        }
        // 计算中间元素的索引
        int index = (length - 1) / 2;
        // 从头开始遍历链表，并计数
        int i = 0;
        x = head;
        while (i < index) {
            x = x.next;
            i++;
        }
        return x.value;
    }

    public static void main(String[] args) {
        // 1 --> 2 --> 3
        /*Node head = new Node(3);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(middleElement(head));*/

        // 1 --> 2 --> 3 --> 4
        Node head = new Node(4);
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(middleElement(head));
    }
}
  1. 判断单链表中是否有环
/*
2. 判断单链表中是否有环
思路1：一刀切
    给定一个阈值100ms
    如果程序运行时间超过10ms, 有环, 否则无环。
思路2：迷雾森林
    将经过的结点做标记。Collection visited.
    遍历链表：
        判断当前结点是否在visited集合中存在。contains
        存在：返回true。
        不存在：遍历下一个结点。
    遍历结束：返回false。
思路3：跑道(快慢指针)
    1. 快慢指针都指向头结点，慢指针每次走一步, 快指针每次走两步。
    2. 如果快指针走到终点，说明无环
    3. 否则快慢指针一定会再次相遇, 说明有环。
 */
public class Ex2 {
    /*
    时间复杂度：O(n^2) --> O(n)
    空间复杂度：O(n)
     */
   /* public static boolean hasCircle(Node head) {
        // Collection visited = new ArrayList(); // HashSet的查找时间复杂度为O(1)
        Collection visited = new HashSet();
        Node x = head;
        while (x != null) {
            if (visited.contains(x)) return true;
            // 做标记
            visited.add(x);
            x = x.next;
        }
        return false;
    }*/

   /*
   时间复杂度：假设环外的结点有a个，环内的结点有r个
     最好情况：O(a)
     最坏情况：O(a + r)
     平均情况：O(a + r/2)
   空间复杂度：O(1)
    */
    public static boolean hasCircle(Node head) {
        Node slow = head;
        Node fast = head;
        do {
            // 判断快指针是否走到了终点 (短路原则)
            if (fast == null || fast.next == null) return false;
            slow = slow.next;
            fast = fast.next.next;
        } while (slow != fast);
        return true;
    }

    public static void main(String[] args) {
        // 1 --> 2 --> 3 --> 4
        /*Node head = new Node(4);
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(hasCircle(head));*/

        // 1 --> 2 --> 3 --> 4 --> 2...
        /*Node node = new Node(4);
        Node head = new Node(3, node);
        head = new Node(2, head);
        node.next = head;
        head = new Node(1, head);
        System.out.println(hasCircle(head));*/

        // 1 --> 2 --> 3 --> 4 --> 4 ...
        Node head = new Node(4);
        head.next = head;
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(hasCircle(head));
    }
}

画图说明：
在这里插入图片描述

  1. 扩展：判断单链表中是否有环，如果有环，返回入环的第一个结点
/*
3. 判断单链表中是否有环
   如果有环，返回入环的第一个结点
   否则返回null

思路1: 迷雾森林
    将经过的结点做标记。Collection visited.
    遍历链表：
        判断当前结点是否在visited集合中存在。contains
        存在：返回该节点
        不存在：遍历下一个结点。
    遍历结束：返回null。
思路2：跑道(快慢指针)

 */
public class Ex3 {
    /*
    时间复杂度：O(n)
    空间复杂度：O(n)
     */
    /*public static Node hasCircle(Node head) {
        Collection visited = new HashSet();
        Node x = head;
        while (x != null) {
            if (visited.contains(x)) return x;
            visited.add(x);
            x = x.next;
        }
        return null;
    }*/

    /*
    时间复杂度：假设环外的结点有a个，环内的结点有r个
      最好情况：O(2a)
      最坏情况：O(2a + r)
      平均情况：O(2a + r/2)
    空间复杂度：O(1)
     */
    public static Node hasCircle(Node head) {
        Node fast = head;
        Node slow = head;
        do {
            if (fast == null || fast.next == null) return null;
            slow = slow.next;
            fast = fast.next.next;
        } while (slow != fast);
        // 将fast移动到头结点
        fast = head;
        while (slow != fast) {
            fast = fast.next;
            slow = slow.next;
        }
        return fast;
    }

    public static void main(String[] args) {
        // 1 --> 2 --> 3 --> 4
        /*Node head = new Node(4);
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(hasCircle(head));*/

        // 1 --> 2 --> 3 --> 4 --> 2...
       /* Node node = new Node(4);
        Node head = new Node(3, node);
        head = new Node(2, head);
        node.next = head;
        head = new Node(1, head);
        System.out.println(hasCircle(head));*/

        // 1 --> 2 --> 3 --> 4 --> 4 ...
        /*Node head = new Node(4);
        head.next = head;
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        System.out.println(hasCircle(head));*/
    }
}

画图说明：
在这里插入图片描述

  1. 反转单链表
/*
反转单链表
示例
输入：1 --> 2 --> 3 --> null
输出：3 --> 2 --> 1 --> null

思路1：头插法
思路2：递归
 */
public class Ex1 {
    /*public static Node reverse(Node head) {
        Node prev = null;
        Node curr = head;
        while (curr != null) {
            Node next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }*/

    public static Node reverse(Node head) {
        if (head.next == null) return head;
        // 反转head.next
        Node reversed = reverse(head.next);
        // 反转head结点
        head.next.next = head;
        head.next = null;
        return reversed;
    }
    public static void print(Node head) {
        Node x = head;
        while (x != null) {
            System.out.print(x.value);
            if (x.next != null) {
                System.out.print(" --> ");
            }
            x = x.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        Node head = new Node(4);
        head = new Node(3, head);
        head = new Node(2, head);
        head = new Node(1, head);
        print(head);
        head = reverse(head);
        print(head);
    }
}

头插法 画图说明：
在这里插入图片描述
递归法 画图说明：在这里插入图片描述

3.数组和链表的区别

在这里插入图片描述


总结起来就是：数组更加高效，链表更加灵活。

而且数组和链表是实现其他数据结构的基础，比如栈、队列、树、哈希表、图等
luotianyi1
关注
【数据结构与算法】程序员们常用的10个关键数据结构，包括它们的原理和C语言实现代码
AI天才研究院
05-02 8719
在计算机科学和编程中，我们每天使用各种数据结构来存储和操作数据。
100天精通Python丨基础知识篇 —— 01、C站最全Python标准库总结
热门推荐
独木不成林，单弦不成音。
06-29 51万+
❤粉丝福利：免费下载海量【PPT模板、简历模板、学习资料】https://app.yinxiang.com/fx/13ce6bbd-f36f-4e92-be53-92dd381ed729
数组与链表
梁婉玲krysliang的博客
11-26 434
数组 一、基本概念 1、什么数组？ 数组是一种线性表的数据结构。它用一组连续的内存空间，来存储一组具有相同类型的数据。 2、数组是如何实现下标随机访问数组元素的？ 我们拿一个长度为10的数组来举例，在下面的图中，计算机给数组分配了一块连续的内存空间，其中内存的首地址为base_address=1000。 每次获取数据的时候，计算机都会根据下面的寻址公式计算出元素的存储的内存...
day02总结.rar
10-10
Day02可能讲解了SQL的基本查询语句（SELECT, FROM, WHERE），以及如何创建、更新和删除数据。 6. **操作系统原理**：简要介绍操作系统的基本功能，如进程管理、内存管理、文件系统等，帮助初学者理解计算机运行的...
22.11.11 IO day5
qq_44191452的博客
11-14 266
线程处理数组逆置
day15 重要函数和全部函数介绍。
gaosong0623的博客
07-16 192
1.filter()函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。 注：Pyhton2.7 返回列表，Python3.x 返回迭代器对象 #_author:无言宝宝 #date: 2019/7...
数组和链表
11-23 3281
数组和链表是一组简单、常用的，线性的数据结构，java中很多复杂数据结构都是基于它们实现的。虽然简单，但却是面试中的常客，尤其是算法相关的面试题。 数组 数组是一种有序的、固定大小的、存储相同数据类型的线性数据结构。数组有着广泛的应用，比如java中的ArrayList、Vector等数据结构就是基于数组实现的。数组的示意图： 数组的主要特点： 插入和删除效率低 连续内存，大小固定，无法动态扩展 可以根据下标随机访问，查找效率高 链表 链表也是一种线性的数据结构，但链表不是连续内存，而是通过指针指向将元
数组和链表区别 罗列3点
最新发布
04-23
好的，我知道了。关于数组和链表的区别，可以罗列以下三点： 1. 存储方式不同：数组在内存...3. 应用场景不同：数组适合存储需要随机访问的数据，如排序和查找。链表则适合存储需要频繁插入和删除的数据，如队列和栈。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值