数据结构篇

最新推荐文章于 2021-06-16 19:16:27 发布

汉三姓胡

最新推荐文章于 2021-06-16 19:16:27 发布

阅读量475

点赞数

CC 4.0 BY-SA版权

分类专栏：面试文章标签：安卓数据结构

本文链接：https://blog.youkuaiyun.com/hnnd123/article/details/87807128

面试专栏收录该内容

5 篇文章

订阅专栏

算法时间复杂度的表示法O(n²)、O(n)、O(1)、O(nlogn)

简单说O(n²)表示当n很大的时候，复杂度约等于Cn²，C是某个常数，简单说就是当n足够大的时候，n的线性增长，复杂度将沿平方增长。
O(n)也是差不多的意思，也就是说n很大的时候复杂度约等于Cn，C是某个常数。
O(1)就是说n很大的时候，复杂度基本就不增长了，基本就是个常量C。
举例解释：
要找到一个数组里面最大的一个数，你要把n个变量都扫描一遍，操作次数为n，那么算法复杂度是O(n).
用冒泡排序排一个数组，对于n个变量的数组，需要交换变量位置n^2 次，那么算法复杂度就是O(n^2 ).
有时候，如果对变量操作的次数是个多项式比如n⁴⁺ⁿ2+n, 就取数量级最大的那个，O(n^4)

常用数据结构简介

Android中一般使用的数据结构有java中的基础数据结构Set, List, Map。还有一些Android中特有的几个，SparseArray(使用Map时Key是int类型的时候可以用这个代替)等。
在这里插入图片描述
Collection
它是所有集合类的接口，Set和List也都实现Collection接口。

Set
一般使用的有TreeSet和HashSet
①HashSet是根据hashCode来决定存储位置的，是通过HashMap实现的，所以对象必须实现hashCode()方法，存储的数据无序不能重复，可以存储null,但是只能存一个。
②TreeSet

List
List比较常用的有ArrayList和LinkedList，还有一个比较类似的Vector。

①ArrayList
是使用动态数组来实现的，对于数据的随机get和set或是少量数据的插入或删除，效率会比较高。ArrayList是线程不安全的，在不考虑线程安全的情况下速度也比较快的。ArrayList插入数据可以重复，也是有序的，按照插入的顺序来排序。

②.LinkedList
内部是使用链表的形式来实现的,在插入大量数据的时候效率比较快。
LinkedList根据序号获取数据，是二分进行遍历，如果序号小于总长度的一半，就从链表头部开始往后遍历，直到找到对应的序号。如果序号大于总长度的一半，就从链表尾部往前进行遍历，直到找到对应的序号。拿到数据。
③ Vector
Vector的使用方法和内部实现基本和ArrayList相同，只不过它在add(), remove(), get()等方法中都加了同步。所以它是线程安全的。但是使用效率上不如ArrayList。

Map
① HashMap
HashMap是基于散列链表来实现的，简单的来说，根据key算出一个hash值，确定一个存放index,但是hash值有可能会冲突重复，所以如果冲突的hash值就需要以链表的形式在同一个index存放了。
② TreeMap
TreeMap的使用大致跟HashMap类似，但是内部实现是根据红黑树来实现的。红黑树是一种平衡有序的二叉树，TreeMap的插入删除查询都是依据红黑树的规则来进行的。
③ Hashtable
先说下，HashMap和TreeMap都是线程不安全的，多线程操作的时候可能会造成数据错误。Hashtable是线程安全的。其他内部实现，与HashMap都是一样的。

并发集合了解哪些？
常见的并发集合：
ConcurrentHashMap：线程安全的HashMap的实现
CopyOnWriteArrayList：线程安全且在读操作时无锁的ArrayList
CopyOnWriteArraySet：基于CopyOnWriteArrayList，不添加重复元素
ArrayBlockingQueue：基于数组、先进先出、线程安全，可实现指定时间的阻塞读写，并且容量可以限制
LinkedBlockingQueue：基于链表实现，读写各用一把锁，在高并发读写操作都多的情况下，性能优于ArrayBlockingQueue

