关于

同时对多个数组进行排序的搜索结果

回答

本人学习数据结构时看到的不错的总结，共享一下了

文件有一组记录组成，记录有若干数据项组成，唯一标识记录的数据项称关键字;

排序是将文件按关键字的递增(减)顺序排列;

排序文件中有相同的关键字时，若排序后相对次序保持不变的称稳定排序，否则称不稳定排序;

在排序过程中，文件放在内存中处理不涉及数据的内、外存交换的称内部排序，反之称外部排序;

排序算法的基本操作：1)比较关键字的大小;2)改变指向记录的指针或移动记录本身。

评价排序方法的标准：1)执行时间;2)所需辅助空间，辅助空间为O(1)称就地排序;另要注意算法的复杂程度。

若关键字类型没有比较运算符，可事先定义宏或函数表示比较运算。

8.2插入排序

8.2.1直接插入排序

实现过程：

void insertsort(seqlist R)

{

int i, j;

for(i=2;i<=n;i++)

if(R[i].key< R[i-1].key{

R[0]=R[i];j=i-1;

do{R[j+1]=R[j];j--;}

while(R[0].key

R[j+1]=R[0];

}

}

复制代码

算法中引入监视哨R[0]的作用是：1)保存

R[i]

复制代码

的副本;2)简化边界条件，防止循环下标越界。

关键字比较次数最大为(n+2)(n-1)/2;记录移动次数最大为(n+4)(n-1)/2;

算法的最好时间是O(n);最坏时间是O(n^2);平均时间是O(n^2);是一种就地的稳定的排序;

8.2.2希尔排序

实现过程：是将直接插入排序的间隔变为d。d的取值要注意：1)最后一次必为1;2)避免d值互为倍数;

关键字比较次数最大为n^1.25;记录移动次数最大为1.6n^1.25;

算法的平均时间是O(n^1.25);是一种就地的不稳定的排序;

8.3交换排序

8.3.1冒泡排序

实现过程：从下到上相邻两个比较，按小在上原则扫描一次，确定最小值，重复n-1次。

关键字比较次数最小为n-1、最大为n(n-1)/2;记录移动次数最小为0，最大为3n(n-1)/2;

算法的最好时间是O(n);最坏时间是O(n^2);平均时间是O(n^2);是一种就地的稳定的排序;

8.3.2快速排序

实现过程：将第一个值作为基准，设置i,j指针交替从两头与基准比较，有交换后,交换j，i。i=j时确定基准，并以其为界限将序列分为两段。重复以上步骤。

关键字比较次数最好为nlog2n+nC(1)、最坏为n(n-1)/2;

算法的最好时间是O(nlog2n);最坏时间是O(n^2);平均时间是O(nlog2n);辅助空间为O(log2n);是一种不稳定排序;

8.4选择排序

8.4.1直接选择排序

实现过程：选择序列中最小的插入第一位，在剩余的序列中重复上一步，共重复n-1次。

关键字比较次数为n(n-1)/2;记录移动次数最小为0，最大为3(n-1);

算法的最好时间是O(n^2);最坏时间是O(n^2);平均时间是O(n^2);是一种就地的不稳定的排序;

8.4.2堆排序

实现过程：把序列按层次填入完全二叉树，调整位置使双亲大于或小于孩子，建立初始大根或小根堆，调整树根与最后一个叶子的位置，排除该叶子重新调整位置。

算法的最好时间是O(nlog2n);最坏时间是O(nlog2n);平均时间是O(nlog2n);是一种就地的不稳定排序;

8.5归并排序

实现过程：将初始序列分为2个一组，最后单数轮空，对每一组排序后作为一个单元，对2个单元排序，直到结束。

算法的最好时间是O(nlog2n);最坏时间是O(nlog2n);平均时间是O(nlog2n);辅助空间为O(n);是一种稳定排序;

8.6分配排序

8.6.1箱排序

实现过程：按关键字的取值范围确定箱子的个数，将序列按关键字放入箱中，输出非空箱的关键字。

在桶内分配和收集，及对各桶进行插入排序的时间为O(n),算法的期望时间是O(n),最坏时间是O(n^2)。

8.6.2基数排序

实现过程：按基数设置箱子，对关键字从低位到高位依次进行箱排序。

算法的最好时间是O(d*n+d*rd);最坏时间是O(d*n+d*rd);平均时间是O(d*n+d*rd);辅助空间O(n+rd);是一种稳定排序;

8.7各种内部排序方法的比较和选择

按平均时间复杂度分为：

1) 平方阶排序：直接插入、直接选择、冒泡排序;

2) 线性对数阶：快速排序、堆排序、归并排序;

3) 指数阶：希尔排序;

4) 线性阶：箱排序、基数排序。

选择合适排序方法的因素：1)待排序的记录数;2)记录的大小;3)关键字的结构和初始状态;4)对稳定性的要求;5)语言工具的条件;6)存储结构;7)时间和辅助空间复杂度。

结论：

1) 若规模较小可采用直接插入或直接选择排序;

2) 若文件初始状态基本有序可采用直接插入、冒泡或随机快速排序;

3) 若规模较大可采用快速排序、堆排序或归并排序;

4) 任何借助于比较的排序，至少需要O(nlog2n)的时间，箱排序和基数排序只适用于有明显结构特征的关键字;

5) 有的语言没有提供指针及递归，使归并、快速、基数排序算法复杂;

6) 记录规模较大时为避免大量移动记录可用链表作为存储结构，如插入、归并、基数排序，但快速、堆排序在链表上难以实现，可提取关键字建立索引表，然后对索引表排序。

附二:

第八章排序

*************************************************************************************

记录中可用某一项来标识一个记录，则称为关键字项，该数据项的值称为关键字。

排序是使文件中的记录按关键字递增(或递减)次序排列起来。·基本操作：比较关键字大小;改变指向记录的指针或移动记录。

·存储结构：顺序结构、链表结构、索引结构。

经过排序后这些具有相同关键字的记录之间的相对次序保持不变,则称这种排序方法是稳定的，否则排序算法是不稳定的。

排序过程中不涉及数据的内、外存交换则称之为"内部排序"(内排序)，反之，若存在数据的内外存交换，则称之为外排序。

内部排序方法可分五类：插入排序、选择排序、交换排序、归并排序和分配排序。

评价排序算法好坏的标准主要有两条：执行时间和所需的辅助空间，另外算法的复杂程序也是要考虑的一个因素。

*************************************************************************************

插入排序：·直接插入排序： ·逐个向前插入到合适位置。

·哨兵(监视哨)有两个作用： ·作为临变量存放

R[i]

复制代码

·是在查找循环中用来监视下标变量j是否越界。

·直接插入排序是就地的稳定排序。时间复杂度为O(n^2)，比较次数为(n+2)(n-1)/2;移动次数为(n+4)(n-1)/2;

·希尔排序： ·等间隔的数据比较并按要求顺序排列，最后间隔为1。

·希尔排序是就地的不稳定排序。时间复杂度为O(n^1.25)，比较次数为(n^1.25);移动次数为(1.6n^1.25);

交换排序：·冒泡排序：·自下向上确定最轻的一个。·自上向下确定最重的一个。·自下向上确定最轻的一个，后自上向下确定最重的一个。

·冒泡排序是就地的稳定排序。时间复杂度为O(n^2)，比较次数为n(n-1)/2;移动次数为3n(n-1)/2;

·快速排序：·以第一个元素为参考基准，设定、动两个指针，发生交换后指针交换位置，直到指针重合。重复直到排序完成。

·快速排序是非就地的不稳定排序。时间复杂度为O(nlog2n)，比较次数为n(n-1)/2;

选择排序：·直接选择排序： ·选择最小的放在比较区前。

·直接选择排序就地的不稳定排序。时间复杂度为O(n^2)。比较次数为n(n-1)/2;

·堆排序 ·建堆：按层次将数据填入完全二叉树，从int(n/2)处向前逐个调整位置。

·然后将树根与最后一个叶子交换值并断开与树的连接并重建堆，直到全断开。

·堆排序是就地不稳定的排序，时间复杂度为O(nlog2n)，不适宜于记录数较少的文件。。

归并排序： ·先两个一组排序，形成(n+1)/2组，再将两组并一组，直到剩下一组为止。

·归并排序是非就地稳定排序，时间复杂度是O(nlog2n),

分配排序：·箱排序： ·按关键字的取值范围确定箱子数，按关键字投入箱子，链接所有非空箱。

·箱排序的平均时间复杂度是线性的O(n).

·基数排序：·从低位到高位依次对关键字进行箱排序。

·基数排序是非就稳定的排序，时间复杂度是O(d*n+d*rd)。

各种排序方法的比较和选择： ·.待排序的记录数目n;n较大的要用时间复杂度为O(nlog2n)的排序方法;

·记录的大小(规模);记录大最好用链表作为存储结构，而快速排序和堆排序在链表上难于实现;

·关键字的结构及其初始状态;

·对稳定性的要求;

·语言工具的条件;

·存储结构;

·时间和辅助空间复杂度。

排序(sort)或分类

所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下：

输入：n个记录R1，R2，…，Rn，其相应的关键字分别为K1，K2，…，Kn。

输出：Ril，Ri2，…，Rin，使得Ki1≤Ki2≤…≤Kin。(或Ki1≥Ki2≥…≥Kin)。

1．被排序对象--文件

被排序的对象--文件由一组记录组成。

记录则由若干个数据项(或域)组成。其中有一项可用来标识一个记录，称为关键字项。该数据项的值称为关键字(Key)。

注意：

在不易产生混淆时，将关键字项简称为关键字。

2．排序运算的依据--关键字

用来作排序运算依据的关键字，可以是数字类型，也可以是字符类型。

关键字的选取应根据问题的要求而定。

【例】在高考成绩统计中将每个考生作为一个记录。每条记录包含准考证号、姓名、各科的分数和总分数等项内容。若要惟一地标识一个考生的记录，则必须用"准考证号"作为关键字。若要按照考生的总分数排名次，则需用"总分数"作为关键字。

排序的稳定性

当待排序记录的关键字均不相同时，排序结果是惟一的，否则排序结果不唯一。

在待排序的文件中，若存在多个关键字相同的记录，经过排序后这些具有相同关键字的记录之间的相对次序保持不变，该排序方法是稳定的；若具有相同关键字的记录之间的相对次序发生变化，则称这种排序方法是不稳定的。

注意：

排序算法的稳定性是针对所有输入实例而言的。即在所有可能的输入实例中，只要有一个实例使得算法不满足稳定性要求，则该排序算法就是不稳定的。

排序方法的分类

1．按是否涉及数据的内、外存交换分

在排序过程中，若整个文件都是放在内存中处理，排序时不涉及数据的内、外存交换，则称之为内部排序(简称内排序)；反之，若排序过程中要进行数据的内、外存交换，则称之为外部排序。

注意：

① 内排序适用于记录个数不很多的小文件

② 外排序则适用于记录个数太多，不能一次将其全部记录放人内存的大文件。

2．按策略划分内部排序方法

可以分为五类：插入排序、选择排序、交换排序、归并排序和分配排序。

排序算法分析

1．排序算法的基本操作

大多数排序算法都有两个基本的操作：

(1) 比较两个关键字的大小；

(2) 改变指向记录的指针或移动记录本身。

注意：

第(2)种基本操作的实现依赖于待排序记录的存储方式。

2．待排文件的常用存储方式

(1) 以顺序表(或直接用向量)作为存储结构

排序过程：对记录本身进行物理重排(即通过关键字之间的比较判定，将记录移到合适的位置)

(2) 以链表作为存储结构

排序过程：无须移动记录，仅需修改指针。通常将这类排序称为链表(或链式)排序；

(3) 用顺序的方式存储待排序的记录，但同时建立一个辅助表(如包括关键字和指向记录位置的指针组成的索引表)

排序过程：只需对辅助表的表目进行物理重排(即只移动辅助表的表目，而不移动记录本身)。适用于难于在链表上实现，仍需避免排序过程中移动记录的排序方法。

3．排序算法性能评价

(1) 评价排序算法好坏的标准

评价排序算法好坏的标准主要有两条：

① 执行时间和所需的辅助空间

② 算法本身的复杂程度

(2) 排序算法的空间复杂度

若排序算法所需的辅助空间并不依赖于问题的规模n，即辅助空间是O(1)，则称之为就地排序(In-PlaceSou)。

非就地排序一般要求的辅助空间为O(n)。

(3) 排序算法的时间开销

大多数排序算法的时间开销主要是关键字之间的比较和记录的移动。有的排序算法其执行时间不仅依赖于问题的规模，还取决于输入实例中数据的状态。

马铭芳

2019-12-02 01:19:07

0 浏览量

回答数 0

问题

十大经典排序算法大梳理 7月6日 【今日算法】

以前也零零碎碎发过一些排序算法，但排版都不太好，这次重新整理一次，排序算法是数据结构的重要部分，面试必问，系统地学习很有必要！

时间、空间复杂度比较

排...

游客ih62co2qqq5ww

2020-07-07 02:04:48

1002 浏览量

回答数 1

回答

名称 HashMap LinkedHashMap TreeMap 共同点 线程不安全 线程不安全 线程不安全 不同点 数据无序 数据有序 数据有序还可以对数据进行排序 数据结构 数组+链表+红黑树(在JDK1.8中如果链表长度大于8的时候才转换为红黑树，平常不是) 双向链表+HashMap 红黑树

1.HashMap是一个最常用的Map，它根据键的hashCode值存储数据，根据键可以直接获取它的值，具有很快的访问速度。HashMap最多只允许一条记录的键为null，不允许多条记录的值为null。HashMap不支持线程的同步，即任一时刻可以有多个线程同时写HashMap，可能会导致数据的不一致。如果需要同步，可以用Collections.synchronizedMap(HashMap map)方法使HashMap具有同步的能力。 2.LinkedHashMap保存了记录的插入顺序，在用Iteraor遍历LinkedHashMap时，先得到的记录肯定是先插入的。在遍历的时候会比HashMap慢。有HashMap的全部特性。 3.TreeMap能够把它保存的记录根据键排序，默认是按升序排序，也可以指定排序的比较器。当用Iteraor遍历TreeMap时，得到的记录是排过序的。TreeMap的键和值都不能为空。

景凌凯

2020-01-09 13:45:34

0 浏览量

回答数 0

问题

算法工程师必知必会10大基础算法！ 6月23日 【今日算法】

算法一：快速排序算法

快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序n个项目要Ο(nlogn)次比较。在最坏状况下则需要Ο(n2)次比较，但这种状况并不常见。

事实上࿰...

游客ih62co2qqq5ww

2020-06-23 13:36:00

6 浏览量

回答数 1

问题

图解！24张图彻底弄懂九大常见数据结构！ 7月22日 【今日算法】

数据结构想必大家都不会陌生，对于一个成熟的程序员而言，熟悉和掌握数据结构和算法也是基本功之一。数据结构本身其实不过是数据按照特点关系进行存储或者组织的集合，特殊的结构在不同的应用场景中往往会带来不一...

游客ih62co2qqq5ww

2020-07-27 13:19:32

6 浏览量

回答数 1

问题

图解九大数据结构 6月13日 【今日算法】

数据结构想必大家都不会陌生，对于一个成熟的程序员而言，熟悉和掌握数据结构和算法也是基本功之一。数据结构本身其实不过是数据按照特点关系进行存储或者组织的集合，特殊的结构在不同的应用场景中往往会带来不一...

游客ih62co2qqq5ww

2020-06-17 13:17:00

29 浏览量

回答数 1

问题

十大经典排序算法最强总结(内含代码实现)

1、算法分类

十种常见排序算法可以分为两大类：

比较类排序：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(nlogn)，因此也称为非线性时间比较类排序。

非比较类排...

游客pklijor6gytpx

2020-01-09 14:44:55

1240 浏览量

回答数 2

问题

什么是表结构优化?

7.3 表结构优化

分区列选择

基本原理分析型数据库的表一级分区采用hash分区，可指定任意一列(不支持多列)作为分区列，然后采用以下标准CRC算法，计算出C...

nicenelly

2019-12-01 21:11:07

1421 浏览量

回答数 0

问题

什么是表结构优化?

7.3 表结构优化

分区列选择

基本原理分析型数据库的表一级分区采用hash分区，可指定任意一列(不支持多列)作为分区列，然后采用以下标准CRC算法，计算出C...

nicenelly

2019-12-01 21:25:39

1095 浏览量

回答数 0

回答

2.1基于词频统计——词位置加权的搜索引擎

利用关键词在文档中出现的频率和位置排序是搜索引擎最早期排序的主要思想，其技术发展也最为成熟，是第一阶段搜索引擎的主要排序技术，应用非常广泛，至今仍是许多搜索引擎的核心排序技术。其基本原理是：关键词在文档中词频越高，出现的位置越重要，则被认为和检索词的相关性越好。

1)词频统计

文档的词频是指查询关键词在文档中出现的频率。查询关键词词频在文档中出现的频率越高，其相关度越大。但当关键词为常用词时，使其对相关性判断的意义非常小。TF/IDF很好的解决了这个问题。TF/IDF算法被认为是信息检索中最重要的发明。TF(Term Frequency)：单文本词汇频率，用关键词的次数除以网页的总字数，其商称为“关键词的频率”。IDF(Inverse Document Frequency)：逆文本频率指数，其原理是，一个关键词在N个网页中出现过，那么N越大，此关键词的权重越小，反之亦然。当关键词为常用词时，其权重极小，从而解决词频统计的缺陷。

2)词位置加权

在搜索引擎中，主要针对网页进行词位置加权。所以，页面版式信息的分析至关重要。通过对检索关键词在Web页面中不同位置和版式，给予不同的权值，从而根据权值来确定所搜索结果与检索关键词相关程度。可以考虑的版式信息有：是否是标题，是否为关键词，是否是正文，字体大小，是否加粗等等。同时，锚文本的信息也是非常重要的，它一般能精确的描述所指向的页面的内容。

2.2基于链接分析排序的第二代搜索引擎

链接分析排序的思想起源于文献引文索引机制，即论文被引用的次数越多或被越权威的论文引用，其论文就越有价值。链接分析排序的思路与其相似，网页被别的网页引用的次数越多或被越权威的网页引用，其价值就越大。被别的网页引用的次数越多，说明该网页越受欢迎，被越权威的网页引用，说明该网页质量越高。链接分析排序算法大体可以分为以下几类：基于随机漫游模型的，比如PageRank和Repution算法；基于概率模型的，如SALSA、PHITS；基于Hub和Authority相互加强模型的，如HITS及其变种；基于贝叶斯模型的，如贝叶斯算法及其简化版本。所有的算法在实际应用中都结合传统的内容分析技术进行了优化。本文主要介绍以下几种经典排序算法：

1)PageRank算法

PageRank算法由斯坦福大学博士研究生Sergey Brin和Lwraence Page等提出的。PageRank算法是Google搜索引擎的核心排序算法，是Google成为全球最成功的搜索引擎的重要因素之一，同时开启了链接分析研究的热潮。

PageRank算法的基本思想是：页面的重要程度用PageRank值来衡量，PageRank值主要体现在两个方面：引用该页面的页面个数和引用该页面的页面重要程度。一个页面P(A)被另一个页面P(B)引用，可看成P(B)推荐P(A)，P(B)将其重要程度(PageRank值)平均的分配P(B)所引用的所有页面，所以越多页面引用P(A)，则越多的页面分配PageRank值给P(A)，PageRank值也就越高，P(A)越重要。另外，P(B)越重要，它所引用的页面能分配到的PageRank值就越多，P(A)的PageRank值也就越高，也就越重要。

其计算公式为：

PR(A)：页面A的PageRank值；

d：阻尼系数，由于某些页面没有入链接或者出链接，无法计算PageRank值，为避免这个问题(即LinkSink问题)，而提出的。阻尼系数常指定为0.85。

R(Pi)：页面Pi的PageRank值；

C(Pi)：页面链出的链接数量；

PageRank值的计算初始值相同，为了不忽视被重要网页链接的网页也是重要的这一重要因素，需要反复迭代运算，据张映海撰文的计算结果，需要进行10次以上的迭代后链接评价值趋于稳定，如此经过多次迭代，系统的PR值达到收敛。

PageRank是一个与查询无关的静态算法，因此所有网页的PageRank值均可以通过离线计算获得。这样，减少了用户检索时需要的排序时间，极大地降低了查询响应时间。但是PageRank存在两个缺陷：首先PageRank算法严重歧视新加入的网页，因为新的网页的出链接和入链接通常都很少，PageRank值非常低。另外PageRank算法仅仅依靠外部链接数量和重要度来进行排名，而忽略了页面的主题相关性，以至于一些主题不相关的网页(如广告页面)获得较大的PageRank值，从而影响了搜索结果的准确性。为此，各种主题相关算法纷纷涌现，其中以以下几种算法最为典型。

2)Topic-Sensitive PageRank算法

由于最初PageRank算法中是没有考虑主题相关因素的，斯坦福大学计算机科学系Taher Haveli-wala提出了一种主题敏感(Topic-Sensitive)的PageRank算法解决了“主题漂流”问题。该算法考虑到有些页面在某些领域被认为是重要的，但并不表示它在其它领域也是重要的。

网页A链接网页B，可以看作网页A对网页B的评分，如果网页A与网页B属于相同主题，则可认为A对B的评分更可靠。因为A与B可形象的看作是同行，同行对同行的了解往往比不是同行的要多，所以同行的评分往往比不是同行的评分可靠。遗憾的是TSPR并没有利用主题的相关性来提高链接得分的准确性。

3)HillTop算法

HillTop是Google的一个工程师Bharat在2001年获得的专利。HillTop是一种查询相关性链接分析算法，克服了的PageRank的查询无关性的缺点。HillTop算法认为具有相同主题的相关文档链接对于搜索者会有更大的价值。在Hilltop中仅考虑那些用于引导人们浏览资源的专家页面(Export Sources)。Hilltop在收到一个查询请求时，首先根据查询的主题计算出一列相关性最强的专家页面，然后根据指向目标页面的非从属专家页面的数量和相关性来对目标页面进行排序。

HillTop算法确定网页与搜索关键词的匹配程度的基本排序过程取代了过分依靠PageRank的值去寻找那些权威页面的方法，避免了许多想通过增加许多无效链接来提高网页PageRank值的作弊方法。HillTop算法通过不同等级的评分确保了评价结果对关键词的相关性，通过不同位置的评分确保了主题(行业)的相关性，通过可区分短语数防止了关键词的堆砌。

但是，专家页面的搜索和确定对算法起关键作用，专家页面的质量对算法的准确性起着决定性作用，也就忽略了大多数非专家页面的影响。专家页面在互联网中占的比例非常低(1.79%)，无法代表互联网全部网页，所以HillTop存在一定的局限性。同时，不同于PageRank算法，HillTop算法的运算是在线运行的，对系统的响应时间产生极大的压力。

4)HITS

HITS(Hyperlink Induced Topic Search)算法是Kleinberg在1998年提出的，是基于超链接分析排序算法中另一个最著名的算法之一。该算法按照超链接的方向，将网页分成两种类型的页面：Authority页面和Hub页面。Authority页面又称权威页面，是指与某个查询关键词和组合最相近的页面，Hub页面又称目录页，该页面的内容主要是大量指向Authority页面的链接，它的主要功能就是把这些Authority页面联合在一起。对于Authority页面P，当指向P的Hub页面越多，质量越高，P的Authority值就越大；而对于Hub页面H，当H指向的Authority的页面越多，Authority页面质量越高，H的Hub值就越大。对整个Web集合而言，Authority和Hub是相互依赖、相互促进，相互加强的关系。Authority和Hub之间相互优化的关系，即为HITS算法的基础。

HITS基本思想是：算法根据一个网页的入度(指向此网页的超链接)和出度(从此网页指向别的网页)来衡量网页的重要性。在限定范围之后根据网页的出度和入度建立一个矩阵，通过矩阵的迭代运算和定义收敛的阈值不断对两个向量Authority和Hub值进行更新直至收敛。

实验数据表明，HITS的排名准确性要比PageRank高，HITS算法的设计符合网络用户评价网络资源质量的普遍标准，因此能够为用户更好的利用网络信息检索工具访问互联网资源带来便利。

但却存在以下缺陷：首先，HITS算法只计算主特征向量，处理不好主题漂移问题；其次，进行窄主题查询时，可能产生主题泛化问题；第三，HITS算法可以说一种实验性质的尝试。它必须在网络信息检索系统进行面向内容的检索操作之后，基于内容检索的结果页面及其直接相连的页面之间的链接关系进行计算。尽管有人尝试通过算法改进和专门设立链接结构计算服务器(Connectivity Server)等操作，可以实现一定程度的在线实时计算，但其计算代价仍然是不可接受的。

2.3基于智能化排序的第三代搜索引擎

排序算法在搜索引擎中具有特别重要的地位，目前许多搜索引擎都在进一步研究新的排序方法，来提升用户的满意度。但目前第二代搜索引擎有着两个不足之处，在此背景下，基于智能化排序的第三代搜索引擎也就应运而生。

1)相关性问题

相关性是指检索词和页面的相关程度。由于语言复杂，仅仅通过链接分析及网页的表面特征来判断检索词与页面的相关性是片面的。例如：检索“稻瘟病”，有网页是介绍水稻病虫害信息的，但文中没有“稻瘟病”这个词，搜索引擎根本无法检索到。正是以上原因，造成大量的搜索引擎作弊现象无法解决。解决相关性的的方法应该是增加语意理解，分析检索关键词与网页的相关程度，相关性分析越精准，用户的搜索效果就会越好。同时，相关性低的网页可以剔除，有效地防止搜索引擎作弊现象。检索关键词和网页的相关性是在线运行的，会给系统相应时间很大的压力，可以采用分布式体系结构可以提高系统规模和性能。

2)搜索结果的单一化问题

在搜索引擎上，任何人搜索同一个词的结果都是一样。这并不能满足用户的需求。不同的用户对检索的结果要求是不一样的。例如：普通的农民检索“稻瘟病”，只是想得到稻瘟病的相关信息以及防治方法，但农业专家或科技工作者可能会想得到稻瘟病相关的论文。

解决搜索结果单一的方法是提供个性化服务，实现智能搜索。通过Web数据挖掘，建立用户模型(如用户背景、兴趣、行为、风格)，提供个性化服务。

琴瑟

2019-12-02 01:17:25

0 浏览量

回答数 0

回答

遍历一个 List 有哪些不同的方式？每种方法的实现原理是什么？Java 中 List 遍历的最佳实践是什么？

遍历方式有以下几种：

for 循环遍历，基于计数器。在集合外部维护一个计数器，然后依次读取每一个位置的元素，当读取到最后一个元素后停止。 迭代器遍历，Iterator。Iterator 是面向对象的一个设计模式，目的是屏蔽不同数据集合的特点，统一遍历集合的接口。Java 在 Collections 中支持了 Iterator 模式。 foreach 循环遍历。foreach 内部也是采用了 Iterator 的方式实现，使用时不需要显式声明 Iterator 或计数器。优点是代码简洁，不易出错；缺点是只能做简单的遍历，不能在遍历过程中操作数据集合，例如删除、替换。

最佳实践：Java Collections 框架中提供了一个 RandomAccess 接口，用来标记 List 实现是否支持 Random Access。

如果一个数据集合实现了该接口，就意味着它支持 Random Access，按位置读取元素的平均时间复杂度为 O(1)，如ArrayList。如果没有实现该接口，表示不支持 Random Access，如LinkedList。 推荐的做法就是，支持 Random Access 的列表可用 for 循环遍历，否则建议用 Iterator 或 foreach 遍历。

说一下 ArrayList 的优缺点

ArrayList的优点如下：

ArrayList 底层以数组实现，是一种随机访问模式。ArrayList 实现了 RandomAccess 接口，因此查找的时候非常快。ArrayList 在顺序添加一个元素的时候非常方便。

ArrayList 的缺点如下：

删除元素的时候，需要做一次元素复制操作。如果要复制的元素很多，那么就会比较耗费性能。插入元素的时候，也需要做一次元素复制操作，缺点同上。

ArrayList 比较适合顺序添加、随机访问的场景。

如何实现数组和 List 之间的转换？

数组转 List：使用 Arrays. asList(array) 进行转换。List 转数组：使用 List 自带的 toArray() 方法。

代码示例：

ArrayList 和 LinkedList 的区别是什么？

数据结构实现：ArrayList 是动态数组的数据结构实现，而 LinkedList 是双向链表的数据结构实现。随机访问效率：ArrayList 比 LinkedList 在随机访问的时候效率要高，因为 LinkedList 是线性的数据存储方式，所以需要移动指针从前往后依次查找。增加和删除效率：在非首尾的增加和删除操作，LinkedList 要比 ArrayList 效率要高，因为 ArrayList 增删操作要影响数组内的其他数据的下标。内存空间占用：LinkedList 比 ArrayList 更占内存，因为 LinkedList 的节点除了存储数据，还存储了两个引用，一个指向前一个元素，一个指向后一个元素。线程安全：ArrayList 和 LinkedList 都是不同步的，也就是不保证线程安全；

综合来说，在需要频繁读取集合中的元素时，更推荐使用 ArrayList，而在插入和删除操作较多时，更推荐使用 LinkedList。

补充：数据结构基础之双向链表

双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。

ArrayList 和 Vector 的区别是什么？

这两个类都实现了 List 接口(List 接口继承了 Collection 接口)，他们都是有序集合

线程安全：Vector 使用了 Synchronized 来实现线程同步，是线程安全的，而 ArrayList 是非线程安全的。性能：ArrayList 在性能方面要优于 Vector。扩容：ArrayList 和 Vector 都会根据实际的需要动态的调整容量，只不过在 Vector 扩容每次会增加 1 倍，而 ArrayList 只会增加 50%。 Vector类的所有方法都是同步的。可以由两个线程安全地访问一个Vector对象、但是一个线程访问Vector的话代码要在同步操作上耗费大量的时间。

Arraylist不是同步的，所以在不需要保证线程安全时时建议使用Arraylist。

插入数据时，ArrayList、LinkedList、Vector谁速度较快？阐述 ArrayList、Vector、LinkedList 的存储性能和特性？

ArrayList、LinkedList、Vector 底层的实现都是使用数组方式存储数据。数组元素数大于实际存储的数据以便增加和插入元素，它们都允许直接按序号索引元素，但是插入元素要涉及数组元素移动等内存操作，所以索引数据快而插入数据慢。

Vector 中的方法由于加了 synchronized 修饰，因此 Vector 是线程安全容器，但性能上较ArrayList差。

LinkedList 使用双向链表实现存储，按序号索引数据需要进行前向或后向遍历，但插入数据时只需要记录当前项的前后项即可，所以 LinkedList 插入速度较快。

多线程场景下如何使用 ArrayList？

ArrayList 不是线程安全的，如果遇到多线程场景，可以通过 Collections 的 synchronizedList 方法将其转换成线程安全的容器后再使用。例如像下面这样：

为什么 ArrayList 的 elementData 加上 transient 修饰？

ArrayList 中的数组定义如下：

private transient Object[] elementData;

再看一下 ArrayList 的定义：

public class ArrayList

extends AbstractList

implements List, RandomAccess, Cloneable, java.io.Serializable

可以看到 ArrayList 实现了 Serializable 接口，这意味着 ArrayList 支持序列化。transient 的作用是说不希望 elementData 数组被序列化，重写了 writeObject 实现：

每次序列化时，先调用 defaultWriteObject() 方法序列化 ArrayList 中的非 transient 元素，然后遍历 elementData，只序列化已存入的元素，这样既加快了序列化的速度，又减小了序列化之后的文件大小。

List 和 Set 的区别 List , Set 都是继承自Collection 接口

List 特点：一个有序(元素存入集合的顺序和取出的顺序一致)容器，元素可以重复，可以插入多个null元素，元素都有索引。常用的实现类有 ArrayList、LinkedList 和 Vector。

Set 特点：一个无序(存入和取出顺序有可能不一致)容器，不可以存储重复元素，只允许存入一个null元素，必须保证元素唯一性。Set 接口常用实现类是 HashSet、LinkedHashSet 以及 TreeSet。

另外 List 支持for循环，也就是通过下标来遍历，也可以用迭代器，但是set只能用迭代，因为他无序，无法用下标来取得想要的值。

Set和List对比

Set：检索元素效率低下，删除和插入效率高，插入和删除不会引起元素位置改变。 List：和数组类似，List可以动态增长，查找元素效率高，插入删除元素效率低，因为会引起其他元素位置改变

Set接口

说一下 HashSet 的实现原理？

HashSet 是基于 HashMap 实现的，HashSet的值存放于HashMap的key上，HashMap的value统一为PRESENT，因此 HashSet 的实现比较简单，相关 HashSet 的操作，基本上都是直接调用底层 HashMap 的相关方法来完成，HashSet 不允许重复的值。

HashSet如何检查重复？HashSet是如何保证数据不可重复的？

向HashSet 中add ()元素时，判断元素是否存在的依据，不仅要比较hash值，同时还要结合equles 方法比较。 HashSet 中的add ()方法会使用HashMap 的put()方法。

HashMap 的 key 是唯一的，由源码可以看出 HashSet 添加进去的值就是作为HashMap 的key，并且在HashMap中如果K/V相同时，会用新的V覆盖掉旧的V，然后返回旧的V。所以不会重复( HashMap 比较key是否相等是先比较hashcode 再比较equals )。

以下是HashSet 部分源码：

hashCode()与equals()的相关规定：

如果两个对象相等，则hashcode一定也是相同的 两个对象相等,对两个equals方法返回true 两个对象有相同的hashcode值，它们也不一定是相等的 综上，equals方法被覆盖过，则hashCode方法也必须被覆盖 hashCode()的默认行为是对堆上的对象产生独特值。如果没有重写hashCode()，则该class的两个对象无论如何都不会相等(即使这两个对象指向相同的数据)。

** ==与equals的区别**

==是判断两个变量或实例是不是指向同一个内存空间 equals是判断两个变量或实例所指向的内存空间的值是不是相同 ==是指对内存地址进行比较 equals()是对字符串的内容进行比较3.==指引用是否相同 equals()指的是值是否相同

HashSet与HashMap的区别

Queue

BlockingQueue是什么？

Java.util.concurrent.BlockingQueue是一个队列，在进行检索或移除一个元素的时候，它会等待队列变为非空；当在添加一个元素时，它会等待队列中的可用空间。BlockingQueue接口是Java集合框架的一部分，主要用于实现生产者-消费者模式。我们不需要担心等待生产者有可用的空间，或消费者有可用的对象，因为它都在BlockingQueue的实现类中被处理了。Java提供了集中BlockingQueue的实现，比如ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue,、SynchronousQueue等。

在 Queue 中 poll()和 remove()有什么区别？

相同点：都是返回第一个元素，并在队列中删除返回的对象。 不同点：如果没有元素 poll()会返回 null，而 remove()会直接抛出 NoSuchElementException 异常。 代码示例：

Queue

queue = new LinkedList

(); queue. offer("string"); // add System. out. println(queue. poll()); System. out. println(queue. remove()); System. out. println(queue. size());

Map接口

说一下 HashMap 的实现原理？

HashMap概述： HashMap是基于哈希表的Map接口的非同步实现。此实现提供所有可选的映射操作，并允许使用null值和null键。此类不保证映射的顺序，特别是它不保证该顺序恒久不变。

HashMap的数据结构： 在Java编程语言中，最基本的结构就是两种，一个是数组，另外一个是模拟指针(引用)，所有的数据结构都可以用这两个基本结构来构造的，HashMap也不例外。HashMap实际上是一个“链表散列”的数据结构，即数组和链表的结合体。

HashMap 基于 Hash 算法实现的

当我们往Hashmap中put元素时，利用key的hashCode重新hash计算出当前对象的元素在数组中的下标存储时，如果出现hash值相同的key，此时有两种情况。(1)如果key相同，则覆盖原始值；(2)如果key不同(出现冲突)，则将当前的key-value放入链表中获取时，直接找到hash值对应的下标，在进一步判断key是否相同，从而找到对应值。理解了以上过程就不难明白HashMap是如何解决hash冲突的问题，核心就是使用了数组的存储方式，然后将冲突的key的对象放入链表中，一旦发现冲突就在链表中做进一步的对比。