CopyOnWrite集合即写时复制的集合。
通俗的理解是当我们往一个集合添加元素的时候，不直接往当前集合添加，而是先将当前集合进行Copy，复制出一个新的集合，然后新的集合里添加元素，添加完元素之后，再将原集合的引用指向新的集合。这样做的好处是我们可以对CopyOnWrite集合进行并发的读，而不需要加锁，因为当前集合不会添加任何元素。所以CopyOnWrite集合也是一种读写分离的思想，读和写不同的集合。

列举java的集合以及集合之间的继承关系

集合类以及集合框架
核心的集合接口：

Collection接口：集合框架的根接口。它是集合类框架中最具一般性的顶层接口。Java平台没有提供任何该接口的直接具体实现类，但是提供了具有各种不同特性的子接口

Set接口：不允许包含重复值的集合

List接口：可索引的集合，可以包含重复值。使用该接口时我们通过索引对元素进行精准的插入和查找

Queue接口：该集合适用于组织一个队列，队列中的元素按照优先级进行处理。除了继承自Collection接口的方法，该接口还提供了另外的插入、提取和检验方法。典型的队列是符合“先进先出”（FIFO:First In,First Out）原则的，优先级队列是一种例外，它按照元素的优先级顺序排列元素。无论按照什么原则排序，队头元素总是首先被检出。每个Queue接口的实现类必须指定它的排序原则

Deque接口：与Queue的不同之处在于它是一个双端队列，在两端都能插入和移除元素，它继承并扩展了Queue接口

Map接口：提供了键值对（key/value）的映射关系的集合。关键字不能有重复值，每个关键字至多可映射一个值

SortedSet接口：以升序的原则维持着集合中的元素顺序。

SortedMap接口：以关键字升序的原则维持着集合中的元素顺序

在这里插入图片描述

容器类介绍以及之间的区别（容器类估计很多人没听这个词，Java容器主要可以划分为4个部分：List列表、Set集合、Map映射、工具类（Iterator迭代器、Enumeration枚举类、Arrays和Collections），具体的可以看看这篇博文 Java容器类 http://alexyyek.github.io/2015/04/06/Collection/）

List,Set,Map的区别

链表的原理
单链表原理：https://www.jianshu.com/p/141da62b819e https://blog.youkuaiyun.com/wyqwilliam/article/details/82717670

双向链表：https://blog.youkuaiyun.com/defineshan/article/details/52266184 https://blog.youkuaiyun.com/xu404741377/article/details/73526955

hash表原理
https://blog.youkuaiyun.com/qq_41230365/article/details/81058217

红黑树，二叉树原理
二叉树：https://www.jianshu.com/p/4716b2f49e8e
红黑树：https://www.cnblogs.com/skywang12345/p/3624343.html

队列
https://blog.youkuaiyun.com/qq_34975710/article/details/78028302

栈
https://blog.youkuaiyun.com/zengxingyuluo/article/details/78942074

什么场景下使用list，set，map呢？

如果你经常会使用索引来对容器中的元素进行访问，那么 List 是你的正确的选择。如果你已经知道索引了的话，那么 List 的实现类比如 ArrayList 可以提供更快速的访问,如果经常添加删除元素的，那么肯定要选择LinkedList。

如果你想容器中的元素能够按照它们插入的次序进行有序存储，那么还是 List，因为 List 是一个有序容器，它按照插入顺序进行存储。

如果你想保证插入元素的唯一性，也就是你不想有重复值的出现，那么可以选择一个 Set 的实现类，比如 HashSet、LinkedHashSet 或者 TreeSet。所有 Set 的实现类都遵循了统一约束比如唯一性，而且还提供了额外的特性比如 TreeSet 还是一个 SortedSet，所有存储于 TreeSet 中的元素可以使用 Java 里的 Comparator 或者 Comparable 进行排序。LinkedHashSet 也按照元素的插入顺序对它们进行存储。