需要注意Jdk 1.8中对HashMap的实现做了优化，当链表中的节点数据超过八个之后，该链表会转为红黑树来提高查询效率，从原来的O(n)到O(logn)

HashMap在JDK1.7和JDK1.8中有哪些不同？HashMap的底层实现

在Java中，保存数据有两种比较简单的数据结构：数组和链表。数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，但插入和删除容易；所以我们将数组和链表结合在一起，发挥两者各自的优势，使用一种叫做拉链法的方式可以解决哈希冲突。

JDK1.8之前

JDK1.8之前采用的是拉链法。拉链法：将链表和数组相结合。也就是说创建一个链表数组，数组中每一格就是一个链表。若遇到哈希冲突，则将冲突的值加到链表中即可。

JDK1.8之后

相比于之前的版本，jdk1.8在解决哈希冲突时有了较大的变化，当链表长度大于阈值(默认为8)时，将链表转化为红黑树，以减少搜索时间。

JDK1.7 VS JDK1.8 比较

JDK1.8主要解决或优化了一下问题：

resize 扩容优化引入了红黑树，目的是避免单条链表过长而影响查询效率，红黑树算法请参考解决了多线程死循环问题，但仍是非线程安全的，多线程时可能会造成数据丢失问题。

HashMap的put方法的具体流程？

当我们put的时候，首先计算 key的hash值，这里调用了 hash方法，hash方法实际是让key.hashCode()与key.hashCode()>>>16进行异或操作，高16bit补0，一个数和0异或不变，所以 hash 函数大概的作用就是：高16bit不变，低16bit和高16bit做了一个异或，目的是减少碰撞。按照函数注释，因为bucket数组大小是2的幂，计算下标index = (table.length - 1) & hash，如果不做 hash 处理，相当于散列生效的只有几个低 bit 位，为了减少散列的碰撞，设计者综合考虑了速度、作用、质量之后，使用高16bit和低16bit异或来简单处理减少碰撞，而且JDK8中用了复杂度 O(logn)的树结构来提升碰撞下的性能。

putVal方法执行流程图

①.判断键值对数组table[i]是否为空或为null，否则执行resize()进行扩容；

②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；

③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；

④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；

⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作；遍历过程中若发现key已经存在直接覆盖value即可；

⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。

HashMap的扩容操作是怎么实现的？

①.在jdk1.8中，resize方法是在hashmap中的键值对大于阀值时或者初始化时，就调用resize方法进行扩容；

②.每次扩展的时候，都是扩展2倍；

③.扩展后Node对象的位置要么在原位置，要么移动到原偏移量两倍的位置。

在putVal()中，我们看到在这个函数里面使用到了2次resize()方法，resize()方法表示的在进行第一次初始化时会对其进行扩容，或者当该数组的实际大小大于其临界值值(第一次为12),这个时候在扩容的同时也会伴随的桶上面的元素进行重新分发，这也是JDK1.8版本的一个优化的地方，在1.7中，扩容之后需要重新去计算其Hash值，根据Hash值对其进行分发，但在1.8版本中，则是根据在同一个桶的位置中进行判断(e.hash & oldCap)是否为0，重新进行hash分配后，该元素的位置要么停留在原始位置，要么移动到原始位置+增加的数组大小这个位置上

HashMap是怎么解决哈希冲突的？

答：在解决这个问题之前，我们首先需要知道什么是哈希冲突，而在了解哈希冲突之前我们还要知道什么是哈希才行；

什么是哈希？

Hash，一般翻译为“散列”，也有直接音译为“哈希”的，这就是把任意长度的输入通过散列算法，变换成固定长度的输出，该输出就是散列值(哈希值)；这种转换是一种压缩映射，也就是，散列值的空间通常远小于输入的空间，不同的输入可能会散列成相同的输出，所以不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。

所有散列函数都有如下一个基本特性**：根据同一散列函数计算出的散列值如果不同，那么输入值肯定也不同。但是，根据同一散列函数计算出的散列值如果相同，输入值不一定相同**。

什么是哈希冲突？

当两个不同的输入值，根据同一散列函数计算出相同的散列值的现象，我们就把它叫做碰撞(哈希碰撞)。

HashMap的数据结构 在Java中，保存数据有两种比较简单的数据结构：数组和链表。数组的特点是：寻址容易，插入和删除困难；链表的特点是：寻址困难，但插入和删除容易；所以我们将数组和链表结合在一起，发挥两者各自的优势，使用一种叫做链地址法的方式可以解决哈希冲突：

这样我们就可以将拥有相同哈希值的对象组织成一个链表放在hash值所对应的bucket下，但相比于hashCode返回的int类型，我们HashMap初始的容量大小DEFAULT_INITIAL_CAPACITY = 1 << 4(即2的四次方16)要远小于int类型的范围，所以我们如果只是单纯的用hashCode取余来获取对应的bucket这将会大大增加哈希碰撞的概率，并且最坏情况下还会将HashMap变成一个单链表，所以我们还需要对hashCode作一定的优化

hash()函数

上面提到的问题，主要是因为如果使用hashCode取余，那么相当于参与运算的只有hashCode的低位，高位是没有起到任何作用的，所以我们的思路就是让hashCode取值出的高位也参与运算，进一步降低hash碰撞的概率，使得数据分布更平均，我们把这样的操作称为扰动，在JDK 1.8中的hash()函数如下：

static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);// 与自己右移16位进行异或运算(高低位异或) }

这比在JDK 1.7中，更为简洁，相比在1.7中的4次位运算，5次异或运算(9次扰动)，在1.8中，只进行了1次位运算和1次异或运算(2次扰动)；

JDK1.8新增红黑树

通过上面的链地址法(使用散列表)和扰动函数我们成功让我们的数据分布更平均，哈希碰撞减少，但是当我们的HashMap中存在大量数据时，加入我们某个bucket下对应的链表有n个元素，那么遍历时间复杂度就为O(n)，为了针对这个问题，JDK1.8在HashMap中新增了红黑树的数据结构，进一步使得遍历复杂度降低至O(logn)；

总结

简单总结一下HashMap是使用了哪些方法来有效解决哈希冲突的：

使用链地址法(使用散列表)来链接拥有相同hash值的数据；使用2次扰动函数(hash函数)来降低哈希冲突的概率，使得数据分布更平均；引入红黑树进一步降低遍历的时间复杂度，使得遍历更快；

**能否使用任何类作为 Map 的 key？

**可以使用任何类作为 Map 的 key，然而在使用之前，需要考虑以下几点：

如果类重写了 equals() 方法，也应该重写 hashCode() 方法。

类的所有实例需要遵循与 equals() 和 hashCode() 相关的规则。

如果一个类没有使用 equals()，不应该在 hashCode() 中使用它。

用户自定义 Key 类最佳实践是使之为不可变的，这样 hashCode() 值可以被缓存起来，拥有更好的性能。不可变的类也可以确保 hashCode() 和 equals() 在未来不会改变，这样就会解决与可变相关的问题了。

为什么HashMap中String、Integer这样的包装类适合作为K？

答：String、Integer等包装类的特性能够保证Hash值的不可更改性和计算准确性，能够有效的减少Hash碰撞的几率

都是final类型，即不可变性，保证key的不可更改性，不会存在获取hash值不同的情况 内部已重写了equals()、hashCode()等方法，遵守了HashMap内部的规范(不清楚可以去上面看看putValue的过程)，不容易出现Hash值计算错误的情况；

如果使用Object作为HashMap的Key，应该怎么办呢？

答：重写hashCode()和equals()方法

重写hashCode()是因为需要计算存储数据的存储位置，需要注意不要试图从散列码计算中排除掉一个对象的关键部分来提高性能，这样虽然能更快但可能会导致更多的Hash碰撞； 重写equals()方法，需要遵守自反性、对称性、传递性、一致性以及对于任何非null的引用值x，x.equals(null)必须返回false的这几个特性，目的是为了保证key在哈希表中的唯一性；

HashMap为什么不直接使用hashCode()处理后的哈希值直接作为table的下标

答：hashCode()方法返回的是int整数类型，其范围为-(2 ^ 31)~(2 ^ 31 - 1)，约有40亿个映射空间，而HashMap的容量范围是在16(初始化默认值)~2 ^ 30，HashMap通常情况下是取不到最大值的，并且设备上也难以提供这么多的存储空间，从而导致通过hashCode()计算出的哈希值可能不在数组大小范围内，进而无法匹配存储位置；

那怎么解决呢？

HashMap自己实现了自己的hash()方法，通过两次扰动使得它自己的哈希值高低位自行进行异或运算，降低哈希碰撞概率也使得数据分布更平均； 在保证数组长度为2的幂次方的时候，使用hash()运算之后的值与运算(&)(数组长度 - 1)来获取数组下标的方式进行存储，这样一来是比取余操作更加有效率，二来也是因为只有当数组长度为2的幂次方时，h&(length-1)才等价于h%length，三来解决了“哈希值与数组大小范围不匹配”的问题； HashMap 的长度为什么是2的幂次方 为了能让 HashMap 存取高效，尽量较少碰撞，也就是要尽量把数据分配均匀，每个链表/红黑树长度大致相同。这个实现就是把数据存到哪个链表/红黑树中的算法。

这个算法应该如何设计呢？

我们首先可能会想到采用%取余的操作来实现。但是，重点来了：“取余(%)操作中如果除数是2的幂次则等价于与其除数减一的与(&)操作(也就是说 hash%length==hash&(length-1)的前提是 length 是2的 n 次方；)。” 并且 采用二进制位操作 &，相对于%能够提高运算效率，这就解释了 HashMap 的长度为什么是2的幂次方。

那为什么是两次扰动呢？

答：这样就是加大哈希值低位的随机性，使得分布更均匀，从而提高对应数组存储下标位置的随机性&均匀性，最终减少Hash冲突，两次就够了，已经达到了高位低位同时参与运算的目的；

HashMap 与 HashTable 有什么区别？

线程安全： HashMap 是非线程安全的，HashTable 是线程安全的；HashTable 内部的方法基本都经过 synchronized 修饰。(如果你要保证线程安全的话就使用 ConcurrentHashMap 吧！)； 效率： 因为线程安全的问题，HashMap 要比 HashTable 效率高一点。另外，HashTable 基本被淘汰，不要在代码中使用它； 对Null key 和Null value的支持： HashMap 中，null 可以作为键，这样的键只有一个，可以有一个或多个键所对应的值为 null。但是在 HashTable 中 put 进的键值只要有一个 null，直接抛NullPointerException。 **初始容量大小和每次扩充容量大小的不同 **： ①创建时如果不指定容量初始值，Hashtable 默认的初始大小为11，之后每次扩充，容量变为原来的2n+1。HashMap 默认的初始化大小为16。之后每次扩充，容量变为原来的2倍。②创建时如果给定了容量初始值，那么 Hashtable 会直接使用你给定的大小，而 HashMap 会将其扩充为2的幂次方大小。也就是说 HashMap 总是使用2的幂作为哈希表的大小，后面会介绍到为什么是2的幂次方。 底层数据结构： JDK1.8 以后的 HashMap 在解决哈希冲突时有了较大的变化，当链表长度大于阈值(默认为8)时，将链表转化为红黑树，以减少搜索时间。Hashtable 没有这样的机制。 推荐使用：在 Hashtable 的类注释可以看到，Hashtable 是保留类不建议使用，推荐在单线程环境下使用 HashMap 替代，如果需要多线程使用则用 ConcurrentHashMap 替代。

如何决定使用 HashMap 还是 TreeMap？

对于在Map中插入、删除和定位元素这类操作，HashMap是最好的选择。然而，假如你需要对一个有序的key集合进行遍历，TreeMap是更好的选择。基于你的collection的大小，也许向HashMap中添加元素会更快，将map换为TreeMap进行有序key的遍历。

HashMap 和 ConcurrentHashMap 的区别 ConcurrentHashMap对整个桶数组进行了分割分段(Segment)，然后在每一个分段上都用lock锁进行保护，相对于HashTable的synchronized锁的粒度更精细了一些，并发性能更好，而HashMap没有锁机制，不是线程安全的。(JDK1.8之后ConcurrentHashMap启用了一种全新的方式实现,利用CAS算法。) HashMap的键值对允许有null，但是ConCurrentHashMap都不允许。

ConcurrentHashMap 和 Hashtable 的区别？

ConcurrentHashMap 和 Hashtable 的区别主要体现在实现线程安全的方式上不同。

底层数据结构： JDK1.7的 ConcurrentHashMap 底层采用 分段的数组+链表 实现，JDK1.8 采用的数据结构跟HashMap1.8的结构一样，数组+链表/红黑二叉树。Hashtable 和 JDK1.8 之前的 HashMap 的底层数据结构类似都是采用 数组+链表 的形式，数组是 HashMap 的主体，链表则是主要为了解决哈希冲突而存在的； 实现线程安全的方式(重要)： ① 在JDK1.7的时候，ConcurrentHashMap(分段锁) 对整个桶数组进行了分割分段(Segment)，每一把锁只锁容器其中一部分数据，多线程访问容器里不同数据段的数据，就不会存在锁竞争，提高并发访问率。(默认分配16个Segment，比Hashtable效率提高16倍。) 到了 JDK1.8 的时候已经摒弃了Segment的概念，而是直接用 Node 数组+链表+红黑树的数据结构来实现，并发控制使用 synchronized 和 CAS 来操作。(JDK1.6以后 对 synchronized锁做了很多优化) 整个看起来就像是优化过且线程安全的 HashMap，虽然在JDK1.8中还能看到 Segment 的数据结构，但是已经简化了属性，只是为了兼容旧版本；② Hashtable(同一把锁) :使用 synchronized 来保证线程安全，效率非常低下。当一个线程访问同步方法时，其他线程也访问同步方法，可能会进入阻塞或轮询状态，如使用 put 添加元素，另一个线程不能使用 put 添加元素，也不能使用 get，竞争会越来越激烈效率越低。

两者的对比图：

HashTable:

JDK1.7的ConcurrentHashMap：

JDK1.8的ConcurrentHashMap(TreeBin: 红黑二叉树节点 Node: 链表节点)：

答：ConcurrentHashMap 结合了 HashMap 和 HashTable 二者的优势。HashMap 没有考虑同步，HashTable 考虑了同步的问题。但是 HashTable 在每次同步执行时都要锁住整个结构。 ConcurrentHashMap 锁的方式是稍微细粒度的。

ConcurrentHashMap 底层具体实现知道吗？实现原理是什么？ JDK1.7

首先将数据分为一段一段的存储，然后给每一段数据配一把锁，当一个线程占用锁访问其中一个段数据时，其他段的数据也能被其他线程访问。

在JDK1.7中，ConcurrentHashMap采用Segment + HashEntry的方式进行实现，结构如下：

一个 ConcurrentHashMap 里包含一个 Segment 数组。Segment 的结构和HashMap类似，是一种数组和链表结构，一个 Segment 包含一个 HashEntry 数组，每个 HashEntry 是一个链表结构的元素，每个 Segment 守护着一个HashEntry数组里的元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment的锁。

该类包含两个静态内部类 HashEntry 和 Segment ；前者用来封装映射表的键值对，后者用来充当锁的角色；Segment 是一种可重入的锁 ReentrantLock，每个 Segment 守护一个HashEntry 数组里得元素，当对 HashEntry 数组的数据进行修改时，必须首先获得对应的 Segment 锁。

JDK1.8

在JDK1.8中，放弃了Segment臃肿的设计，取而代之的是采用Node + CAS + Synchronized来保证并发安全进行实现，synchronized只锁定当前链表或红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升N倍。

结构如下：

如果该节点是TreeBin类型的节点，说明是红黑树结构，则通过putTreeVal方法往红黑树中插入节点；如果binCount不为0，说明put操作对数据产生了影响，如果当前链表的个数达到8个，则通过treeifyBin方法转化为红黑树，如果oldVal不为空，说明是一次更新操作，没有对元素个数产生影响，则直接返回旧值；如果插入的是一个新节点，则执行addCount()方法尝试更新元素个数baseCount；

辅助工具类

Array 和 ArrayList 有何区别？

Array 可以存储基本数据类型和对象，ArrayList 只能存储对象。Array 是指定固定大小的，而 ArrayList 大小是自动扩展的。Array 内置方法没有 ArrayList 多，比如 addAll、removeAll、iteration 等方法只有 ArrayList 有。

对于基本类型数据，集合使用自动装箱来减少编码工作量。但是，当处理固定大小的基本数据类型的时候，这种方式相对比较慢。

如何实现 Array 和 List 之间的转换？

Array 转 List： Arrays. asList(array) ；List 转 Array：List 的 toArray() 方法。

comparable 和 comparator的区别？

comparable接口实际上是出自java.lang包，它有一个 compareTo(Object obj)方法用来排序comparator接口实际上是出自 java.util 包，它有一个compare(Object obj1, Object obj2)方法用来排序

一般我们需要对一个集合使用自定义排序时，我们就要重写compareTo方法或compare方法，当我们需要对某一个集合实现两种排序方式，比如一个song对象中的歌名和歌手名分别采用一种排序方法的话，我们可以重写compareTo方法和使用自制的Comparator方法或者以两个Comparator来实现歌名排序和歌星名排序，第二种代表我们只能使用两个参数版的Collections.sort().

方法如何比较元素？

TreeSet 要求存放的对象所属的类必须实现 Comparable 接口，该接口提供了比较元素的 compareTo()方法，当插入元素时会回调该方法比较元素的大小。TreeMap 要求存放的键值对映射的键必须实现 Comparable 接口从而根据键对元素进 行排 序。

Collections 工具类的 sort 方法有两种重载的形式，

第一种要求传入的待排序容器中存放的对象比较实现 Comparable 接口以实现元素的比较；

第二种不强制性的要求容器中的元素必须可比较，但是要求传入第二个参数，参数是Comparator 接口的子类型(需要重写 compare 方法实现元素的比较)，相当于一个临时定义的排序规则，其实就是通过接口注入比较元素大小的算法，也是对回调模式的应用(Java 中对函数式编程的支持)。

剑曼红尘

2020-03-24 14:41:57

0 浏览量

回答数 0

问题

【今日算法】备战大厂必备题目，持续更新