如果你以键和值的形式进行数据存储那么 Map 是你正确的选择。你可以根据你的后续需要从 Hashtable、HashMap、TreeMap 中进行选择。

List和Map的实现方式以及存储方式

HashMap的实现原理
https://www.cnblogs.com/chengxiao/p/6059914.html

HashMap数据结构？
HashMap是通过数组+链表
https://www.cnblogs.com/dassmeta/p/5338955.html

HashMap源码理解

HashMap如何put数据（从HashMap源码角度讲解）？

public V put(K key, V value) {
        //当key为null，调用putForNullKey方法，保存null与table第一个位置中，这是HashMap允许为null的原因
        if (key == null)
            return putForNullKey(value);
        //计算key的hash值
        int hash = hash(key.hashCode());                  ------(1)
        //计算key hash 值在 table 数组中的位置
        int i = indexFor(hash, table.length);             ------(2)
        //从i出开始迭代 e,找到 key 保存的位置
        for (Entry<K, V> e = table[i]; e != null; e = e.next) {
            Object k;
            //判断该条链上是否有hash值相同的(key相同)
            //若存在相同，则直接覆盖value，返回旧value
            if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
                V oldValue = e.value;    //旧值 = 新值
                e.value = value;
                e.recordAccess(this);
                return oldValue;     //返回旧值
            }
        }
        //修改次数增加1
        modCount++;
        //将key、value添加至i位置处
        addEntry(hash, key, value, i);
        return null;
    }

通过源码我们可以清晰看到HashMap保存数据的过程为：首先判断key是否为null，若为null，则直接调用putForNullKey方法。若不为空则先计算key的hash值，然后根据hash值搜索在table数组中的索引位置，如果table数组在该位置处有元素，则通过比较是否存在相同的key，若存在则覆盖原来key的value，否则将该元素保存在链头（最先保存的元素放在链尾）。若table在该处没有元素，则直接保存。这个过程看似比较简单，其实深有内幕。有如下几点：

1、先看迭代处。此处迭代原因就是为了防止存在相同的key值，若发现两个hash值（key）相同时，HashMap的处理方式是用新value替换旧value，这里并没有处理key，这就解释了HashMap中没有两个相同的key。

2、在看（1）、（2）处。这里是HashMap的精华所在。首先是hash方法，该方法为一个纯粹的数学计算，就是计算h的hash值。

相对于HashMap的存而言，get就显得比较简单了。通过key的hash值找到在table数组中的索引处的Entry，然后返回该key对应的value即可。
在这里能够根据key快速的取到value除了和HashMap的数据结构密不可分外，还和Entry有莫大的关系，在前面就提到过，HashMap在存储过程中并没有将key，value分开来存储，而是当做一个整体key-value来处理的，这个整体就是Entry对象。同时value也只相当于key的附属而已。在存储的过程中，系统根据key的hashcode来决定Entry在table数组中的存储位置，在取的过程中同样根据key的hashcode取出相对应的Entry对象。

HashMap怎么手写实现？
https://www.jianshu.com/p/b638f19aeb64

ConcurrentHashMap的实现原理
https://www.cnblogs.com/chengxiao/p/6842045.html

ArrayMap和HashMap的对比
HashMap是通过数组+链表的形式存储数据，内部有一个名为table的Node类型的数组用以存放数据，每一个Node都可以向后构成一个单向链表，用于在hash重复而key不相同时保存新的键值对

ArrayMap是一个<key,value>映射的数据结构，它设计上更多的是考虑内存的优化，内部是使用两个数组进行数据存储，一个数组记录key的hash值，另外一个数组记录Value值，它和SparseArray一样，也会对key使用二分法进行从小到大排序，在添加、删除、查找数据的时候都是先使用二分查找法得到相应的index，然后通过index来进行添加、查找、删除等操作，所以，应用场景和SparseArray的一样，如果在数据量比较大的情况下，那么它的性能将退化至少50%。

https://blog.youkuaiyun.com/shangsxb/article/details/78898323

HashTable实现原理
HashTable类中，保存实际数据的，依然是Entry对象。其数据结构与HashMap是相同的。
和HashMap一样，Hashtable 也是一个散列表，它存储的内容是键值对(key-value)映射。
Hashtable 继承于Dictionary，实现了Map、Cloneable、java.io.Serializable接口。
Hashtable 的函数都是同步的，这意味着它是线程安全的。它的key、value都不可以为null。
Hashtable中的映射不是有序的。

TreeMap具体实现

HashMap和HashTable的区别

HashMap与HashSet的区别
HashSet：

HashSet实现了Set接口，它不允许集合中出现重复元素。当我们提到HashSet时，第一件事就是在将对象存储在
HashSet之前，要确保重写hashCode（）方法和equals（）方法，这样才能比较对象的值是否相等，确保集合中没有
储存相同的对象。如果不重写上述两个方法，那么将使用下面方法默认实现：
public boolean add(Object obj)方法用在Set添加元素时，如果元素值重复时返回 “false”，如果添加成功则返回"true"

HashMap：

HashMap实现了Map接口，Map接口对键值对进行映射。Map中不允许出现重复的键（Key）。Map接口有两个基本的实现
TreeMap和HashMap。TreeMap保存了对象的排列次序，而HashMap不能。HashMap可以有空的键值对（Key（null）-Value（null））
HashMap是非线程安全的（非Synchronize），要想实现线程安全，那么需要调用collections类的静态方法synchronizeMap（）实现。
public Object put(Object Key,Object value)方法用来将元素添加到map中。
在这里插入图片描述

HashSet与HashMap怎么判断集合元素重复？
HashSet不能添加重复的元素，当调用add（Object）方法时候，
首先会调用Object的hashCode方法判hashCode是否已经存在，如不存在则直接插入元素；
如果已存在则调用Object对象的equals方法判断是否返回true，如果为true则说明元素已经存在，如为false则插入元素。
结论：为了保证HashSet中的对象不会出现重复值，在被存放元素的类中必须要重写hashCode()和equals()这两个方法。

HashMap
如果原本已经存在对应的key，则直接改变对应的value，并返回旧的value，而在判断key是否存在的时候是先比较key的hashCode，再比较相等或equals的。这里可能我们还看不出来，直接从上面代码来看是比较的对应Map.Entry的hashCode和key的hashCode，而实际上在后面我们可以看到Map.Entry的hashCode其实就是其存放key的hashCode。而如果对应的key原本不存在的话将调用addEntry将对应的key-value添加到Map中。addEntry传递的参数hash就是对应key的hashCode。

集合Set实现Hash怎么防止碰撞
在向hashSet中add()元素时，判断元素是否存在的依据，不仅仅是hash码值就能够确定的，同时还要结合equles方法。

ArrayList和LinkedList的区别，以及应用场景
使用场景：

（1）如果应用程序对各个索引位置的元素进行大量的存取或删除操作，ArrayList对象要远优于LinkedList对象；

( 2 ) 如果应用程序主要是对列表进行循环，并且循环时候进行插入或者删除操作，LinkedList对象要远优于ArrayList对象；

ArrayList是最常用的List实现类，内部是通过动态数组实现的，它允许对元素进行快速随机访问。数组的缺点是每个元素之间不能有间隔，当数组大小不满足时需要增加存储能力，就要讲已经有数组的数据复制到新的存储空间中。当从ArrayList的中间位置插入或者删除元素时，需要对数组进行复制、移动、代价比较高。因此，它适合随机查找和遍历，不适合插入和删除。

Vector与ArrayList一样，也是通过数组实现的，不同的是它支持线程的同步，即某一时刻只有一个线程能够写Vector，避免多线程同时写而引起的不一致性，但实现同步需要很高的花费，因此，访问它比访问ArrayList慢。