学习算法，每天进步一点点! 想要进入大厂，发现算法题总是困难重重，我们整理了备战大厂那些必不可少的算法题目，周一到周五每天更新一道，答案会在出题第二天倾情奉上哦~

72...

游客ih62co2qqq5ww

2020-04-08 09:21:40

3542 浏览量

回答数 4

问题

OpenSearch的搜索相关的有哪些？

搜索

系统提供了丰富的搜索语法以满足用户各种场景下的搜索需求。

URL

/search

支持格式

JSON

HTTP请求方式

GET

请求参数

参数类型必需取值范围默认值描述querystring是搜索主...

轩墨

2019-12-01 20:56:46

1333 浏览量

回答数 0

问题

OpenSearch的搜索处理是什么？

Search 搜索

系统提供了丰富的搜索语法以满足用户各种场景下的搜索需求。

URL

/v3/openapi/apps/$app_name/search?fetch_fields=name&query=c...

轩墨

2019-12-01 20:57:06

1661 浏览量

回答数 0

回答

Arraylist和Vector是采用数组方式存储数据，此数组元素数大于实际存储的数据以便增加插入元素，都允许直接序号索引元素，但是插入数据要涉及到数组元素移动等内存操作，所以插入数据慢，查找有下标，所以查询数据快，Vector由于使用了synchronized方法-线程安全，所以性能上比ArrayList要差，LinkedList使用双向链表实现存储，按序号索引数据需要进行向前或向后遍历，但是插入数据时只需要记录本项前后项即可，插入数据较快。线性表，链表，哈希表是常用的数据结构，在进行java开发时，JDK已经为我们提供了一系列相应的类实现基本的数据结构，这些结构均在java.util包中，collection├List│├LinkedList│├ArrayList│└Vector│　└Stack└SetMap├Hashtable├HashMap└WeakHashMapCollection接口Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素(elements)，一些Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：　　　　Iterator it = collection.iterator(); // 获得一个迭代子　　　　while(it.hasNext()) {　　　　　　Object obj = it.next(); // 得到下一个元素　　　　}　　由Collection接口派生的两个接口是List和Set。List接口　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引(元素在List中的位置，类似于数组下标)来访问List中的元素，这类似于Java的数组。和下面要提到的Set不同，List允许有相同的元素。　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。ArrayList类　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。　　每个ArrayList实例都有一个容量(Capacity)，即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。　　和LinkedList一样，ArrayList也是非同步的(unsynchronized)。Vector类　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态(例如，添加或删除了一些元素)，这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。Stack 类　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。Map接口　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。Hashtable类　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空(non-null)的对象都可作为key或者value。　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：　　　　Hashtable numbers = new Hashtable();　　　　numbers.put(“one”, new Integer(1));　　　　numbers.put(“two”, new Integer(2));　　　　numbers.put(“three”, new Integer(3));　　要取出一个数，比如2，用相应的key：　　　　Integer n = (Integer)numbers.get(“two”);　　　　System.out.println(“two = ” + n);　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果(期待的get方法返回null)，要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。　　Hashtable是同步的。HashMap类　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时(values()方法可返回Collection)，其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。WeakHashMap类　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。总结　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。同步性Vector是同步的。这个类中的一些方法保证了Vector中的对象是线程安全的。而ArrayList则是异步的，因此ArrayList中的对象并不是线程安全的。因为同步的要求会影响执行的效率，所以如果你不需要线程安全的集合那么使用ArrayList是一个很好的选择，这样可以避免由于同步带来的不必要的性能开销。数据增长从内部实现机制来讲ArrayList和Vector都是使用数组(Array)来控制集合中的对象。当你向这两种类型中增加元素的时候，如果元素的数目超出了内部数组目前的长度它们都需要扩展内部数组的长度，Vector缺省情况下自动增长原来一倍的数组长度，ArrayList是原来的50%,所以最后你获得的这个集合所占的空间总是比你实际需要的要大。所以如果你要在集合中保存大量的数据那么使用Vector有一些优势，因为你可以通过设置集合的初始化大小来避免不必要的资源开销。使用模式在ArrayList和Vector中，从一个指定的位置(通过索引)查找数据或是在集合的末尾增加、移除一个元素所花费的时间是一样的，这个时间我们用O(1)表示。但是，如果在集合的其他位置增加或移除元素那么花费的时间会呈线形增长：O(n-i)，其中n代表集合中元素的个数，i代表元素增加或移除元素的索引位置。为什么会这样呢？以为在进行上述操作的时候集合中第i和第i个元素之后的所有元素都要执行位移的操作。这一切意味着什么呢？这意味着，你只是查找特定位置的元素或只在集合的末端增加、移除元素，那么使用Vector或ArrayList都可以。如果是其他操作，你最好选择其他的集合操作类。比如，LinkList集合类在增加或移除集合中任何位置的元素所花费的时间都是一样的?O(1)，但它在索引一个元素的使用缺比较慢－O(i),其中i是索引的位置.使用ArrayList也很容易，因为你可以简单的使用索引来代替创建iterator对象的操作。LinkList也会为每个插入的元素创建对象，所有你要明白它也会带来额外的开销。最后，在《Practical Java》一书中Peter Haggar建议使用一个简单的数组(Array)来代替Vector或ArrayList。尤其是对于执行效率要求高的程序更应如此。因为使用数组(Array)避免了同步、额外的方法调用和不必要的重新分配空间的操作。

wangccsy

2019-12-02 01:48:37

0 浏览量

回答数 0

回答

官方文档上列举共有32种常见算子，包括Transformation的20种操作和Action的12种操作。

Transformation：

1.map

map的输入变换函数应用于RDD中所有元素，而mapPartitions应用于所有分区。区别于mapPartitions主要在于调用粒度不同。如parallelize(1 to 10， 3)，map函数执行10次，而mapPartitions函数执行3次。

​

2.filter(function)

过滤操作，满足filter内function函数为true的RDD内所有元素组成一个新的数据集。如：filter(a == 1)。

3.flatMap(function)

map是对RDD中元素逐一进行函数操作映射为另外一个RDD，而flatMap操作是将函数应用于RDD之中的每一个元素，将返回的迭代器的所有内容构成新的RDD。而flatMap操作是将函数应用于RDD中每一个元素，将返回的迭代器的所有内容构成RDD。

flatMap与map区别在于map为“映射”，而flatMap“先映射，后扁平化”，map对每一次(func)都产生一个元素，返回一个对象，而flatMap多一步就是将所有对象合并为一个对象。

4.mapPartitions(function)

区于foreachPartition(属于Action，且无返回值)，而mapPartitions可获取返回值。与map的区别前面已经提到过了，但由于单独运行于RDD的每个分区上(block)，所以在一个类型为T的RDD上运行时，(function)必须是Iterator

=> Iterator

类型的方法(入参)。

5.mapPartitionsWithIndex(function) 与mapPartitions类似，但需要提供一个表示分区索引值的整型值作为参数，因此function必须是(int， Iterator

)=>Iterator

类型的。

​ 6.sample(withReplacement， fraction， seed) 采样操作，用于从样本中取出部分数据。withReplacement是否放回，fraction采样比例，seed用于指定的随机数生成器的种子。(是否放回抽样分true和false，fraction取样比例为(0, 1]。seed种子为整型实数。) ​ 7.union(otherDataSet) 对于源数据集和其他数据集求并集，不去重。 ​ 8.intersection(otherDataSet) 对于源数据集和其他数据集求交集，并去重，且无序返回。 ​ 9.distinct([numTasks]) 返回一个在源数据集去重之后的新数据集，即去重，并局部无序而整体有序返回。 ​ ​ 10.groupByKey([numTasks]) 在一个PairRDD或(k,v)RDD上调用，返回一个(k,Iterable

)。主要作用是将相同的所有的键值对分组到一个集合序列当中，其顺序是不确定的。groupByKey是把所有的键值对集合都加载到内存中存储计算，若一个键对应值太多，则易导致内存溢出。

在此，用之前求并集的union方法，将pair1，pair2变为有相同键值的pair3，而后进行groupByKey ​ 11.reduceByKey(function，[numTasks]) 与groupByKey类似，却有不同。如(a,1), (a,2), (b,1), (b,2)。groupByKey产生中间结果为( (a,1), (a,2) ), ( (b,1), (b,2) )。而reduceByKey为(a,3), (b,3)。 reduceByKey主要作用是聚合，groupByKey主要作用是分组。(function对于key值来进行聚合) ​ 12.aggregateByKey(zeroValue)(seqOp， combOp， [numTasks]) 类似reduceByKey，对pairRDD中想用的key值进行聚合操作，使用初始值(seqOp中使用，而combOpenCL中未使用)对应返回值为pairRDD，而区于aggregate(返回值为非RDD) ​ 13.sortByKey([ascending], [numTasks]) 同样是基于pairRDD的，根据key值来进行排序。ascending升序，默认为true，即升序；numTasks 14.join(otherDataSet，[numTasks]) 加入一个RDD，在一个(k，v)和(k，w)类型的dataSet上调用，返回一个(k，(v，w))的pair dataSet。 ​ 15.cogroup(otherDataSet，[numTasks]) 合并两个RDD，生成一个新的RDD。实例中包含两个Iterable值，第一个表示RDD1中相同值，第二个表示RDD2中相同值(key值)，这个操作需要通过partitioner进行重新分区，因此需要执行一次shuffle操作。(若两个RDD在此之前进行过shuffle，则不需要) ​ 16.cartesian(otherDataSet) 求笛卡尔乘积。该操作不会执行shuffle操作。 ​ 17.pipe(command，[envVars]) 通过一个shell命令来对RDD各分区进行“管道化”。通过pipe变换将一些shell命令用于Spark中生成的新RDD，如： ​ 18.coalesce(numPartitions) 重新分区，减少RDD中分区的数量到numPartitions。 ​ 19.repartition(numPartitions) repartition是coalesce接口中shuffle为true的简易实现，即Reshuffle RDD并随机分区，使各分区数据量尽可能平衡。若分区之后分区数远大于原分区数，则需要shuffle。 ​ 20.repartitionAndSortWithinPartitions(partitioner) 该方法根据partitioner对RDD进行分区，并且在每个结果分区中按key进行排序。 Action： 1.reduce(function) reduce将RDD中元素两两传递给输入函数，同时产生一个新值，新值与RDD中下一个元素再被传递给输入函数，直到最后只有一个值为止。 ​ 2.collect() 将一个RDD以一个Array数组形式返回其中的所有元素。 ​ 3.count() 返回数据集中元素个数，默认Long类型。 ​ 4.first() 返回数据集的第一个元素(类似于take(1)) ​ 5.takeSample(withReplacement， num， [seed]) 对于一个数据集进行随机抽样，返回一个包含num个随机抽样元素的数组，withReplacement表示是否有放回抽样，参数seed指定生成随机数的种子。 该方法仅在预期结果数组很小的情况下使用，因为所有数据都被加载到driver端的内存中。 ​ 6.take(n) 返回一个包含数据集前n个元素的数组(从0下标到n-1下标的元素)，不排序。 ​ 7.takeOrdered(n，[ordering]) 返回RDD中前n个元素，并按默认顺序排序(升序)或者按自定义比较器顺序排序。 ​ 8.saveAsTextFile(path) 将dataSet中元素以文本文件的形式写入本地文件系统或者HDFS等。Spark将对每个元素调用toString方法，将数据元素转换为文本文件中的一行记录。 若将文件保存到本地文件系统，那么只会保存在executor所在机器的本地目录。 ​ 9.saveAsSequenceFile(path)(Java and Scala) 将dataSet中元素以Hadoop SequenceFile的形式写入本地文件系统或者HDFS等。(对pairRDD操作) ​ 10.saveAsObjectFile(path)(Java and Scala) 将数据集中元素以ObjectFile形式写入本地文件系统或者HDFS等。 ​ ​ 11.countByKey() 用于统计RDD[K,V]中每个K的数量，返回具有每个key的计数的(k，int)pairs的hashMap。 ​ 12.foreach(function) 对数据集中每一个元素运行函数function。

bigbigtree

2020-03-19 19:21:30

0 浏览量

回答数 0

回答

计算机的算法具有可行性，有穷性、输入\输出、确定性。

计算机算法特点

1.有穷性。一个算法应包含有限的操作步骤，而不能是无限的。事实上“有穷性”往往指“在合理的范围之内”。如果让计算机执行一个历时1000年才结束的算法，这虽然是有穷的，但超过了合理的限度，人们不把他视为有效算法。

2. 确定性。算法中的每一个步骤都应当是确定的，而不应当是含糊的、模棱两可的。算法中的每一个步骤应当不致被解释成不同的含义，而应是十分明确的。也就是说，算法的含义应当是唯一的，而不应当产生“歧义性”。

3. 有零个或多个输入、所谓输入是指在执行算法是需要从外界取得必要的信息。

4. 有一个或多个输出。算法的目的是为了求解，没有输出的算法是没有意义的。

5.有效性。 算法中的每一个 步骤都应当能有效的执行。并得到确定的结果。 拓展资料：

重要算法

A*搜寻算法

俗称A星算法。这是一种在图形平面上，有多个节点的路径，求出最低通过成本的算法。常用于游戏中的NPC的移动计算，或线上游戏的BOT的移动计算上。该算法像Dijkstra算法一样，可以找到一条最短路径；也像BFS一样，进行启发式的搜索。

Beam Search

束搜索(beam search)方法是解决优化问题的一种启发式方法，它是在分枝定界方法基础上发展起来的，它使用启发式方法估计k个最好的路径，仅从这k个路径出发向下搜索，即每一层只有满意的结点会被保留，其它的结点则被永久抛弃，从而比分枝定界法能大大节省运行时间。束搜索于20 世纪70年代中期首先被应用于人工智能领域,1976 年Lowerre在其称为HARPY的语音识别系统中第一次使用了束搜索方法。他的目标是并行地搜索几个潜在的最优决策路径以减少回溯，并快速地获得一个解。

二分取中查找算法

一种在有序数组中查找某一特定元素的搜索算法。搜索过程从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于中间元素的那一半中查找，而且跟开始一样从中间元素开始比较。这种搜索算法每一次比较都使搜索范围缩小一半。

Branch and bound

分支定界(branch and bound)算法是一种在问题的解空间树上搜索问题的解的方法。但与回溯算法不同，分支定界算法采用广度优先或最小耗费优先的方法搜索解空间树，并且，在分支定界算法中，每一个活结点只有一次机会成为扩展结点。

数据压缩

数据压缩是通过减少计算机中所存储数据或者通信传播中数据的冗余度，达到增大数据密度，最终使数据的存储空间减少的技术。数据压缩在文件存储和分布式系统领域有着十分广泛的应用。数据压缩也代表着尺寸媒介容量的增大和网络带宽的扩展。

Diffie–Hellman密钥协商

Diffie–Hellman key exchange，简称“D–H”，是一种安全协议。它可以让双方在完全没有对方任何预先信息的条件下通过不安全信道建立起一个密钥。这个密钥可以在后续的通讯中作为对称密钥来加密通讯内容。

Dijkstra’s 算法

迪科斯彻算法(Dijkstra)是由荷兰计算机科学家艾兹格·迪科斯彻(Edsger Wybe Dijkstra)发明的。算法解决的是有向图中单个源点到其他顶点的最短路径问题。举例来说，如果图中的顶点表示城市，而边上的权重表示著城市间开车行经的距离，迪科斯彻算法可以用来找到两个城市之间的最短路径。

动态规划

动态规划是一种在数学和计算机科学中使用的，用于求解包含重叠子问题的最优化问题的方法。其基本思想是，将原问题分解为相似的子问题，在求解的过程中通过子问题的解求出原问题的解。动态规划的思想是多种算法的基础，被广泛应用于计算机科学和工程领域。比较著名的应用实例有：求解最短路径问题，背包问题，项目管理，网络流优化等。这里也有一篇文章说得比较详细。

欧几里得算法

在数学中，辗转相除法，又称欧几里得算法，是求最大公约数的算法。辗转相除法首次出现于欧几里得的《几何原本》(第VII卷，命题i和ii)中，而在中国则可以追溯至东汉出现的《九章算术》。

最大期望(EM)算法

在统计计算中，最大期望(EM)算法是在概率(probabilistic)模型中寻找参数最大似然估计的算法，其中概率模型依赖于无法观测的隐藏变量(Latent Variable)。最大期望经常用在机器学习和计算机视觉的数据聚类(Data Clustering)领域。最大期望算法经过两个步骤交替进行计算，第一步是计算期望(E)，利用对隐藏变量的现有估计值，计算其最大似然估计值；第二步是最大化(M)，最大化在 E 步上求得的最大似然值来计算参数的值。M 步上找到的参数估计值被用于下一个 E 步计算中，这个过程不断交替进行。

快速傅里叶变换(FFT)

快速傅里叶变换(Fast Fourier Transform，FFT)，是离散傅里叶变换的快速算法，也可用于计算离散傅里叶变换的逆变换。快速傅里叶变换有广泛的应用，如数字信号处理、计算大整数乘法、求解偏微分方程等等。

哈希函数

HashFunction是一种从任何一种数据中创建小的数字“指纹”的方法。该函数将数据打乱混合，重新创建一个叫做散列值的指纹。散列值通常用来代表一个短的随机字母和数字组成的字符串。好的散列函数在输入域中很少出现散列冲突。在散列表和数据处理中，不抑制冲突来区别数据，会使得数据库记录更难找到。

堆排序

Heapsort是指利用堆积树(堆)这种数据结构所设计的一种排序算法。堆积树是一个近似完全二叉树的结构，并同时满足堆积属性：即子结点的键值或索引总是小于(或者大于)它的父结点。

归并排序

Merge sort是建立在归并操作上的一种有效的排序算法。该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。

RANSAC 算法

RANSAC 是”RANdom SAmpleConsensus”的缩写。该算法是用于从一组观测数据中估计数学模型参数的迭代方法，由Fischler and Bolles在1981提出，它是一种非确定性算法，因为它只能以一定的概率得到合理的结果，随着迭代次数的增加，这种概率是增加的。该算法的基本假设是观测数据集中存在”inliers”(那些对模型参数估计起到支持作用的点)和”outliers”(不符合模型的点)，并且这组观测数据受到噪声影响。RANSAC 假设给定一组”inliers”数据就能够得到最优的符合这组点的模型。

RSA加密演算法

这是一个公钥加密算法，也是世界上第一个适合用来做签名的算法。今天的RSA已经专利失效，其被广泛地用于电子商务加密，大家都相信，只要密钥足够长，这个算法就会是安全的。

并查集Union-find

并查集是一种树型的数据结构，用于处理一些不相交集合(Disjoint Sets)的合并及查询问题。常常在使用中以森林来表示。

Viterbi algorithm

寻找最可能的隐藏状态序列(Finding most probable sequence of hidden states)。 参考资料：计算机算法

游客886

2019-12-02 01:17:57

0 浏览量

回答数 0

问题

【面试必备】2020最新Java集合容器面试题

【面试必备】2020最新Java集合容器面试题

集合容器概述

什么是集合

集合框架：用于存储数据的容器。

集合框架是为表示和操作集合而规定的一种统一的标准的体系结构。 任何集合框架都包含三大块内容：对外的...

剑曼红尘

2020-03-24 14:00:04

7 浏览量

回答数 1

问题

理解MySQL——索引与优化

索引对查询的速度有着至关重要的影响，理解索引也是进行数据库性能调优的起点。考虑如下情况，假设数据库中一个表有10^6条记录，DBMS的页面大小为4K，并存储100条记录。如果没有索引&...

老毛哈哈

2019-12-01 21:05:12

9617 浏览量

回答数 1

回答

Kafka 是一个消息系统，原本开发自 LinkedIn，用作 LinkedIn 的活动流(Activity Stream)和运营数据处理管道(Pipeline)的基础。现在它已被多家公司作为多种类型的数据管道和消息系统使用。活动流数据是几乎所有站点在对其网站使用情况做报表时都要用到的数据中最常规的部分。活动数据包括页面访问量(Page View)、被查看内容方面的信息以及搜索情况等内容。这种数据通常的处理方式是先把各种活动以日志的形式写入某种文件，然后周期性地对这些文件进行统计分析。运营数据指的是服务器的性能数据(CPU、IO 使用率、请求时间、服务日志等等数据)，总的来说，运营数据的统计方法种类繁多。Kafka 专用术语Broker：Kafka 集群包含一个或多个服务器，这种服务器被称为 broker。Topic：每条发布到 Kafka 集群的消息都有一个类别，这个类别被称为 Topic。(物理上不同 Topic 的消息分开存储，逻辑上一个 Topic 的消息虽然保存于一个或多个 broker 上，但用户只需指定消息的 Topic 即可生产或消费数据而不必关心数据存于何处)。Partition：Partition 是物理上的概念，每个 Topic 包含一个或多个 Partition。Producer：负责发布消息到 Kafka broker。Consumer：消息消费者，向 Kafka broker 读取消息的客户端。Consumer Group：每个 Consumer 属于一个特定的 Consumer Group(可为每个 Consumer 指定 group name，若不指定 group name 则属于默认的 group)。Kafka 交互流程Kafka 是一个基于分布式的消息发布-订阅系统，它被设计成快速、可扩展的、持久的。与其他消息发布-订阅系统类似，Kafka 在主题当中保存消息的信息。生产者向主题写入数据，消费者从主题读取数据。由于 Kafka 的特性是支持分布式，同时也是基于分布式的，所以主题也是可以在多个节点上被分区和覆盖的。信息是一个字节数组，程序员可以在这些字节数组中存储任何对象，支持的数据格式包括 String、JSON、Avro。Kafka 通过给每一个消息绑定一个键值的方式来保证生产者可以把所有的消息发送到指定位置。属于某一个消费者群组的消费者订阅了一个主题，通过该订阅消费者可以跨节点地接收所有与该主题相关的消息，每一个消息只会发送给群组中的一个消费者，所有拥有相同键值的消息都会被确保发给这一个消费者。Kafka 设计中将每一个主题分区当作一个具有顺序排列的日志。同处于一个分区中的消息都被设置了一个唯一的偏移量。Kafka 只会保持跟踪未读消息，一旦消息被置为已读状态，Kafka 就不会再去管理它了。Kafka 的生产者负责在消息队列中对生产出来的消息保证一定时间的占有，消费者负责追踪每一个主题 (可以理解为一个日志通道) 的消息并及时获取它们。基于这样的设计，Kafka 可以在消息队列中保存大量的开销很小的数据，并且支持大量的消费者订阅。利用 Apache Kafka 系统架构的设计思路示例：网络游戏假设我们正在开发一个在线网络游戏平台，这个平台需要支持大量的在线用户实时操作，玩家在一个虚拟的世界里通过互相协作的方式一起完成每一个任务。由于游戏当中允许玩家互相交易金币、道具，我们必须确保玩家之间的诚信关系，而为了确保玩家之间的诚信及账户安全，我们需要对玩家的 IP 地址进行追踪，当出现一个长期固定 IP 地址忽然之间出现异动情况，我们要能够预警，同时，如果出现玩家所持有的金币、道具出现重大变更的情况，也要能够及时预警。此外，为了让开发组的数据工程师能够测试新的算法，我们要允许这些玩家数据进入到 Hadoop 集群，即加载这些数据到 Hadoop 集群里面。对于一个实时游戏，我们必须要做到对存储在服务器内存中的数据进行快速处理，这样可以帮助实时地发出预警等各类动作。我们的系统架设拥有多台服务器，内存中的数据包括了每一个在线玩家近 30 次访问的各类记录，包括道具、交易信息等等，并且这些数据跨服务器存储。我们的服务器拥有两个角色：首先是接受用户发起的动作，例如交易请求，其次是实时地处理用户发起的交易并根据交易信息发起必要的预警动作。为了保证快速、实时地处理数据，我们需要在每一台机器的内存中保留历史交易信息，这意味着我们必须在服务器之间传递数据，即使接收用户请求的这台机器没有该用户的交易信息。为了保证角色的松耦合，我们使用 Kafka 在服务器之间传递信息 (数据)。Kafka 特性Kafka 的几个特性非常满足我们的需求：可扩展性、数据分区、低延迟、处理大量不同消费者的能力。这个案例我们可以配置在 Kafka 中为登陆和交易配置同一个主题。由于 Kafka 支持在单一主题内的排序，而不是跨主题的排序，所以我们为了保证用户在交易前使用实际的 IP 地址登陆系统，我们采用了同一个主题来存储登陆信息和交易信息。当用户登陆或者发起交易动作后，负责接收的服务器立即发事件给 Kafka。这里我们采用用户 id 作为消息的主键，具体事件作为值。这保证了同一个用户的所有的交易信息和登陆信息被发送到 Kafka 分区。每一个事件处理服务被当作一个 Kafka 消费者来运行，所有的消费者被配置到了同一个消费者群组，这样每一台服务器从一些 Kafka 分区读取数据，一个分区的所有数据被送到同一个事件处理服务器 (可以与接收服务器不同)。当事件处理服务器从 Kafka 读取了用户交易信息，它可以把该信息加入到保存在本地内存中的历史信息列表里面，这样可以保证事件处理服务器在本地内存中调用用户的历史信息并做出预警，而不需要额外的网络或磁盘开销。图 1. 游戏设计图图 1. 游戏设计图为了多线程处理，我们为每一个事件处理服务器或者每一个核创建了一个分区。Kafka 已经在拥有 1 万个分区的集群里测试过。切换回 Kafka上面的例子听起来有点绕口：首先从游戏服务器发送信息到 Kafka，然后另一台游戏服务器的消费者从主题中读取该信息并处理它。然而，这样的设计解耦了两个角色并且允许我们管理每一个角色的各种功能。此外，这种方式不会增加负载到 Kafka。测试结果显示，即使 3 个结点组成的集群也可以处理每秒接近百万级的任务，平均每个任务从注册到消费耗时 3 毫秒。上面例子当发现一个事件可疑后，发送一个预警标志到一个新的 Kafka 主题，同样的有一个消费者服务会读取它，并将数据存入 Hadoop 集群用于进一步的数据分析。因为 Kafka 不会追踪消息的处理过程及消费者队列，所以它在消耗极小的前提下可以同时处理数千个消费者。Kafka 甚至可以处理批量级别的消费者，例如每小时唤醒一次一批睡眠的消费者来处理所有的信息。Kafka 让数据存入 Hadoop 集群变得非常简单。当拥有多个数据来源和多个数据目的地时，为每一个来源和目的地配对地编写一个单独的数据通道会导致混乱发生。Kafka 帮助 LinkedIn 规范了数据通道格式，并且允许每一个系统获取数据和写入数据各一次，这样极大地减少数据通道的复杂性和操作耗时。LinkedIn 的架构师 Jay Kreps 说：“我最初是在 2008 年完成键值对数据存储方式后开始的，我的项目是尝试运行 Hadoop，将我们的一些处理过程移动到 Hadoop 里面去。我们在这个领域几乎没有经验，花了几个星期尝试把数据导入、导出，另外一些事件花在了尝试各种各样的预测性算法使用上面，然后，我们开始了漫漫长路”。与 Flume 的区别Kafka 与 Flume 很多功能确实是重复的。以下是评估两个系统的一些建议：Kafka 是一个通用型系统。你可以有许多的生产者和消费者分享多个主题。相反地，Flume 被设计成特定用途的工作，特定地向 HDFS 和 HBase 发送出去。Flume 为了更好地为 HDFS 服务而做了特定的优化，并且与 Hadoop 的安全体系整合在了一起。基于这样的结论，Hadoop 开发商 Cloudera 推荐如果数据需要被多个应用程序消费的话，推荐使用 Kafka，如果数据只是面向 Hadoop 的，可以使用 Flume。Flume 拥有许多配置的来源 (sources) 和存储池 (sinks)。然后，Kafka 拥有的是非常小的生产者和消费者环境体系，Kafka 社区并不是非常支持这样。如果你的数据来源已经确定，不需要额外的编码，那你可以使用 Flume 提供的 sources 和 sinks，反之，如果你需要准备自己的生产者和消费者，那你需要使用 Kafka。Flume 可以在拦截器里面实时处理数据。这个特性对于过滤数据非常有用。Kafka 需要一个外部系统帮助处理数据。无论是 Kafka 或是 Flume，两个系统都可以保证不丢失数据。然后，Flume 不会复制事件。相应地，即使我们正在使用一个可以信赖的文件通道，如果 Flume agent 所在的这个节点宕机了，你会失去所有的事件访问能力直到你修复这个受损的节点。使用 Kafka 的管道特性不会有这样的问题。Flume 和 Kafka 可以一起工作的。如果你需要把流式数据从 Kafka 转移到 Hadoop，可以使用 Flume 代理 (agent)，将 kafka 当作一个来源 (source)，这样可以从 Kafka 读取数据到 Hadoop。你不需要去开发自己的消费者，你可以使用 Flume 与 Hadoop、HBase 相结合的特性，使用 Cloudera Manager 平台监控消费者，并且通过增加过滤器的方式处理数据。结束语综上所述，Kafka 的设计可以帮助我们解决很多架构上的问题。但是想要用好 Kafka 的高性能、低耦合、高可靠性、数据不丢失等特性，我们需要非常了解 Kafka，以及我们自身的应用系统使用场景，并不是任何环境 Kafka 都是最佳选择。

hiekay

2019-12-02 01:42:10

0 浏览量

回答数 0

回答

本教程介绍了如何利用弹性伸缩均衡分布ECS实例，并组合使用按量付费ECS实例和抢占式实例，以更低的成本部署高可用计算集群。

前提条件 使用本教程进行操作前，请确保您已经注册了阿里云账号。如还未注册，请先完成账号注册。 为应用的ECS实例创建了自定义镜像，具体操作请参见使用实例创建自定义镜像。 业务场景 某在线广告提供商应用机器学习精准投放广告，在业务高峰期会临时需要大量计算资源，成本较高，也可能存在ECS实例库存不足、手动创建ECS实例操作仓促、ECS实例临时停止服务等问题，存在一定的业务受损风险。

假设您的应用面向以下场景，也可以采用类似解决方案： 分布式大数据计算。 人工智能训练。 解决方案 弹性伸缩可以快速交付一个计算集群，同时利用均衡分布策略自动将计算节点分散在多个可用区，并实时检测ECS实例的运行状况，确保计算集群的高可用性。

您可以采用以下方案： 通过弹性伸缩将计算节点分散在多个可用区，同时指定多种实例规格。 组合使用按量实例和抢占式实例，以低成本购买ECS实例。伸缩组会按照单位vCPU的价格从低到高排序，优先选择单位vCPU价格更低的实例规格。 示意图如下： 业务收益 利用弹性伸缩部署高可用计算集群，您可以获得以下收益： 零运维成本 您只需提前配置扩缩容策略。负载增加时，伸缩组自动创建ECS实例，并将ECS实例添加到RDS实例的白名单；负载降低时，伸缩组自动将ECS实例从RDS实例的白名单中移除，然后释放ECS实例。整个过程自动触发和完成，无需人工干预。

超高性价比 弹性伸缩支持组合使用按量实例和抢占式实例，抢占式实例最低能以一折的价格购得ECS实例，性价比超高。如果抢占式实例库存不足，也会以按量实例的方式交付，保证交付结果。

天然高可用 均衡分布策略实现自动分散部署计算节点，避免因单可用区中库存不足等原因导致服务不可用，而且默认开启的健康检查功能可以确保伸缩组内ECS实例都处于可用状态。

操作步骤 请根据您的业务架构评估业务模块，为需要部署高可用集群的业务模块创建伸缩组，并为伸缩配置选择应用实例的自定义镜像，确保自动创建出的ECS实例符合应用的要求。

登录弹性伸缩控制台。 单击创建伸缩组。 配置伸缩组信息并完成伸缩组创建。 伸缩组内最小实例数设置为100。 组内实例配置信息来源设置为自定义伸缩配置。 选择多个可用区下的虚拟交换机。 多可用区扩容模式设置为均衡分布策略。 绑定当前业务模块所使用的RDS实例。 请根据需要配置其它信息，详细信息请参见创建伸缩组。

单击创建伸缩配置。 配置伸缩配置信息并完成伸缩配置创建。 计费方式设置为抢占式实例。 镜像设置为您的自定义镜像。 请根据需要配置其它信息，详细信息请参见创建伸缩配置。

确定启用伸缩配置。 确定启用伸缩组。 执行结果 启用伸缩组后，伸缩组自动在所选可用区中均衡部署满100台ECS实例，单可用区中因库存不足等原因引发问题时，对整个应用的影响有限。伸缩组在抢占式实例被回收后自动创建新的抢占式实例，并自动移除进入不健康状态的ECS实例并创建新的ECS实例。保证集群高可用性的同时，也降低了成本。

1934890530796658

2020-03-22 13:27:57

0 浏览量

回答数 0

问题

备战大厂每日挑战算法，坚持打卡更有社区定制周边奖品等你赢！

算法工程师，一个听起来非常高大上的职业~ 不但轻轻松松月入过万，更是进入大厂必考的题目。如何通过大厂算法岗面试？如何轻轻松松拿到高薪？如何成为算法技术大牛？

今天开发者...

被纵养的懒猫

2020-04-07 11:41:45

5309 浏览量

回答数 5

问题

一个函数秒杀 2Sum 3Sum 4Sum 问题 7月9日 【今日算法】

经常刷 LeetCode 的读者肯定知道鼎鼎有名的 twoSum 问题，我们的旧文Two Sum 问题的核心思想对 twoSum 的几个变种做了解析。

但是除了 twoSum 问题，LeetCode 上面还有 ...

游客ih62co2qqq5ww

2020-07-10 07:34:19

5 浏览量

回答数 1

问题

云服务器ECS安全组实践(二)

在

云服务器ECS安全组实践(一) 中我们简单介绍了安全组的一些规则和约束和实践，在创建一台云服务的时候，它作为几个必选参数之一，可见它的重要性。本文将继续安全组的介绍，...

正禾

2019-12-01 21:21:00

2436 浏览量

回答数 0

回答

Redis常见的几种主要使用方式：

Redis 单副本 Redis 多副本(主从) Redis Sentinel(哨兵) Redis Cluster(集群) Redis 自研

Redis各种使用方式的优缺点：

1 Redis单副本

Redis各种使用方式的优缺点：

Redis 多副本，采用主从(replication)部署结构，相较于单副本而言最大的特点就是主从实例间数据实时同步，并且提供数据持久化和备份策略。主从实例部署在不同的物理服务器上，根据公司的基础环境配置，可以实现同时对外提供服务和读写分离策略。

优点：

1、高可靠性，一方面，采用双机主备架构，能够在主库出现故障时自动进行主备切换，从库提升为主库提供服务，保证服务平稳运行。另一方面，开启数据持久化功能和配置合理的备份策略，能有效的解决数据误操作和数据异常丢失的问题。 2、读写分离策略，从节点可以扩展主库节点的读能力，有效应对大并发量的读操作。

缺点：

1、故障恢复复杂，如果没有RedisHA系统(需要开发)，当主库节点出现故障时，需要手动将一个从节点晋升为主节点，同时需要通知业务方变更配置，并且需要让其他从库节点去复制新主库节点，整个过程需要人为干预，比较繁琐。

2、主库的写能力受到单机的限制，可以考虑分片

3、主库的存储能力受到单机的限制，可以考虑Pika

4、原生复制的弊端在早期的版本也会比较突出，如：Redis复制中断后，Slave会发起psync，此时如果同步不成功，则会进行全量同步，主库执行全量备份的同时可能会造成毫秒或秒级的卡顿；又由于COW机制，导致极端情况下的主库内存溢出，程序异常退出或宕机；主库节点生成备份文件导致服务器磁盘IO和CPU(压缩)资源消耗；发送数GB大小的备份文件导致服务器出口带宽暴增，阻塞请求。建议升级到最新版本。

使用场景

对 Redis 协议兼容性要求较高的业务

标准版完全兼容 Redis 协议，业务可以平滑迁移。

Redis 作为持久化数据存储使用的业务

标准版提供持久化机制及备份恢复机制，极大地保证数据可靠性。

单个 Redis 性能压力可控

由于 Redis 原生采用单线程机制，性能在10万 QPS 以下的业务建议使用。如果需要更高的性能要求，请选用集群版本。

Redis 命令相对简单，排序、计算类命令较少