LinkedList是用链表结构存储数据的，很适合数据的动态插入和删除，随机访问和遍历速度比较慢。另外，他还提供了List接口中没有定义的方法，专门用于操作表头和表尾元素，可以当作堆栈、队列和双向队列使用。

Java IdentityHashMap与HashMap的区别
两者最主要的区别是IdentityHashMap使用的是比较key的值，而HashMap使用的是equals()
HashMap使用的是hashCode()查找位置，IdentityHashMap使用的是System.identityHashCode(object)
IdentityHashMap理论上来说速度要比HashMap快一点
另外一点呢就是IdentityHashMap中key能重复，但需要注意一点的是key比较的方法是，所以若要存放两个相同的key，就需要存放不同的地址，下面用代码来说明：

import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.Map;

public class IdentityMapDemo {

public static void main(String[] args) {
     Map identityMap = new IdentityHashMap();
     identityMap.put("a", 1);
     identityMap.put(new String("a"), 2);
     identityMap.put("a", 3);
     System.out.println("Identity Map KeySet Size :: " +  identityMap.keySet().size());
      //输出结果为Identity Map KeySet Size :: 2
 }

数组和链表的区别
数组的特点
在内存中，数组是一块连续的区域。 拿上面的看电影来说，这几个人在电影院必须坐在一起。
数组需要预留空间，在使用前要先申请占内存的大小，可能会浪费内存空间。比如看电影时，为了保证10个人能坐在一起，必须提前订好10个连续的位置。这样的好处就是能保证10个人可以在一起。但是这样的缺点是，如果来的人不够10个，那么剩下的位置就浪费了。如果临时有多来了个人，那么10个就不够用了，这时可能需要将第11个位置上的人挪走，或者是他们11个人重新去找一个11连坐的位置，效率都很低。如果没有找到符合要求的作为，那么就没法坐了。
插入数据和删除数据效率低，插入数据时，这个位置后面的数据在内存中都要向后移。删除数据时，这个数据后面的数据都要往前移动。比如原来去了5个人，然后后来又去了一个人要坐在第三个位置上，那么第三个到第五个都要往后移动一个位子，将第三个位置留给新来的人。当这个人走了的时候，因为他们要连在一起的，所以他后面几个人要往前移动一个位置，把这个空位补上。
随机读取效率很高。因为数组是连续的，知道每一个数据的内存地址，可以直接找到给地址的数据。
并且不利于扩展，数组定义的空间不够时要重新定义数组。

链表的特点
在内存中可以存在任何地方，不要求连续。在电影院几个人可以随便坐。
每一个数据都保存了下一个数据的内存地址，通过这个地址找到下一个数据。第一个人知道第二个人的座位号，第二个人知道第三个人的座位号……
增加数据和删除数据很容易。再来个人可以随便坐，比如来了个人要做到第三个位置，那他只需要把自己的位置告诉第二个人，然后问第二个人拿到原来第三个人的位置就行了。其他人都不用动。
查找数据时效率低，因为不具有随机访问性，所以访问某个位置的数据都要从第一个数据开始访问，然后根据第一个数据保存的下一个数据的地址找到第二个数据，以此类推。要找到第三个人，必须从第一个人开始问起。
不指定大小，扩展方便。链表大小不用定义，数据随意增删。

各自的优缺点：

数组的优点
随机访问性强
查找速度快

数组的缺点
插入和删除效率低
可能浪费内存
内存空间要求高，必须有足够的连续内存空间。
数组大小固定，不能动态拓展

链表的优点
插入删除速度快
内存利用率高，不会浪费内存
大小没有固定，拓展很灵活。

链表的缺点
不能随机查找，必须从第一个开始遍历，查找效率低

在这里插入图片描述

二叉树的深度优先遍历和广度优先遍历的具体实现
在这里插入图片描述
深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。以上面二叉树为例，深度优先搜索的顺序为：ABDECFG。怎么实现这个顺序呢？深度优先搜索二叉树是先访问根结点，然后遍历左子树接着是遍历右子树，因此我们可以利用堆栈的先进后出的特点，现将右子树压栈，再将左子树压栈，这样左子树就位于栈顶，可以保证结点的左子树先与右子树被遍历。

广度优先搜索(Breadth First Search),又叫宽度优先搜索或横向优先搜索，是从根结点开始沿着树的宽度搜索遍历，上面二叉树的遍历顺序为：ABCDEFG.可以利用队列实现广度优先搜索。
堆的结构

堆和树的区别
以小根堆为例，堆的特点是双亲结点的关键字必然小于等于孩子结点的关键字，而两个孩子结点的关键字没有次序规定
而二叉排序树中，每个双亲结点的关键字均大于左子树结点的关键字，均小于右子树j结点的关键字，也就是说，每个双亲结点的左右孩子的关键字有次序关系
这样，当对两种树执行中序遍历后，二叉排序树会得到一个有序的序列，而堆不一定。

堆和栈在内存中的区别是什么(解答提示：可以从数据结构方面以及实际实现方面两个方面去回答)？

①数据结构的栈和堆
栈就像装数据的桶或箱子
我们先从大家比较熟悉的栈说起吧，它是一种具有后进先出性质的数据结构，也就是说后存放的先取，先存放的后取。
这就如同我们要取出放在箱子里面底下的东西（放入的比较早的物体），我们首先要移开压在它上面的物体（放入的比较晚的物体）。

堆像一棵倒过来的树
而堆就不同了，堆是一种经过排序的树形数据结构，每个结点都有一个值。
通常我们所说的堆的数据结构，是指二叉堆。
堆的特点是根结点的值最小（或最大），且根结点的两个子树也是一个堆。

栈内存：
在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。栈内存主要存放的是基本类型类型的数据如( int, short, long, byte, float, double, boolean, char) 和对象句柄。注意：并没有String基本类型、在栈内存的数据的大小及生存周期是必须确定的、其优点是寄存速度快、栈数据可以共享、缺点是数据固定、不够灵活。

堆内存：
堆内存用来存放所有new 创建的对象和数组的数据，只要是用new()来新建对象的，都会在堆中创建，而且其字符串是单独存值的，即使与栈中的数据相同，也不会与栈中的数据共享。

申请方式和回收方式不同

栈（英文名称是stack）是系统自动分配空间的，例如我们定义一个 char a；系统会自动在栈上为其开辟空间。而堆（英文名称是heap）则是程序员根据需要自己申请的空间，例如malloc（10）；开辟十个字节的空间。

由于栈上的空间是自动分配自动回收的，所以栈上的数据的生存周期只是在函数的运行过程中，运行后就释放掉，不可以再访问。而堆上的数据只要程序员不释放空间，就一直可以访问到，不过缺点是一旦忘记释放会造成内存泄露。

堆与栈的区别：

        1.栈内存存储的是局部变量而堆内存存储的是实体；

        2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短；

        3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收。

什么是深拷贝和浅拷贝
https://blog.youkuaiyun.com/tounaobun/article/details/8491392
https://blog.youkuaiyun.com/qq_41635167/article/details/82943223

手写链表逆序代码

讲一下对树，B+树的理解
https://blog.youkuaiyun.com/lz201788/article/details/79628726

讲一下对图的理解

判断单链表成环与否？
https://blog.youkuaiyun.com/wxgxgp/article/details/82528999

链表翻转（即：翻转一个单项链表）
https://www.cnblogs.com/zhengcj/p/7494089.html

合并多个单有序链表（假设都是递增的）
https://blog.youkuaiyun.com/zm13007310400/article/details/78317821

递归
https://www.cnblogs.com/renxiaoren/p/4568745.html
https://www.cnblogs.com/BeyondAnyTime/archive/2012/05/19/2508807.html