由于 Redis 的单线程机制，CPU 会成为主要瓶颈。如排序、计算类较多的业务建议选用集群版配置。

2 Redis多副本(主从)

Redis 多副本，采用主从(replication)部署结构，相较于单副本而言最大的特点就是主从实例间数据实时同步，并且提供数据持久化和备份策略。主从实例部署在不同的物理服务器上，根据公司的基础环境配置，可以实现同时对外提供服务和读写分离策略。

优点：

1、高可靠性，一方面，采用双机主备架构，能够在主库出现故障时自动进行主备切换，从库提升为主库提供服务，保证服务平稳运行。另一方面，开启数据持久化功能和配置合理的备份策略，能有效的解决数据误操作和数据异常丢失的问题。

2、读写分离策略，从节点可以扩展主库节点的读能力，有效应对大并发量的读操作。

缺点：

1、故障恢复复杂，如果没有RedisHA系统(需要开发)，当主库节点出现故障时，需要手动将一个从节点晋升为主节点，同时需要通知业务方变更配置，并且需要让其他从库节点去复制新主库节点，整个过程需要人为干预，比较繁琐。

2、主库的写能力受到单机的限制，可以考虑分片

3、主库的存储能力受到单机的限制，可以考虑Pika

4、原生复制的弊端在早期的版本也会比较突出，如：Redis复制中断后，Slave会发起psync，此时如果同步不成功，则会进行全量同步，主库执行全量备份的同时可能会造成毫秒或秒级的卡顿；又由于COW机制，导致极端情况下的主库内存溢出，程序异常退出或宕机；主库节点生成备份文件导致服务器磁盘IO和CPU(压缩)资源消耗；发送数GB大小的备份文件导致服务器出口带宽暴增，阻塞请求。建议升级到最新版本。

使用场景

对 Redis 协议兼容性要求较高的业务

标准版完全兼容 Redis 协议，业务可以平滑迁移。

Redis 作为持久化数据存储使用的业务

标准版提供持久化机制及备份恢复机制，极大地保证数据可靠性。

单个 Redis 性能压力可控

由于 Redis 原生采用单线程机制，性能在10万 QPS 以下的业务建议使用。如果需要更高的性能要求，请选用集群版本。

Redis 命令相对简单，排序、计算类命令较少

由于 Redis 的单线程机制，CPU 会成为主要瓶颈。如排序、计算类较多的业务建议选用集群版配置。

3 Redis Sentinel(哨兵)

Redis Sentinel是社区版本推出的原生高可用解决方案，Redis Sentinel部署架构主要包括两部分：Redis Sentinel集群和Redis数据集群，其中Redis Sentinel集群是由若干Sentinel节点组成的分布式集群。可以实现故障发现、故障自动转移、配置中心和客户端通知。Redis Sentinel的节点数量要满足2n+1(n>=1)的奇数个。

优点：

1、Redis Sentinel集群部署简单

2、能够解决Redis主从模式下的高可用切换问题

3、很方便实现Redis数据节点的线形扩展，轻松突破Redis自身单线程瓶颈，可极大满足对Redis大容量或高性能的业务需求。

4、可以实现一套Sentinel监控一组Redis数据节点或多组数据节点

缺点：

1、部署相对Redis 主从模式要复杂一些，原理理解更繁琐

2、资源浪费，Redis数据节点中slave节点作为备份节点不提供服务

3、Redis Sentinel主要是针对Redis数据节点中的主节点的高可用切换，对Redis的数据节点做失败判定分为主观下线和客观下线两种，对于Redis的从节点有对节点做主观下线操作，并不执行故障转移。

4、不能解决读写分离问题，实现起来相对复杂

建议：

1、如果监控同一业务，可以选择一套Sentinel集群监控多组Redis数据节点的方案，反之选择一套Sentinel监控一组Redis数据节点的方案

2、sentinel monitor

配置中的

建议设置成Sentinel节点的一半加1，当Sentinel部署在多个IDC的时候，单个IDC部署的Sentinel数量不建议超过(Sentinel数量 – quorum)。

3、合理设置参数，防止误切，控制切换灵敏度控制

quorum

down-after-milliseconds 30000

failover-timeout 180000

maxclient

timeout

4、部署的各个节点服务器时间尽量要同步，否则日志的时序性会混乱

5、Redis建议使用pipeline和multi-keys操作，减少RTT次数，提高请求效率

6、自行搞定配置中心(zookeeper)，方便客户端对实例的链接访问

4 Redis Cluster(集群)

Redis Cluster是社区版推出的Redis分布式集群解决方案，主要解决Redis分布式方面的需求，比如，当遇到单机内存，并发和流量等瓶颈的时候，Redis Cluster能起到很好的负载均衡的目的。Redis Cluster集群节点最小配置6个节点以上(3主3从)，其中主节点提供读写操作，从节点作为备用节点，不提供请求，只作为故障转移使用。Redis Cluster采用虚拟槽分区，所有的键根据哈希函数映射到0～16383个整数槽内，每个节点负责维护一部分槽以及槽所印映射的键值数据。

优点：

1、无中心架构

2、数据按照slot存储分布在多个节点，节点间数据共享，可动态调整数据分布。

3、可扩展性，可线性扩展到1000多个节点，节点可动态添加或删除。

4、高可用性，部分节点不可用时，集群仍可用。通过增加Slave做standby数据副本，能够实现故障自动failover，节点之间通过gossip协议交换状态信息，用投票机制完成Slave到Master的角色提升。

5、降低运维成本，提高系统的扩展性和可用性。

缺点：

1、Client实现复杂，驱动要求实现Smart Client，缓存slots mapping信息并及时更新，提高了开发难度，客户端的不成熟影响业务的稳定性。目前仅JedisCluster相对成熟，异常处理部分还不完善，比如常见的“max redirect exception”。

2、节点会因为某些原因发生阻塞(阻塞时间大于clutser-node-timeout)，被判断下线，这种failover是没有必要的。

3、数据通过异步复制,不保证数据的强一致性。

4、多个业务使用同一套集群时，无法根据统计区分冷热数据，资源隔离性较差，容易出现相互影响的情况。

5、Slave在集群中充当“冷备”，不能缓解读压力，当然可以通过SDK的合理设计来提高Slave资源的利用率。

6、key批量操作限制，如使用mset、mget目前只支持具有相同slot值的key执行批量操作。对于映射为不同slot值的key由于keys 不支持跨slot查询，所以执行mset、mget、sunion等操作支持不友好。

7、key事务操作支持有限，只支持多key在同一节点上的事务操作，当多个key分布于不同的节点上时无法使用事务功能。

8、key作为数据分区的最小粒度，因此不能将一个很大的键值对象如hash、list等映射到不同的节点。

9、不支持多数据库空间，单机下的redis可以支持到16个数据库，集群模式下只能使用1个数据库空间，即db 0。

10、复制结构只支持一层，从节点只能复制主节点，不支持嵌套树状复制结构。

11、避免产生hot-key，导致主库节点成为系统的短板。

12、避免产生big-key，导致网卡撑爆、慢查询等。

13、重试时间应该大于cluster-node-time时间

14、Redis Cluster不建议使用pipeline和multi-keys操作，减少max redirect产生的场景。

使用场景

数据量较大

Redis 集群版可以有效的扩展数据规模，相比标准版支持存储量更大的64、128、256 GB 集群版，可以有效的满足数据扩展需求。

QPS 压力较大

标准版 Redis 无法支撑较大的 QPS，需要采用多节点的部署方式来冲破 Redis 单线程的性能瓶颈。

吞吐密集型应用

相比标准版，Redis 集群版的内网吞吐限制相对较低，针对热点数据读取、大吞吐类型的业务可以友好的支持。

对 Redis 协议不敏感的应用

由于集群版的架构引入了多个组件，在 Redis 协议支持上相比标准版有一定限制。

剑曼红尘

2020-04-27 14:41:57

0 浏览量

回答数 0

回答

PHP面试干货

1、进程和线程

进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：

简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

线程的划分尺度小于进程，使得多线程程序的并发性高。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

2、apache默认使用进程管理还是线程管理？如何判断并设置最大连接数？

一个进程可以开多个线程 默认是进程管理 默认有一个主进程

Linux: ps -aux | grep httpd | more 一个子进程代表一个用户的连接

Conf/extra/httpd-mpm.conf 多路功能模块 http -l 查询当前apache处于什么模式下

3、单例模式

单例模式需求:只能实例化产生一个对象

如何实现:

私有化构造函数

禁止克隆对象

提供一个访问这个实例的公共的静态方法(通常为getInstance方法)，从而返回唯一对象

需要一个保存类的静态属性

class demo {

private static $MyObject; //保存对象的静态属性

private function __construct(){ //私有化构造函数

}

private function __clone(){ //禁止克隆

}

public static function getInstance(){

if(! (self::$MyObject instanceof self)){

self::$MyObject = new self;

}

return self::$MyObject;

}

}

4、安装完Apache后，在http.conf中配置加载PHP文件以Apache模块的方式安装PHP，在文件http.conf中首先要用语句LoadModule php5_module "e:/php/php5apache2.dll"动态装载PHP模块，然后再用语句AddType application/x-httpd-php .php 使得Apache把所有扩展名为PHP的文件都作为PHP脚本处理

5、debug_backtrace()函数能返回脚本里的任意行中调用的函数的名称。该函数同时还经常被用在调试中，用来判断错误是如何发生的

function one($str1, $str2)

{

two("Glenn", "Quagmire");

}

function two($str1, $str2)

{

three("Cleveland", "Brown");

}

function three($str1, $str2)

{

print_r(debug_backtrace());

}

one("Peter", "Griffin");

Array

(

[0] => Array

(

[file] => D:\www\test\result.php

[line] => 9

[function] => three

[args] => Array

(

[0] => Cleveland

[1] => Brown

)

)

[1] => Array

(

[file] => D:\www\test\result.php

[line] => 5

[function] => two

[args] => Array

(

[0] => Glenn

[1] => Quagmire

)

)

[2] => Array

(

[file] => D:\www\test\result.php

[line] => 16

[function] => one

[args] => Array

(

[0] => Peter

[1] => Griffin

)

)

)

6、输出用户的IP地址，并且判断用户的IP地址是否在192.168.1.100 — 192.168.1.150之间

echo $ip=getenv('REMOTE_ADDR');

$ip=str_replace('.','',$ip);

if($ip<1921681150 && $ip>1921681100)

{

echo 'ip在192.168.1.100—–192.168.1.150之间';

}

else

{

echo 'ip不在192.168.1.100—–192.168.1.150之间';

}

7、请将2维数组按照name的长度进行重新排序，按照顺序将id赋值

$tarray = array(

array('id' => 0, 'name' => '123'),

array('id' => 0, 'name' => '1234'),

array('id' => 0, 'name' => '1235'),

array('id' => 0, 'name' => '12356'),

array('id' => 0, 'name' => '123abc')

);

foreach($tarray as $key=>$val)

{

$c[]=$val['name'];

}

function aa($a,$b)

{

if(strlen($a)==strlen($b)) return 0;

return strlen($a)>strlen($b)?-1:1;

}

usort($c,'aa');

$len=count($c);

for($i=0;$i

{

$t[$i]['id']=$i+1;

$t[$i]['name']=$c[$i];

}

print_r($t);

8、表单数据提交方式POST和GET的区别，URL地址传递的数据最大长度是多少？

POST方式提交数据用户不可见，是数据更安全，最大长度不受限制，而GET方式传值在URL地址可以看到，相对不安全，对大长度是2048字节。

9、SESSION和COOKIE的作用和区别，SESSION信息的存储方式，如何进行遍历

SESSION和COOKIE都能够使值在页面之间进行传递，SESSION存储在服务器端，数据更安全，COOKIE保存在客户端，用户使用手段可以进行修改，SESSION依赖于COOKIE进行传递的。Session遍历使用$_SESSION[]取值，cookie遍历使用$_COOKIE[]取值。

10、什么是数据库索引，主键索引，唯一索引的区别，索引的缺点是什么

索引用来快速地寻找那些具有特定值的记录。

主键索引和唯一索引的区别：主键是一种唯一性索引，但它必须指定为“PRIMARY KEY”,每个表只能有一个主键。唯一索引索引列的所有值都只能出现一次，即必须唯一。

索引的缺点：

1、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。

2、索引需要占用物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，需要的空间就会更大。

3、当对表中的数据进行增加、删除、修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

11、数据库设计时，常遇到的性能瓶颈有哪些，常有的解决方案

瓶颈主要有：

1、磁盘搜索 优化方法是：将数据分布在多个磁盘上

2、磁盘读/写 优化方法是：从多个磁盘并行读写。

3、CPU周期 优化方法：扩充内存

4、内存带宽

12、include和require区别

include引入文件的时候，如果碰到错误，会给出提示，并继续运行下边的代码。

require引入文件的时候，如果碰到错误，会给出提示，并停止运行下边的代码。

13、文件上传时设计到点

和文件上传有关的php.ini配置选项(File Uploads)：

file_uploads=On/Off:文件是否允许上传

upload_max_filesize上传文件时，单个文件的最大大小

post_max_size:提交表单时，整个post表单的最大大小

max_file_uploads =20上传文件的个数

内存占用，脚本最大执行时间也间接影响到文件的上传

14、header常见状态

//200 正常状态

header('HTTP/1.1 200 OK');

// 301 永久重定向，记得在后面要加重定向地址 Location:$url

header('HTTP/1.1 301 Moved Permanently');

// 重定向，其实就是302 暂时重定向

header('Location: http://www.maiyoule.com/');

// 设置页面304 没有修改

header('HTTP/1.1 304 Not Modified');

// 显示登录框，

header('HTTP/1.1 401 Unauthorized');

header('WWW-Authenticate: Basic realm="登录信息"');

echo '显示的信息！';

// 403 禁止访问

header('HTTP/1.1 403 Forbidden');

// 404 错误

header('HTTP/1.1 404 Not Found');

// 500 服务器错误

header('HTTP/1.1 500 Internal Server Error');

// 3秒后重定向指定地址(也就是刷新到新页面与

header('Content-Transfer-Encoding: binary');

readfile('example.zip');//读取文件到客户端

//禁用页面缓存

header('Cache-Control: no-cache, no-store, max-age=0, must-revalidate');

header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');

header('Pragma: no-cache');

//设置页面头信息

header('Content-Type: text/html; charset=iso-8859-1');

header('Content-Type: text/html; charset=utf-8');

header('Content-Type: text/plain');

header('Content-Type: image/jpeg');

header('Content-Type: application/zip');

header('Content-Type: application/pdf');

header('Content-Type: audio/mpeg');

header('Content-Type: application/x-shockwave-flash');

//.... 至于Content-Type 的值 可以去查查 w3c 的文档库，那里很丰富

15、ORM和ActiveRecord

ORM:object relation mapping,即对象关系映射，简单的说就是对象模型和关系模型的一种映射。为什么要有这么一个映射？很简单，因为现在的开发语言基本都是oop的，但是传统的数据库却是关系型的。为了可以靠贴近面向对象开发，我们想要像操作对象一样操作数据库。还可以隔离底层数据库层，我们不需要关心我们使用的是mysql还是其他的关系型数据库

ActiveRecord也属于ORM层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。

ActiveRecord的主要思想是：

1. 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段在类中都有相应的Field；

2. ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD;；

3. ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；

ActiveRecord比较适用于：

1. 业务逻辑比较简单，当你的类基本上和数据库中的表一一对应时, ActiveRecord是非常方便的，即你的业务逻辑大多数是对单表操作；

2. 当发生跨表的操作时, 往往会配合使用事务脚本(Transaction Script)，把跨表事务提升到事务脚本中；

3. ActiveRecord最大优点是简单, 直观。 一个类就包括了数据访问和业务逻辑. 如果配合代码生成器使用就更方便了；

这些优点使ActiveRecord特别适合WEB快速开发。

16、斐波那契方法，也就是1 1 2 3 5 8 ……，这里给出两种方法，大家可以对比下，看看哪种快，以及为什么

function fibonacci($n){

if($n == 0){

return 0;

}

if($n == 1){

return 1;

}

return fibonacci($n-1)+fibonacci($n-2);

}

function fibonacci($n){

for($i=0; $i

$r[] = $i<2 ? 1 : $r[$i-1]+$r[$i-2];

}

return $r[--$i];

}

17、约瑟夫环，也就是常见的数猴子，n只猴子围成一圈，每只猴子下面标了编号，从1开始数起，数到m那么第m只猴子便退出，依次类推，每数到m，那么那个位置的猴子退出，那么最后剩下的猴子下的编号是啥。

function yuesefu($n,$m) {

$r=0;

for($i=2; $i<=$n; $i++) {

$r=($r+$m)%$i;

}

return $r+1;

}

18、冒泡排序，大致是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

function bubbleSort($arr){

for($i=0, $len=count($arr); $i

for($j=0; $j

if($arr[$i]

$tmp = $arr[$j];

$arr[$j] = $arr[$i];

$arr[$i] = $tmp;

}

}

}

return $arr;

}

19、快速排序，也就是找出一个元素(理论上可以随便找一个)作为基准,然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

function quickSort($arr){

$len = count($arr);

if($len <=1){

return $arr;

}

$key = $arr[0];

$leftArr = $rightArr= array();

for($i=1; $i

if($arr[$i] <= $key){

$leftArr[] = $arr[$i];

} else{

$rightArr[] = $arr[$i];

}

}

$leftArr = quickSort($leftArr);

$rightArr = quickSort($rightArr);

return array_merge($leftArr, array($key), $rightArr);

}

20、(递归的)列出目录下所有文件及目录，这里也有两种方法

function listDir($path){

$res = dir($path);

while($file = $res->read()){

if($file == '.' || $file == '..'){

continue;

}

if(is_dir($path . '/' .$file)){

echo $path . '/' .$file . "\r\n";

listDir($path . '/' .$file);

} else{

echo $path . '/' .$file . "\r\n";

}

}

$res->close();

}

function listDir($path){

if(is_dir($path)){

if(FALSE !== ($res = opendir($path))){

while(FALSE !== ($file = readdir($res))){

if($file == '.' || $file == '..'){

continue;

}

$subPath = $path . '/' . $file;

if(is_dir($subPath)){

echo $subPath . "\r\n";

listDir($subPath);

} else{

echo $subPath . "\r\n";

}

}

}

}

}

21、找出相对的目录，比如/a/b/c/d/e.php相对于/a/b/13/34/c.php是/c/d/

function ralativePath($a, $b){

$a = explode('/', dirname($a));

$b = explode('/', dirname($b));

$c = '/';

foreach ($a as $k=> $v){

if($v != $b[$k]){

$c .= $v . '/';

}

}

echo $c;

}

22、快速找出url中php后缀

function get_ext($url){

$data = parse_url($url);

return pathinfo($data['path'], PATHINFO_EXTENSION);

}

23、正则题，使用正则抓取网页，以网页meta为utf8为准，若是抓取的网页编码为big5之类的，需要转化为utf8再收录

function preg_meta($meta){

$replacement = "\\1utf8\\6\\7";

$pattern = '#()#i';

return preg_replace($pattern, $replacement, $meta);

}

echo preg_meta("");

24、不用php的反转函数倒序输出字符串，如abc，反序输出cba

function revstring($str){

for($i=strlen($str)-1; $i>=0; $i--){

echo $str{$i};

}

}

revstring('abc');

25、常见端口

TCP 21端口：FTP 文件传输服务

SSH 22端口：SSH连接linux服务器，通过SSH连接可以远程管理Linux等设备

TCP 23端口：TELNET 终端仿真服务

TCP 25端口：SMTP 简单邮件传输服务

UDP 53端口：DNS 域名解析服务

TCP 80端口：HTTP 超文本传输服务

TCP 110端口：POP3 “邮局协议版本3”使用的端口

TCP 443端口：HTTPS 加密的超文本传输服务

TCP 1521端口：Oracle数据库服务

TCP 1863端口：MSN Messenger的文件传输功能所使用的端口

TCP 3389端口：Microsoft RDP 微软远程桌面使用的端口

TCP 5631端口：Symantec pcAnywhere 远程控制数据传输时使用的端口

UDP 5632端口：Symantec pcAnywhere 主控端扫描被控端时使用的端口

TCP 5000端口：MS SQL Server使用的端口

UDP 8000端口：腾讯QQ

26、linux常用的命令

top linux进程实时监控

ps 在Linux中是查看进程的命令。ps查看正处于Running的进程

mv 为文件或目录改名或将文件由一个目录移入另一个目录中。

find 查找文件

df 可显示所有文件系统对i节点和磁盘块的使用情况。

cat 打印文件类容

chmod 变更文件或目录的权限

chgrp 文件或目录的权限的掌控以拥有者及所诉群组来管理。可以使用chgrp指令取变更文件与目录所属群组

grep 是一种强大的文本搜索工具,它能使用正则表达式搜索文本,并把匹 配的行打印出来。

wc 为统计指定文件中的字节数、字数、行数,并将统计结果显示输出

27、对于大流量的网站,您采用什么样的方法来解决访问量问题

首先，确认服务器硬件是否足够支持当前的流量

其次，优化数据库访问。

第三，禁止外部的盗链。

第四，控制大文件的下载。

第五，使用不同主机分流主要流量

第六，使用流量分析统计软件

28、$_SERVER常用的字段

$_SERVER['PHP_SELF'] #当前正在执行脚本的文件名

$_SERVER['SERVER_NAME'] #当前运行脚本所在服务器主机的名称

$_SERVER['REQUEST_METHOD'] #访问页面时的请求方法。例如：“GET”、“HEAD”，“POST”，“PUT”

$_SERVER['QUERY_STRING'] #查询(query)的字符串

$_SERVER['HTTP_HOST'] #当前请求的 Host: 头部的内容

$_SERVER['HTTP_REFERER'] #链接到当前页面的前一页面的 URL 地址

$_SERVER['REMOTE_ADDR'] #正在浏览当前页面用户的 IP 地址

$_SERVER['REMOTE_HOST'] #正在浏览当前页面用户的主机名

$_SERVER['SCRIPT_FILENAME'] #当前执行脚本的绝对路径名

$_SERVER['SCRIPT_NAME'] #包含当前脚本的路径。这在页面需要指向自己时非常有用

$_SERVER['REQUEST_URI'] #访问此页面所需的 URI。例如，“/index.html”

29、安装php扩展

进入扩展的目录

phpize命令得到configure文件

./configure --with-php-config=/usr/local/php/bin/php-config

make & make install

在php.ini中加入扩展名称.so

重启web服务器(nginx/apache)

30、php-fpm与nginx

PHP-FPM也是一个第三方的FastCGI进程管理器，它是作为PHP的一个补丁来开发的，在安装的时候也需要和PHP源码一起编译，也就是说PHP-FPM被编译到PHP内核中，因此在处理性能方面更加优秀；同时它在处理高并发方面也比spawn-fcgi引擎好很多，因此，推荐Nginx+PHP/PHP-FPM这个组合对PHP进行解析。

FastCGI 的主要优点是把动态语言和HTTP Server分离开来，所以Nginx与PHP/PHP-FPM经常被部署在不同的服务器上，以分担前端Nginx服务器的压力，使Nginx专一处理静态请求和转发动态请求，而PHP/PHP-FPM服务器专一解析PHP动态请求

#fastcgi

FastCGI是一个可伸缩地、高速地在HTTP server和动态脚本语言间通信的接口。多数流行的HTTP server都支持FastCGI，包括Apache、Nginx和lighttpd等，同时，FastCGI也被许多脚本语言所支持，其中就有PHP。

FastCGI是从CGI发展改进而来的。传统CGI接口方式的主要缺点是性能很差，因为每次HTTP服务器遇到动态程序时都需要重新启动脚本解析器来执行解析，然后结果被返回给HTTP服务器。这在处理高并发访问时，几乎是不可用的。另外传统的CGI接口方式安全性也很差，现在已经很少被使用了。

FastCGI接口方式采用C/S结构，可以将HTTP服务器和脚本解析服务器分开，同时在脚本解析服务器上启动一个或者多个脚本解析守护进程。当HTTP服务器每次遇到动态程序时，可以将其直接交付给FastCGI进程来执行，然后将得到的结果返回给浏览器。这种方式可以让HTTP服务器专一地处理静态请求或者将动态脚本服务器的结果返回给客户端，这在很大程度上提高了整个应用系统的性能。

Nginx+FastCGI运行原理

Nginx不支持对外部程序的直接调用或者解析，所有的外部程序(包括PHP)必须通过FastCGI接口来调用。FastCGI接口在Linux下是socket，(这个socket可以是文件socket，也可以是ip socket)。为了调用CGI程序，还需要一个FastCGI的wrapper(wrapper可以理解为用于启动另一个程序的程序)，这个wrapper绑定在某个固定socket上，如端口或者文件socket。当Nginx将CGI请求发送给这个socket的时候，通过FastCGI接口，wrapper接纳到请求，然后派生出一个新的线程，这个线程调用解释器或者外部程序处理脚本并读取返回数据；接着，wrapper再将返回的数据通过FastCGI接口，沿着固定的socket传递给Nginx；最后，Nginx将返回的数据发送给客户端，这就是Nginx+FastCGI的整个运作过程。

31、ajax全称“Asynchronous Javascript And XML”(异步JavaScript和XML)

小川游鱼

2019-12-02 01:41:29

0 浏览量

回答数 0

回答

PHP面试干货

1、进程和线程

进程和线程都是由操作系统所体会的程序运行的基本单元，系统利用该基本单元实现系统对应用的并发性。进程和线程的区别在于：

简而言之,一个程序至少有一个进程,一个进程至少有一个线程.

线程的划分尺度小于进程，使得多线程程序的并发性高。

另外，进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而极大地提高了程序的运行效率。

线程在执行过程中与进程还是有区别的。每个独立的线程有一个程序运行的入口、顺序执行序列和程序的出口。但是线程不能够独立执行，必须依存在应用程序中，由应用程序提供多个线程执行控制。

从逻辑角度来看，多线程的意义在于一个应用程序中，有多个执行部分可以同时执行。但操作系统并没有将多个线程看做多个独立的应用，来实现进程的调度和管理以及资源分配。这就是进程和线程的重要区别。

2、apache默认使用进程管理还是线程管理？如何判断并设置最大连接数？

一个进程可以开多个线程 默认是进程管理 默认有一个主进程

Linux: ps -aux | grep httpd | more 一个子进程代表一个用户的连接

Conf/extra/httpd-mpm.conf 多路功能模块 http -l 查询当前apache处于什么模式下

3、单例模式

单例模式需求:只能实例化产生一个对象

如何实现:

私有化构造函数

禁止克隆对象

提供一个访问这个实例的公共的静态方法(通常为getInstance方法)，从而返回唯一对象

需要一个保存类的静态属性

class demo {

private static $MyObject; //保存对象的静态属性

private function __construct(){ //私有化构造函数

}

private function __clone(){ //禁止克隆

}

public static function getInstance(){

if(! (self::$MyObject instanceof self)){

self::$MyObject = new self;

}

return self::$MyObject;

}

}

4、安装完Apache后，在http.conf中配置加载PHP文件以Apache模块的方式安装PHP，在文件http.conf中首先要用语句LoadModule php5_module "e:/php/php5apache2.dll"动态装载PHP模块，然后再用语句AddType application/x-httpd-php .php 使得Apache把所有扩展名为PHP的文件都作为PHP脚本处理

5、debug_backtrace()函数能返回脚本里的任意行中调用的函数的名称。该函数同时还经常被用在调试中，用来判断错误是如何发生的

function one($str1, $str2)

{

two("Glenn", "Quagmire");

}

function two($str1, $str2)

{

three("Cleveland", "Brown");

}

function three($str1, $str2)

{

print_r(debug_backtrace());

}

one("Peter", "Griffin");

Array

(

[0] => Array

(

[file] => D:\www\test\result.php

[line] => 9

[function] => three

[args] => Array

(

[0] => Cleveland

[1] => Brown

)

)

[1] => Array

(

[file] => D:\www\test\result.php

[line] => 5

[function] => two

[args] => Array

(

[0] => Glenn

[1] => Quagmire

)

)

[2] => Array

(

[file] => D:\www\test\result.php

[line] => 16

[function] => one

[args] => Array

(

[0] => Peter

[1] => Griffin

)

)

)

6、输出用户的IP地址，并且判断用户的IP地址是否在192.168.1.100 — 192.168.1.150之间

echo $ip=getenv('REMOTE_ADDR');

$ip=str_replace('.','',$ip);

if($ip<1921681150 && $ip>1921681100)

{

echo 'ip在192.168.1.100—–192.168.1.150之间';

}

else

{

echo 'ip不在192.168.1.100—–192.168.1.150之间';

}

7、请将2维数组按照name的长度进行重新排序，按照顺序将id赋值

$tarray = array(

array('id' => 0, 'name' => '123'),

array('id' => 0, 'name' => '1234'),

array('id' => 0, 'name' => '1235'),

array('id' => 0, 'name' => '12356'),

array('id' => 0, 'name' => '123abc')

);

foreach($tarray as $key=>$val)

{

$c[]=$val['name'];

}

function aa($a,$b)

{

if(strlen($a)==strlen($b)) return 0;

return strlen($a)>strlen($b)?-1:1;

}

usort($c,'aa');

$len=count($c);

for($i=0;$i

{

$t[$i]['id']=$i+1;

$t[$i]['name']=$c[$i];

}

print_r($t);

8、表单数据提交方式POST和GET的区别，URL地址传递的数据最大长度是多少？

POST方式提交数据用户不可见，是数据更安全，最大长度不受限制，而GET方式传值在URL地址可以看到，相对不安全，对大长度是2048字节。

9、SESSION和COOKIE的作用和区别，SESSION信息的存储方式，如何进行遍历

SESSION和COOKIE都能够使值在页面之间进行传递，SESSION存储在服务器端，数据更安全，COOKIE保存在客户端，用户使用手段可以进行修改，SESSION依赖于COOKIE进行传递的。Session遍历使用$_SESSION[]取值，cookie遍历使用$_COOKIE[]取值。

10、什么是数据库索引，主键索引，唯一索引的区别，索引的缺点是什么

索引用来快速地寻找那些具有特定值的记录。

主键索引和唯一索引的区别：主键是一种唯一性索引，但它必须指定为“PRIMARY KEY”,每个表只能有一个主键。唯一索引索引列的所有值都只能出现一次，即必须唯一。

索引的缺点：

1、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。

2、索引需要占用物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，需要的空间就会更大。

3、当对表中的数据进行增加、删除、修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

11、数据库设计时，常遇到的性能瓶颈有哪些，常有的解决方案

瓶颈主要有：

1、磁盘搜索 优化方法是：将数据分布在多个磁盘上

2、磁盘读/写 优化方法是：从多个磁盘并行读写。

3、CPU周期 优化方法：扩充内存

4、内存带宽

12、include和require区别

include引入文件的时候，如果碰到错误，会给出提示，并继续运行下边的代码。

require引入文件的时候，如果碰到错误，会给出提示，并停止运行下边的代码。

13、文件上传时设计到点

和文件上传有关的php.ini配置选项(File Uploads)：

file_uploads=On/Off:文件是否允许上传

upload_max_filesize上传文件时，单个文件的最大大小

post_max_size:提交表单时，整个post表单的最大大小

max_file_uploads =20上传文件的个数

内存占用，脚本最大执行时间也间接影响到文件的上传

14、header常见状态

//200 正常状态

header('HTTP/1.1 200 OK');

// 301 永久重定向，记得在后面要加重定向地址 Location:$url

header('HTTP/1.1 301 Moved Permanently');

// 重定向，其实就是302 暂时重定向

header('Location: http://www.maiyoule.com/');

// 设置页面304 没有修改

header('HTTP/1.1 304 Not Modified');

// 显示登录框，

header('HTTP/1.1 401 Unauthorized');

header('WWW-Authenticate: Basic realm="登录信息"');

echo '显示的信息！';

// 403 禁止访问

header('HTTP/1.1 403 Forbidden');

// 404 错误

header('HTTP/1.1 404 Not Found');

// 500 服务器错误

header('HTTP/1.1 500 Internal Server Error');

// 3秒后重定向指定地址(也就是刷新到新页面与

header('Content-Transfer-Encoding: binary');

readfile('example.zip');//读取文件到客户端

//禁用页面缓存

header('Cache-Control: no-cache, no-store, max-age=0, must-revalidate');

header('Expires: Mon, 26 Jul 1997 05:00:00 GMT');

header('Pragma: no-cache');

//设置页面头信息

header('Content-Type: text/html; charset=iso-8859-1');

header('Content-Type: text/html; charset=utf-8');

header('Content-Type: text/plain');

header('Content-Type: image/jpeg');

header('Content-Type: application/zip');

header('Content-Type: application/pdf');

header('Content-Type: audio/mpeg');

header('Content-Type: application/x-shockwave-flash');

//.... 至于Content-Type 的值 可以去查查 w3c 的文档库，那里很丰富

15、ORM和ActiveRecord

ORM:object relation mapping,即对象关系映射，简单的说就是对象模型和关系模型的一种映射。为什么要有这么一个映射？很简单，因为现在的开发语言基本都是oop的，但是传统的数据库却是关系型的。为了可以靠贴近面向对象开发，我们想要像操作对象一样操作数据库。还可以隔离底层数据库层，我们不需要关心我们使用的是mysql还是其他的关系型数据库

ActiveRecord也属于ORM层，由Rails最早提出，遵循标准的ORM模型：表映射到记录，记录映射到对象，字段映射到对象属性。配合遵循的命名和配置惯例，能够很大程度的快速实现模型的操作，而且简洁易懂。

ActiveRecord的主要思想是：

1. 每一个数据库表对应创建一个类，类的每一个对象实例对应于数据库中表的一行记录；通常表的每个字段在类中都有相应的Field；

2. ActiveRecord同时负责把自己持久化，在ActiveRecord中封装了对数据库的访问，即CURD;；

3. ActiveRecord是一种领域模型(Domain Model)，封装了部分业务逻辑；

ActiveRecord比较适用于：

1. 业务逻辑比较简单，当你的类基本上和数据库中的表一一对应时, ActiveRecord是非常方便的，即你的业务逻辑大多数是对单表操作；

2. 当发生跨表的操作时, 往往会配合使用事务脚本(Transaction Script)，把跨表事务提升到事务脚本中；

3. ActiveRecord最大优点是简单, 直观。 一个类就包括了数据访问和业务逻辑. 如果配合代码生成器使用就更方便了；

这些优点使ActiveRecord特别适合WEB快速开发。

16、斐波那契方法，也就是1 1 2 3 5 8 ……，这里给出两种方法，大家可以对比下，看看哪种快，以及为什么

function fibonacci($n){

if($n == 0){

return 0;

}

if($n == 1){

return 1;

}

return fibonacci($n-1)+fibonacci($n-2);

}

function fibonacci($n){

for($i=0; $i

$r[] = $i<2 ? 1 : $r[$i-1]+$r[$i-2];

}

return $r[--$i];

}

17、约瑟夫环，也就是常见的数猴子，n只猴子围成一圈，每只猴子下面标了编号，从1开始数起，数到m那么第m只猴子便退出，依次类推，每数到m，那么那个位置的猴子退出，那么最后剩下的猴子下的编号是啥。

function yuesefu($n,$m) {

$r=0;

for($i=2; $i<=$n; $i++) {

$r=($r+$m)%$i;

}

return $r+1;

}

18、冒泡排序，大致是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束

function bubbleSort($arr){

for($i=0, $len=count($arr); $i

for($j=0; $j

if($arr[$i]

$tmp = $arr[$j];

$arr[$j] = $arr[$i];

$arr[$i] = $tmp;

}

}

}

return $arr;

}

19、快速排序，也就是找出一个元素(理论上可以随便找一个)作为基准,然后对数组进行分区操作,使基准左边元素的值都不大于基准值,基准右边的元素值 都不小于基准值，如此作为基准的元素调整到排序后的正确位置。递归快速排序，将其他n-1个元素也调整到排序后的正确位置。最后每个元素都是在排序后的正 确位置，排序完成。所以快速排序算法的核心算法是分区操作，即如何调整基准的位置以及调整返回基准的最终位置以便分治递归。

function quickSort($arr){

$len = count($arr);

if($len <=1){

return $arr;

}

$key = $arr[0];

$leftArr = $rightArr= array();

for($i=1; $i

if($arr[$i] <= $key){

$leftArr[] = $arr[$i];

} else{

$rightArr[] = $arr[$i];

}

}

$leftArr = quickSort($leftArr);

$rightArr = quickSort($rightArr);

return array_merge($leftArr, array($key), $rightArr);

}

20、(递归的)列出目录下所有文件及目录，这里也有两种方法

function listDir($path){

$res = dir($path);

while($file = $res->read()){

if($file == '.' || $file == '..'){

continue;

}

if(is_dir($path . '/' .$file)){

echo $path . '/' .$file . "\r\n";

listDir($path . '/' .$file);

} else{

echo $path . '/' .$file . "\r\n";

}

}

$res->close();

}

function listDir($path){

if(is_dir($path)){

if(FALSE !== ($res = opendir($path))){

while(FALSE !== ($file = readdir($res))){

if($file == '.' || $file == '..'){

continue;

}

$subPath = $path . '/' . $file;

if(is_dir($subPath)){

echo $subPath . "\r\n";

listDir($subPath);

} else{

echo $subPath . "\r\n";

}

}

}

}

}

21、找出相对的目录，比如/a/b/c/d/e.php相对于/a/b/13/34/c.php是/c/d/

function ralativePath($a, $b){

$a = explode('/', dirname($a));

$b = explode('/', dirname($b));

$c = '/';

foreach ($a as $k=> $v){

if($v != $b[$k]){

$c .= $v . '/';

}

}

echo $c;

}

22、快速找出url中php后缀

function get_ext($url){

$data = parse_url($url);

return pathinfo($data['path'], PATHINFO_EXTENSION);

}

23、正则题，使用正则抓取网页，以网页meta为utf8为准，若是抓取的网页编码为big5之类的，需要转化为utf8再收录

function preg_meta($meta){

$replacement = "\\1utf8\\6\\7";

$pattern = '#()#i';

return preg_replace($pattern, $replacement, $meta);

}

echo preg_meta("");

24、不用php的反转函数倒序输出字符串，如abc，反序输出cba

function revstring($str){

for($i=strlen($str)-1; $i>=0; $i--){

echo $str{$i};

}

}

revstring('abc');

25、常见端口

TCP 21端口：FTP 文件传输服务

SSH 22端口：SSH连接linux服务器，通过SSH连接可以远程管理Linux等设备

TCP 23端口：TELNET 终端仿真服务

TCP 25端口：SMTP 简单邮件传输服务

UDP 53端口：DNS 域名解析服务

TCP 80端口：HTTP 超文本传输服务

TCP 110端口：POP3 “邮局协议版本3”使用的端口

TCP 443端口：HTTPS 加密的超文本传输服务

TCP 1521端口：Oracle数据库服务

TCP 1863端口：MSN Messenger的文件传输功能所使用的端口

TCP 3389端口：Microsoft RDP 微软远程桌面使用的端口

TCP 5631端口：Symantec pcAnywhere 远程控制数据传输时使用的端口

UDP 5632端口：Symantec pcAnywhere 主控端扫描被控端时使用的端口

TCP 5000端口：MS SQL Server使用的端口

UDP 8000端口：腾讯QQ

26、linux常用的命令

top linux进程实时监控

ps 在Linux中是查看进程的命令。ps查看正处于Running的进程

mv 为文件或目录改名或将文件由一个目录移入另一个目录中。

find 查找文件

df 可显示所有文件系统对i节点和磁盘块的使用情况。

cat 打印文件类容

chmod 变更文件或目录的权限

chgrp 文件或目录的权限的掌控以拥有者及所诉群组来管理。可以使用chgrp指令取变更文件与目录所属群组

grep 是一种强大的文本搜索工具,它能使用正则表达式搜索文本,并把匹 配的行打印出来。

wc 为统计指定文件中的字节数、字数、行数,并将统计结果显示输出

27、对于大流量的网站,您采用什么样的方法来解决访问量问题

首先，确认服务器硬件是否足够支持当前的流量

其次，优化数据库访问。

第三，禁止外部的盗链。

第四，控制大文件的下载。

第五，使用不同主机分流主要流量

第六，使用流量分析统计软件

28、$_SERVER常用的字段

$_SERVER['PHP_SELF'] #当前正在执行脚本的文件名

$_SERVER['SERVER_NAME'] #当前运行脚本所在服务器主机的名称

$_SERVER['REQUEST_METHOD'] #访问页面时的请求方法。例如：“GET”、“HEAD”，“POST”，“PUT”

$_SERVER['QUERY_STRING'] #查询(query)的字符串

$_SERVER['HTTP_HOST'] #当前请求的 Host: 头部的内容

$_SERVER['HTTP_REFERER'] #链接到当前页面的前一页面的 URL 地址

$_SERVER['REMOTE_ADDR'] #正在浏览当前页面用户的 IP 地址

$_SERVER['REMOTE_HOST'] #正在浏览当前页面用户的主机名

$_SERVER['SCRIPT_FILENAME'] #当前执行脚本的绝对路径名

$_SERVER['SCRIPT_NAME'] #包含当前脚本的路径。这在页面需要指向自己时非常有用

$_SERVER['REQUEST_URI'] #访问此页面所需的 URI。例如，“/index.html”

29、安装php扩展

进入扩展的目录

phpize命令得到configure文件

./configure --with-php-config=/usr/local/php/bin/php-config

make & make install

在php.ini中加入扩展名称.so

重启web服务器(nginx/apache)

30、php-fpm与nginx

PHP-FPM也是一个第三方的FastCGI进程管理器，它是作为PHP的一个补丁来开发的，在安装的时候也需要和PHP源码一起编译，也就是说PHP-FPM被编译到PHP内核中，因此在处理性能方面更加优秀；同时它在处理高并发方面也比spawn-fcgi引擎好很多，因此，推荐Nginx+PHP/PHP-FPM这个组合对PHP进行解析。

FastCGI 的主要优点是把动态语言和HTTP Server分离开来，所以Nginx与PHP/PHP-FPM经常被部署在不同的服务器上，以分担前端Nginx服务器的压力，使Nginx专一处理静态请求和转发动态请求，而PHP/PHP-FPM服务器专一解析PHP动态请求

#fastcgi

FastCGI是一个可伸缩地、高速地在HTTP server和动态脚本语言间通信的接口。多数流行的HTTP server都支持FastCGI，包括Apache、Nginx和lighttpd等，同时，FastCGI也被许多脚本语言所支持，其中就有PHP。

FastCGI是从CGI发展改进而来的。传统CGI接口方式的主要缺点是性能很差，因为每次HTTP服务器遇到动态程序时都需要重新启动脚本解析器来执行解析，然后结果被返回给HTTP服务器。这在处理高并发访问时，几乎是不可用的。另外传统的CGI接口方式安全性也很差，现在已经很少被使用了。

FastCGI接口方式采用C/S结构，可以将HTTP服务器和脚本解析服务器分开，同时在脚本解析服务器上启动一个或者多个脚本解析守护进程。当HTTP服务器每次遇到动态程序时，可以将其直接交付给FastCGI进程来执行，然后将得到的结果返回给浏览器。这种方式可以让HTTP服务器专一地处理静态请求或者将动态脚本服务器的结果返回给客户端，这在很大程度上提高了整个应用系统的性能。

Nginx+FastCGI运行原理

Nginx不支持对外部程序的直接调用或者解析，所有的外部程序(包括PHP)必须通过FastCGI接口来调用。FastCGI接口在Linux下是socket，(这个socket可以是文件socket，也可以是ip socket)。为了调用CGI程序，还需要一个FastCGI的wrapper(wrapper可以理解为用于启动另一个程序的程序)，这个wrapper绑定在某个固定socket上，如端口或者文件socket。当Nginx将CGI请求发送给这个socket的时候，通过FastCGI接口，wrapper接纳到请求，然后派生出一个新的线程，这个线程调用解释器或者外部程序处理脚本并读取返回数据；接着，wrapper再将返回的数据通过FastCGI接口，沿着固定的socket传递给Nginx；最后，Nginx将返回的数据发送给客户端，这就是Nginx+FastCGI的整个运作过程。

31、ajax全称“Asynchronous Javascript And XML”(异步JavaScript和XML)

小川游鱼

2019-12-02 01:41:29

0 浏览量

回答数 0

问题

【精品问答】Python二级考试题库

1.关于数据的存储结构，以下选项描述正确的是( D ) A: 数据所占的存储空间量 B: 存储在外存中的数据 C: 数据在计算机中的顺序存储方式 D: 数据的逻辑结构在计算机中的表示

2.关于线性...

珍宝珠

2019-12-01 22:03:38

1146 浏览量

回答数 2

回答

无影响，无限制。具体Group by分组查询使用规则可参考MaxCompute SELECT语法格式及使用SELECT语法执行嵌套查询、排序操作、分组查询等操作的注意事项

SELECT语法格式

SELECT [ALL | DISTINCT] select_expr, select_expr, ...

FROM table_reference

[WHERE where_condition]

[GROUP BY col_list]

[ORDER BY order_condition]

[DISTRIBUTE BY distribute_condition [SORT BY sort_condition] ]

[LIMIT number]

使用限制

当使用SELECT语句时，屏显目前最多只能显示10000行结果。当SELECT语句作为子句时则无此限制，SELECT子句会将全部结果返回给上层查询。 SELECT语句查询分区表时禁止全表扫描。 2018-01-10 20点后创建的新项目执行SQL时，默认情况下，针对该Project里的分区表不允许全表扫描。在查询分区表数据时必须指定分区，由此减少SQL的不必要I/O，从而减少计算资源的浪费以及按量付费模式下不必要的计算费用。

如果您需要对分区表进行全表扫描，可以在对分区表全表扫描的SQL语句前加上命令set odps.sql.allow.fullscan=true;，并和SQL语句一起提交执行。假设sale_detail表为分区表，需要同时执行如下语句进行全表查询。

set odps.sql.allow.fullscan=true; select * from sale_detail;

如果整个项目都需要全表扫描，执行如下命令打开开关。

setproject odps.sql.allow.fullscan=true;

列表达式(select_expr)

SELECT操作从表中读取数据，列表达式有以下几种形式： 用列名指定要读取的列。例如，读取表sale_detail的列shop_name。

select shop_name from sale_detail;

用*代表所有的列。读取表sale_detail中所有的列。

select * from sale_detail;

在WHERE中可以指定过滤的条件。

select * from sale_detail where shop_name like 'hang%';

select_expr支持正则表达式。举例如下： SELECT abc.* FROM t;选出t表中所有列名以abc开头的列。 SELECT (ds)?+.+ FROM t;选出t表中列名不为ds的所有列。 SELECT (ds|pt)?+.+ FROM t;选出t表中排除ds和pt两列的其它列。 SELECT (d.*)?+.+ FROM t;选出t表中排除列名以d开头的其它列。

DISTINCT去重。您可以在选取的列名前使用DISTINCT去掉重复字段，只返回一个值；而使用ALL会返回字段中所有重复的值。不指定此选项时，默认值为ALL。 举例如下。

--查询表sale_detail中region列数据，如果有重复值时仅显示一条。

select distinct region from sale_detail;

+------------+

| region |

+------------+

| shanghai |

+------------+

--distinct多列时，distinct的作用域是select的列集合，不是单个列。

select distinct region, sale_date from sale_detail;

+------------+------------+

| region | sale_date |

+------------+------------+

| shanghai | 20191110 |

+------------+------------+

TABLE_REFERENCE

table_reference为查询的目标表信息。除了支持已存在的目标表名称还支持使用嵌套子查询，如下所示。

select * from (select region from sale_detail) t where region = 'shanghai';

WHERE子句过滤

where子句支持的过滤条件，如下表所示。

示例

在SELECT语句的where子句中，您可以指定分区范围，只扫描表的指定部分，避免全表扫描，如下所示。

SELECT sale_detail.*

FROM sale_detail

WHERE sale_detail.sale_date >= '2008'

AND sale_detail.sale_date <= '2014';

UDF支持分区裁剪。支持的方式是将UDF语句先当作一个小作业执行，再将执行的结果替换到原来UDF出现的位置 。实现的方式有以下两种：

在编写UDF的时候，UDF类上加入Annotation。

@com.aliyun.odps.udf.annotation.UdfProperty(isDeterministic=true)

在SQL语句前设置Flag：set odps.sql.udf.ppr.deterministic = true;，此时SQL中所有的UDF均被视为deterministic。该操作执行的原理是进行执行结果回填，但是结果回填最多回填1000个Partition。因此，如果UDF类加入Annotation，则可能会导致出现超过1000个回填结果的报错。此时您如果需要忽视此错误，可以通过设置Flag：set odps.sql.udf.ppr.to.subquery = false;全局关闭此功能。关闭后，UDF分区裁剪也会失效。

between…and查询示例如下。

SELECT sale_detail.*

FROM sale_detail

WHERE sale_detail.sale_date BETWEEN '2008' AND '2014';

GROUP BY分组查询

通常，GROUP BY和配合使用。在SELECT中包含聚合函数时有以下规则： - 在SQL解析中，GROUP BY操作先于SELECT操作，因此GROUP BY的取值是SELECT输入表的列名或者由输入表的列构成的表达式，不允许是SELECT语句的输出列的别名。 - GROUP BY的值既是输入表的列或表达式，又是SELECT的输出列时，取值为输入表的列名。 当SQL语句set flag，即set hive.groupby.position.alias=true;时，GROUP BY中的整型常量会被当做SELECT的列序号处理。

set hive.groupby.position.alias=true;--与下一条sql语句一起执行。

select region, sum(total_price) from sale_detail group by 1;-- 1代表select的列中第一列即region，以region值分组，返回每一组的region值(组内唯一)及销售额总量。

示例

--直接使用输入表列名region作为group by的列，即以region值分组。

select region from sale_detail group by region;

--以region值分组，返回每一组的销售额总量。

select sum(total_price) from sale_detail group by region;

--以region值分组，返回每一组的region值(组内唯一)及销售额总量。

select region, sum(total_price) from sale_detail group by region;

--使用select列的别名运行，报错返回。

select region as r from sale_detail group by r;

--必须使用列的完整表达式。

select 2 + total_price as r from sale_detail group by 2 + total_price;

--报错返回，select的所有列中没有使用聚合函数的列，必须出现在group by中。

select region, total_price from sale_detail group by region;

--没有使用聚合函数的列出现在group by中后，运行成功。

select region, total_price from sale_detail group by region, total_price;

ORDER BY/SORT BY/DISTRIBUTE BY

DISTRIBUTE BY 功能说明：用于对数据按照某几列的值做Hash分片，必须使用SELECT的输出列别名。

示例

--查询表sale_detail中的列region值并按照region值进行哈希分片。

select region from sale_detail distribute by region;

-- 列名即是别名，可以运行。

select region as r from sale_detail distribute by region;

等同于

select region as r from sale_detail distribute by r;

ORDER BY 功能说明：用于对所有数据按照指定列进行全局排序。对记录进行降序排序，需要使用desc关键字。默认以升序排列。在使用order by排序时，NULL会被认为比任何值都小，这个行为与MySQL一致，但是与Oracle不一致。order by后面须加SELECT列的别名。当SELECT某列时，如果没有指定列的别名，则列名会被作为列的别名。当SQL语句set flag，set hive.orderby.position.alias=true;时，ORDER BY 中的整型常量会被当做SELECT的列序号处理。

--set flag。

set hive.orderby.position.alias=true;

--创建表src。

creat table src(key BIGINT，value BIGINT);

--以value值分组，返回表src的所有信息。

SELECT * FROM src ORDER BY 2 limit 100;

等同于

SELECT * FROM src ORDER BY value limit 100;

OFFSET 和 ORDER BY LIMIT语句配合，可以指定跳过OFFSET数目的行。

--将src按照key从小到大排序后，输出第11到第30行(OFFSET 10指定跳过前10行，LIMIT 20指定最多输出20行)。

SELECT * FROM src ORDER BY key LIMIT 20 OFFSET 10；

示例

--查询表sale_detail的信息，并按照region升序排列前100条。

select * from sale_detail order by region limit 100;

-- order by没有与limit共同使用时，报错返回。

select * from sale_detail order by region;

--order by加列的别名。

select region as r from sale_detail order by region limit 100;

select region as r from sale_detail order by r limit 100;

LIMIT NUMBER限制输出行数

limit number中的number是常数，限制输出行数。当使用无limit的SELECT语句直接从屏幕输出查看结果时，最多只输出10000行。每个项目空间的这个屏显最大限制可能不同，您可以通过setproject命令控制。

欢迎扫码加入 MaxCompute开发者社区钉钉群，或点击申请加入。

问问小秘

2020-06-04 11:56:06

0 浏览量

回答数 0

回答

STL看起来是使用了面向对象，但实际上是大部分都是面向过程了。

STL的很多算法，就拿sort函数来说吧。 void sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp);

只要数据结构的跌代器是随机访问的就可以使用。比如vector, list，同时也兼容普通数组int[]。

这里说到跌代器，STL有一整套跌代器的实现标准：

1、实现begin和end函数，是要全局的

如vecotr： vecotr::Iterator begin(vecotr);

而不是 vecotr的成员函数begin，这点要区分。

2、跌代器实现前至++运算

3、跌代器实现 * 运算

4、跌代器实现 != 运算

基本这四点就可以完成了，可以根据这个规则自己实现一个跌代器。

有了跌代器后，那么对于算法来说他们基本就一样了，开头，结尾，自增，以次访问就可以了。

所以一个sort就可以 vecotr a;

string b;

list c;

sort(a.begin(), a.end());

sort(b.begin(),b.end());

sort(c.begin(),c.end());

static bool less(int a1, int a2)

{

return a1

}

sort(a.begin(), a.begin()+5, less); // 对前5个排序

sort(a.begin(), a.end(), less);

sort(a.begin(), a.end(), [](int a1, int a2) {

return a1 <= a2; // 匿名函数

});

结论就是算法跟数据结构是通过跌代器进行沟通的，所以学好跌代器，STL才算学好，要会用，也要懂为原理。

晚来风急

2019-12-02 01:22:23

0 浏览量

回答数 0