数组的特点:
数组是将元素在内存中连续存放,由于每个元素占用内存相同,可以通过下标迅速访问数组中任何元素。数组的插入数据和删除数据效率低,插入数据时,这个位置后面的数据在内存中都要向后移。删除数据时,这个数据后面的数据都要往前移动。但数组的随机读取效率很高。因为数组是连续的,知道每一个数据的内存地址,可以直接找到给地址的数据。如果应用需要快速访问数据,很少或不插入和删除元素,就应该用数组。数组需要预留空间,在使用前要先申请占内存的大小,可能会浪费内存空间。并且数组不利于扩展,数组定义的空间不够时要重新定义数组。
链表的特点:
链表中的元素在内存中不是顺序存储的,而是通过存在元素中的指针联系到一起。比如:上一个元素有个指针指到下一个元素,以此类推,直到最后一个元素。如果要访问链表中一个元素,需要从第一个元素开始,一直找到需要的元素位置。但是增加和删除一个元素对于链表数据结构就非常简单了,只要修改元素中的指针就可以了。如果应用需要经常插入和删除元素你就需要用链表数据结构了。不指定大小,扩展方便。链表大小不用定义,数据随意增删。
各自的优缺点
数组的优点:
随机访问性强
查找速度快
数组的缺点:
插入和删除效率低
可能浪费内存
内存空间要求高,必须有足够的连续内存空间。
数组大小固定,不能动态拓展
链表的优点:
插入删除速度快
内存利用率高,不会浪费内存
大小没有固定,拓展很灵活。
链表的缺点:
不能随机查找,必须从第一个开始遍历,查找效率低
总结如下:
(1)存储形式:数组是一块连续的空间,声明时就要确定长度。链表是一块可不连续的动态空间,长度可变,每个结点要保存相邻结点指针。
(2)数据查找:数组的线性查找速度快,查找操作直接使用偏移地址。链表需要按顺序检索结点,效率低。
(3)数据插入或删除:链表可以快速插入和删除结点,而数组则可能需要大量数据移动。
(4)越界问题:链表不存在越界问题,数组有越界问题。
说明:在选择数组或链表数据结构时,一定要根据实际需要进行选择。数组便于查询,链表便于插入删除。数组节省空间但是长度固定,链表虽然变长但是占了更多的存储空间。
堆和栈的区别:
1)申请方式:
栈由系统自动分配和管理,堆由程序员手动分配和管理。
2)效率:
栈由系统分配,速度快,不会有内存碎片。
堆由程序员分配,速度较慢,可能由于操作不当产生内存碎片。
3)扩展方向
栈从高地址向低地址进行扩展,堆由低地址向高地址进行扩展。
4)程序局部变量是使用的栈空间,new/malloc动态申请的内存是堆空间,函数调用时会进行形参和返回值的压栈出栈,也是用的栈空间。
栈的效率高的原因:
栈是操作系统提供的数据结构,计算机底层对栈提供了一系列支持:分配专门的寄存器存储栈的地址,压栈和入栈有专门的指令执行;而堆是由C/C++函数库提供的,机制复杂,需要一些列分配内存、合并内存和释放内存的算法,因此效率较低。
堆是一棵完全二叉树(如果一共有h层,那么1~h-1层均满,在h层可能会连续缺失若干个右叶子)。
1)小根堆
若根节点存在左子女则根节点的值小于左子女的值;若根节点存在右子女则根节点的值小于右子女的值。
2)大根堆
若根节点存在左子女则根节点的值大于左子女的值;若根节点存在右子女则根节点的值大于右子女的值。
判断是否是循环链表时,也设置两个指针,慢指针和快指针,让快指针比慢指针每次移动快两次。如果快指针追赶上慢指针,则为循环链表,否则不是循环链表,如果快指针或者慢指针指向NULL,则不是循环链表。
int JudgeIsloop(NODE* list)
{
NODE *slow,*fast;
if(list == NULL)
return 0;
slow = list;
fast = list->next;
while(slow)
{
if(fast == NULL || fast->next == NULL)//走到头了
return 0;
else if(fast == slow || fast->next == slow)//二者相遇,因为fast走的快,如果fast->next指向slow,也是循环的
{
return 1;
}
else
{
slow = slow->next;//慢指针走一步
fast = fast->next->next;//快指针走两步
}
}
return 0;
}
单向链表:
NODE *linklist_reverse(NODE *head)
{
NODE *p,*q,*pr;
if(head == NULL)
{
return NULL;
}
p = head->next;//保存第一个元素节点的位置
q = NULL;
head->next = NULL;
while(p)
{
pr = p->next;
p->next = q;
q = p;
p = pr;
}
head->next = q;//原头节点的指针域指向原来最后一个元素节点
return head;
}
循环链表:
void linklist_invert(NODE *head)
{
NODE *q = head;
NODE *p = head->next;
q->next = head;
NODE *tmp = NULL;
while(p != head)
{
tmp = p->next;
p->next = q->next;
q->next = p;
p = tmp;
}
}
1、冒泡排序
从数组中第一个数开始,依次遍历数组中的每一个数,通过相邻比较交换,每一轮循环下来找出剩余未排序数的中的最大数并“冒泡”至数列的顶端。
稳定性:稳定
平均时间复杂度: O ( n 2 ) O(n ^ 2) O(n2)
int BubleSort(int *data ,int len)
{
if(data == NULL|| len < 0)
{
return -1;
}
int i,j;
//两个for循环,每次取出一个元素跟数组的其他元素比较
//将最大的元素排到最后。
for(i=0; i<len-1; i++)
{
//外循环一次,就排好一个数,并放在后面,
//所以比较前面n-i-1个元素即可
for(j =0; j<len-1-i; j++)
{
if(data[j] > data[j+1])
{
//方法一
data[j] = data[j]^data[j+1];
data[j+1] = data[j]^data[j+1];
data[j] = data[j]^data[j+1];
//方法二
//data[j] = data[j] + data[j+1];
//data[j+1] = data[j] - data[j+1];
//data[j] = data[j] - data[j+1];
}
}
}
return 0;
}
2、插入排序
从待排序的n个记录中的第二个记录开始,依次与前面的记录比较并寻找插入的位置,每次外循环结束后,将当前的数插入到合适的位置。
稳定性:稳定
平均时间复杂度: O ( n 2 ) O(n ^ 2) O(n2)
void InsertSort(int data[], int n) {
int low,high,mid;
int temp,i,j;
for(i=1;i<n;i++) {
low = 0;
//把data[i]元素插入到它的前面data[0-(i-1)]中
temp =data[i];
high = i-1;
//该while是折半,缩小data[i]的范围(优化手段)
while(low <= high) {
mid = (low+high)/2;
if(data[mid] > temp) {
high = mid-1;
}
else {
low = mid+1;
}
}
int j = i;
//让data与已经排序好的数组的各个元素比较,小的放前面
while((j > low) && data[j-1] > temp) {
data[j] = data[j-1];
--j;
}
data[low] = temp;
}
}
3、希尔排序(缩小增量排序)
希尔排序法是对相邻指定距离(称为增量)的元素进行比较,并不断把增量缩小至1,完成排序。
希尔排序开始时增量较大,分组较多,每组的记录数目较少,故在各组内采用直接插入排序较快,后来增量di逐渐缩小,分组数减少,各组的记录数增多,但由于已经按di−1分组排序,文件叫接近于有序状态,所以新的一趟排序过程较快。因此希尔 排序在效率上比直接插入排序有较大的改进。
在直接插入排序的基础上,将直接插入排序中的1全部改变成增量d即可,因为希尔排序最后一轮的增量d就为1。
稳定性:不稳定
平均时间复杂度:希尔排序算法的时间复杂度分析比较复杂,实际所需的时间取决于各次排序时增量的个数和增量的取值。时间复杂度在 O ( n 1.3 ) O(n ^ {1.3}) O(n1.3)到 O ( n 2 ) O(n ^ 2) O(n2)之间。
void shellSort(int * data, int n) {
int step,i,j,key;
//将数组按照step分组,不断二分到每组只剩下一个元素
for(step=n/2;step>0;step/=2) {
//将每组中的元素排序,小的在前
for(i=step;i<n;i++) {
key = data[i];
for(j=i-step;j>=0 && key<data[j];j-=step) {
data[j+step] = data[j];
}
//和上面的for循环一起,将组中小的元素换到数组的前面
data[j+step] = key;
}
}
}
4、选择排序
从所有记录中选出最小的一个数据元素与第一个位置的记录交换;然后在剩下的记录当中再找最小的与第二个位置的记录交换,循环到只剩下最后一个数据元素为止。
稳定性:不稳定
平均时间复杂度: O ( n 2 ) O(n ^ 2) O(n2)
void SelectSort(int data[], int n)
{
int i,j,min;
//每次循环数组,找出最小的元素,放在前面,前面的即为排序好的
for(i=0; i<n-1; i++)
{
//假设最小元素的下标
min = i;
//将上面假设的最小元素与数组比较,交换出最小的元素的下标
for(j=i+1; j<n; j++)
{
if(data[min] > data[j])
{
min = j;
}
}
//若数组中真的有比假设的元素还小,就交换
if(min != i)
{
//方法一
data[i] = data[i]^data[min];
data[min] = data[i]^data[min];
data[i] = data[i]^data[min];
//方法二
//data[i] = data[i] + data[min];
//data[min] = data[i] - data[min];
//data[i] = data[i] - data[min];
}
}
}
5、快速排序
1)从待排序的n个记录中任意选取一个记录(通常选取第一个记录)为分区标准;
2)把所有小于该排序列的记录移动到左边,把所有大于该排序码的记录移动到右边,中间放所选记录,称之为第一趟排序;
3)然后对前后两个子序列分别重复上述过程,直到所有记录都排好序。
稳定性:不稳定
平均时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn)
int findPos(int data[], int low, int high) {
//将大于t的元素赶到t的左边,大于t的元素赶到t的右边
int t = data[low];
while(low < high) {
while(low < high && data[high] >= t) {
high--;
}
data[low] = data[high];
while(low < high && data[low] <=t) {
low++;
}
data[high] = data[low];
}
data[low] = t;
//返回此时t在数组中的位置
return low;
}
//在数组中找一个元素,对大于该元素和小于该元素的两个数组进行再排序
//再对两个数组分为4个数组,再排序,直到最后每组只剩下一个元素为止
void quickSort(int data[], int low, int high) {
if(low > high) {
return;
}
int pos = findPos(data, low, high);
quickSort(data, low, pos-1);
quickSort(data, pos+1, high);
}
6、堆排序
堆:
1、完全二叉树或者是近似完全二叉树。
2、大顶堆:父节点不小于子节点键值,小顶堆:父节点不大于子节点键值。左右孩子没有大小的顺序。
堆排序在选择排序的基础上提出的,步骤:
1、建立堆
2、删除堆顶元素,同时交换堆顶元素和最后一个元素,再重新调整堆结构,直至全部删除堆中元素。
稳定性:不稳定
平均时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn)
//交换函数
void swap(int data[], int i, int j) {
int temp;
temp = data[i];
data[i] = data[j];
data[j] = temp;
}
void heapAdjust(int data[], int i, int n) {
int j, temp;
//假设第一个结点的元素是最大的
temp = data[i];
//i结点:2*i是i结点的左结点,2*i+1是i结点的右结点
//把结点元素大的交换到前面
for(j=2*i;j<=n;j*=2) {
if(j < n && data[j] < data[j+1]) {
j++;
}
if(temp >= data[j]) {
break;
}
data[i] = data[j];
i = j;
}
data[i] = temp;
}
void heapSort(int data[], int n) {
int i;
//先将数组组成一棵完全二叉树
//从2/n开始,就是从倒数第二排结点往前开始
for(i=n/2;i>0;i--) {
heapAdjust(data, i, n);
}
//循环每个结点,将大的结点交换到堆顶
for(i=n;i>1;i--) {
swap(data, 1, i);
//每次交换完都要调整二叉树,将剩下的最大的结点交换到堆顶
heapAdjust(data, 1, i-1);
}
}
7、归并排序
采用分治思想,现将序列分为一个个子序列,对子序列进行排序合并,直至整个序列有序。
稳定性:稳定
平均时间复杂度: O ( n l o g n ) O(nlogn) O(nlogn)
void merge(int data[], int low, int mid, int high) {
int i, k;
//定义一个临时数组存放传进来的无序数组排好序之后的数组
int *temp = (int *)malloc((high-low+1)*sizeof(int));
//将无序数组分成两个序列
int left_low = low;
int left_high = mid;
int right_low = mid+1;
int right_high = high;
//将两个序列比较排序,小的排前
for(k=0;left_low<=left_high && right_low<=right_high;k++) {
if(data[left_low]<=data[right_low]) {
temp[k] = data[left_low++];
}
else{
temp[k] = data[right_low++];
}
}
//左序列如果有剩下元素未排序,加到临时数组的末尾
if(left_low <= left_high) {
for(i=left_low;i<=left_high;i++) {
temp[k++] = data[i];
}
}
//右序列如果有剩下元素未排序,加到临时数组的末尾
if(right_low <= right_high) {
for(i=right_low;i<=right_high;i++) {
temp[k++] = data[i];
}
}
//将排好序的小分组转移到原数组中
for(i=0;i<high-low+1;i++) {
data[low+i] = temp[i];
}
free(temp);
return;
}
void mergeSort(int data[], int first, int last) {
int mid = 0;
//将数组不停的二分分组再组合,直到每组只剩一个元素
if(first < last) {
mid = (first+last)/2;
mergeSort(data, first, mid);
mergeSort(data, mid+1, last);
merge(data, first, mid, last);
}
return;
}
8、计数排序
思想:如果比元素x小的元素个数有n个,则元素x排序后位置为n+1。
步骤:
1)找出待排序的数组中最大的元素;
2)统计数组中每个值为i的元素出现的次数,存入数组C的第i项;
3)对所有的计数累加(从C中的第一个元素开始,每一项和前一项相加);
4)反向填充目标数组:将每个元素i放在新数组的第C(i)项,每放一个元素就将C(i)减去1。
稳定性:稳定
时间复杂度: O ( n + k ) O(n+k) O(n+k),k是待排序数的范围。
int getNumPos(int num, int pos) {
int i;
int temp = 1;
for(i=0;i<pos-1;i++) {
temp *= 10;
}
return (num / temp) % 10;
}
void radixSort(int data[], int n) {
int i,j,k,pos,num,index;
//这几句话是创建一个从0-9(行)× (n+1)(列)的网格,第一列从上往下是0-9,
//第二列是该行包含的元素个数,默认为0个
int *radixArrays[10];
for(i=0;i<10;i++) {
radixArrays[i] = (int *)malloc(sizeof(int) * (n+1));
radixArrays[i][0] = 0;
}
//pos最大为31为数,计算机能承受的最大范围了
for(pos=1;pos<=31;pos++) {
//该for循环是将数组的元素按照位数(pos)的值放进网格内
for(i=0;i<n;i++) {
num = getNumPos(data[i], pos);
index = ++radixArrays[num][0];
radixArrays[num][index] = data[i];
}
//该for循环是将上面的for循环已经按照某个位数(pos)排列好的元素存入数组
for(i=0,j=0;i<10;i++) {
for(k=1;k<=radixArrays[i][0];k++) {
data[j++] = radixArrays[i][k];
}
//清空网格,以便给下个位数排列
radixArrays[i][0] = 0;
}
}
}
9、桶排序
步骤:
1)设置一个定量的数组当作空桶子; 常见的排序算法及其复杂度:
2)寻访序列,并且把记录一个一个放到对应的桶子去;
3)对每个不是空的桶子进行排序。
4)从不是空的桶子里把项目再放回原来的序列中。
时间复杂度: O ( n + C ) O(n+C) O(n+C) ,C为桶内排序时间。
1.直接全部排序(只适用于内存够的情况)
当数据量较小的情况下,内存中可以容纳所有数据。则最简单也是最容易想到的方法是将数据全部排序,然后取排序后的数据中的前K个。
这种方法对数据量比较敏感,当数据量较大的情况下,内存不能完全容纳全部数据,这种方法便不适应了。即使内存能够满足要求,该方法将全部数据都排序了,而题目只要求找出top K个数据,所以该方法并不十分高效,不建议使用。
2.快速排序的变形 (只使用于内存够的情况)
这是一个基于快速排序的变形,因为第一种方法中说到将所有元素都排序并不十分高效,只需要找出前K个最大的就行。
这种方法类似于快速排序,首先选择一个划分元,将比这个划分元大的元素放到它的前面,比划分元小的元素放到它的后面,此时完成了一趟排序。如果此时这个划分元的序号index刚好等于K,那么这个划分元以及它左边的数,刚好就是前K个最大的元素;如果index > K,那么前K大的数据在index的左边,那么就继续递归的从index-1个数中进行一趟排序;如果index < K,那么再从划分元的右边继续进行排序,直到找到序号index刚好等于K为止。再将前K个数进行排序后,返回Top K个元素。这种方法就避免了对除了Top K个元素以外的数据进行排序所带来的不必要的开销。
3.最小堆法
这是一种局部淘汰法。先读取前K个数,建立一个最小堆。然后将剩余的所有数字依次与最小堆的堆顶进行比较,如果小于或等于堆顶数据,则继续比较下一个;否则,删除堆顶元素,并将新数据插入堆中,重新调整最小堆。当遍历完全部数据后,最小堆中的数据即为最大的K个数。
4.分治法
将全部数据分成N份,前提是每份的数据都可以读到内存中进行处理,找到每份数据中最大的K个数。此时剩下NK个数据,如果内存不能容纳NK个数据,则再继续分治处理,分成M份,找出每份数据中最大的K个数,如果M*K个数仍然不能读到内存中,则继续分治处理。直到剩余的数可以读入内存中,那么可以对这些数使用快速排序的变形或者归并排序进行处理。
5.Hash法
如果这些数据中有很多重复的数据,可以先通过hash法,把重复的数去掉。这样如果重复率很高的话,会减少很大的内存用量,从而缩小运算空间。处理后的数据如果能够读入内存,则可以直接排序;否则可以使用分治法或者最小堆法来处理数据。
1、单向加密
单向加密又称为不可逆加密算法,其密钥是由加密散列函数生成的。单向散列函数一般用于产生消息摘要,密钥加密等,常见的有:
MD5(Message Digest Algorithm 5):是RSA数据安全公司开发的一种单向散列算法,非可逆,相同的明文产生相同的密文;
SHA(Secure Hash Algorithm):可以对任意长度的数据运算生成一个160位的数值。其变种由SHA192,SHA256,SHA384等;
CRC-32,主要用于提供校验功能;
算法特征:
输入一样,输出必然相同;
雪崩效应,输入的微小改变,将会引起结果的巨大变化;
定长输出,无论原始数据多大,结果大小都是相同的;
不可逆,无法根据特征码还原原来的数据;
2、对称加密
采用单钥密码系统的加密方法,同一个密钥可以同时用作信息的加密和解密,这种加密方法称为对称加密,也称为单密钥加密。
特点:
1、加密方和解密方使用同一个密钥;
2、加密解密的速度比较快,适合数据比较长时的使用;
3、密钥传输的过程不安全,且容易被破解,密钥管理也比较麻烦;
优点:对称加密算法的优点是算法公开、计算量小、加密速度快、加密效率高。
缺点:对称加密算法的缺点是在数据传送前,发送方和接收方必须商定好秘钥,然后使双方都能保存好秘钥。其次如果一方的秘钥被泄露,那么加密信息也就不安全了。另外,每对用户每次使用对称加密算法时,都需要使用其他人不知道的唯一秘钥,这会使得收、发双方所拥有的钥匙数量巨大,密钥管理成为双方的负担。
3、非对称加密
非对称密钥加密也称为公钥加密,由一对公钥和私钥组成。公钥是从私钥提取出来的。可以用公钥加密,再用私钥解密,这种情形一般用于公钥加密,当然也可以用私钥加密,用公钥解密。常用于数字签名,因此非对称加密的主要功能就是加密和数字签名。
特征:
1)秘钥对,公钥(public key)和私钥(secret key)
2)主要功能:加密和签名
发送方用对方的公钥加密,可以保证数据的机密性(公钥加密)。
发送方用自己的私钥加密,可以实现身份验证(数字签名)。
3)公钥加密算法很少用来加密数据,速度太慢,通常用来实现身份验证。
常用的非对称加密算法
RSA:由 RSA公司发明,是一个支持变长密钥的公共密钥算法,需要加密的文件块的长度也是可变的;既可以实现加密,又可以实现签名。
DSA(Digital Signature Algorithm):数字签名算法,是一种标准的 DSS(数字签名标准)。
ECC(Elliptic Curves Cryptography):椭圆曲线密码编码。
红黑树和AVL树的定义,特点,以及二者区别
平衡二叉树(AVL树):
平衡二叉树又称为AVL树,是一种特殊的二叉排序树。其左右子树都是平衡二叉树,且左右子树高度之差的绝对值不超过1。一句话表述为:以树中所有结点为根的树的左右子树高度之差的绝对值不超过1。将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF,那么平衡二叉树上的所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝对值大于1,则该二叉树就是不平衡的。
红黑树:
红黑树是一种二叉查找树,但在每个节点增加一个存储位表示节点的颜色,可以是红或黑(非红即黑)。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制,红黑树确保没有一条路径会比其它路径长出两倍,因此,红黑树是一种弱平衡二叉树,相对于要求严格的AVL树来说,它的旋转次数少,所以对于搜索,插入,删除操作较多的情况下,通常使用红黑树。
性质:
每个节点非红即黑
根节点是黑的;
每个叶节点(叶节点即树尾端NULL指针或NULL节点)都是黑的;
如果一个节点是红色的,则它的子节点必须是黑色的。
对于任意节点而言,其到叶子点树NULL指针的每条路径都包含相同数目的黑节点;
区别:
AVL 树是高度平衡的,频繁的插入和删除,会引起频繁的rebalance,导致效率下降;红黑树不是高度平衡的,算是一种折中,插入最多两次旋转,删除最多三次旋转。
哈夫曼编码
哈夫曼编码是哈夫曼树的一种应用,广泛用于数据文件压缩。哈夫曼编码算法用字符在文件中出现的频率来建立使用0,1表示个字符的最优表示方式,其具体算法如下:
(1)哈夫曼算法以自底向上的方式构造表示最优前缀码的二叉树T。
(2)算法以|C|个叶结点开始,执行|C|-1次的“合并”运算后产生最终所要求的树T。
(3)假设编码字符集中每一字符c的频率是f©。以f为键值的优先队列Q用在贪心选择时有效地确定算法当前要合并的2棵具有最小频率的树。一旦2棵具有最小频率的树合并后,产生一棵新的树,其频率为合并的2棵树的频率之和,并将新树插入优先队列Q。经过n-1次的合并后,优先队列中只剩下一棵树,即所要求的树T。
map底层为什么用红黑树实现
1、红黑树:
红黑树是一种二叉查找树,但在每个节点增加一个存储位表示节点的颜色,可以是红或黑(非红即黑)。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制,红黑树确保没有一条路径会比其它路径长出两倍,因此,红黑树是一种弱平衡二叉树,相对于要求严格的AVL树来说,它的旋转次数少,所以对于搜索,插入,删除操作较多的情况下,通常使用红黑树。
性质:
每个节点非红即黑
根节点是黑的;
每个叶节点(叶节点即树尾端NULL指针或NULL节点)都是黑的;
如果一个节点是红色的,则它的子节点必须是黑色的。
对于任意节点而言,其到叶子点树NULL指针的每条路径都包含相同数目的黑节点;
2、平衡二叉树(AVL树):
红黑树是在AVL树的基础上提出来的。
平衡二叉树又称为AVL树,是一种特殊的二叉排序树。其左右子树都是平衡二叉树,且左右子树高度之差的绝对值不超过1。
AVL树中所有结点为根的树的左右子树高度之差的绝对值不超过1。
将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF,那么平衡二叉树上的所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝对值大于1,则该二叉树就是不平衡的。
3、红黑树较AVL树的优点:
AVL 树是高度平衡的,频繁的插入和删除,会引起频繁的rebalance,导致效率下降;红黑树不是高度平衡的,算是一种折中,插入最多两次旋转,删除最多三次旋转。
所以红黑树在查找,插入删除的性能都是O(logn),且性能稳定,所以STL里面很多结构包括map底层实现都是使用的红黑树。
B+树
B+是一种多路搜索树,主要为磁盘或其他直接存取辅助设备而设计的一种平衡查找树,在B+树中,每个节点的可以有多个孩子,并且按照关键字大小有序排列。所有记录节点都是按照键值的大小顺序存放在同一层的叶节点中。相比B树,其具有以下几个特点:
每个节点上的指针上限为2d而不是2d+1(d为节点的出度)
内节点不存储data,只存储key
叶子节点不存储指针
map和unordered_map的底层实现
map底层是基于红黑树实现的,因此map内部元素排列是有序的。而unordered_map底层则是基于哈希表实现的,因此其元素的排列顺序是杂乱无序的。
map和unordered_map优点和缺点
对于map,其底层是基于红黑树实现的,优点如下:
1)有序性,这是map结构最大的优点,其元素的有序性在很多应用中都会简化很多的操作
2)map的查找、删除、增加等一系列操作时间复杂度稳定,都为logn
缺点如下:
1)查找、删除、增加等操作平均时间复杂度较慢,与n相关
对于unordered_map来说,其底层是一个哈希表,优点如下:
查找、删除、添加的速度快,时间复杂度为常数级O©
缺点如下:
因为unordered_map内部基于哈希表,以(key,value)对的形式存储,因此空间占用率高
Unordered_map的查找、删除、添加的时间复杂度不稳定,平均为O©,取决于哈希函数。极端情况下可能为O(n)
epoll怎么实现的
Linux epoll机制是通过红黑树和双向链表实现的。 首先通过epoll_create()系统调用在内核中创建一个eventpoll类型的句柄,其中包括红黑树根节点和双向链表头节点。然后通过epoll_ctl()系统调用,向epoll对象的红黑树结构中添加、删除、修改感兴趣的事件,返回0标识成功,返回-1表示失败。最后通过epoll_wait()系统调用判断双向链表是否为空,如果为空则阻塞。当文件描述符状态改变,fd上的回调函数被调用,该函数将fd加入到双向链表中,此时epoll_wait函数被唤醒,返回就绪好的事件。
Top(K)问题
1、直接全部排序(只适用于内存够的情况)
当数据量较小的情况下,内存中可以容纳所有数据。则最简单也是最容易想到的方法是将数据全部排序,然后取排序后的数据中的前K个。
这种方法对数据量比较敏感,当数据量较大的情况下,内存不能完全容纳全部数据,这种方法便不适应了。即使内存能够满足要求,该方法将全部数据都排序了,而题目只要求找出top K个数据,所以该方法并不十分高效,不建议使用。
2、快速排序的变形 (只使用于内存够的情况)
这是一个基于快速排序的变形,因为第一种方法中说到将所有元素都排序并不十分高效,只需要找出前K个最大的就行。
这种方法类似于快速排序,首先选择一个划分元,将比这个划分元大的元素放到它的前面,比划分元小的元素放到它的后面,此时完成了一趟排序。如果此时这个划分元的序号index刚好等于K,那么这个划分元以及它左边的数,刚好就是前K个最大的元素;如果index > K,那么前K大的数据在index的左边,那么就继续递归的从index-1个数中进行一趟排序;如果index < K,那么再从划分元的右边继续进行排序,直到找到序号index刚好等于K为止。再将前K个数进行排序后,返回Top K个元素。这种方法就避免了对除了Top K个元素以外的数据进行排序所带来的不必要的开销。
3、最小堆法
这是一种局部淘汰法。先读取前K个数,建立一个最小堆。然后将剩余的所有数字依次与最小堆的堆顶进行比较,如果小于或等于堆顶数据,则继续比较下一个;否则,删除堆顶元素,并将新数据插入堆中,重新调整最小堆。当遍历完全部数据后,最小堆中的数据即为最大的K个数。
4、分治法
将全部数据分成N份,前提是每份的数据都可以读到内存中进行处理,找到每份数据中最大的K个数。此时剩下NK个数据,如果内存不能容纳NK个数据,则再继续分治处理,分成M份,找出每份数据中最大的K个数,如果M*K个数仍然不能读到内存中,则继续分治处理。直到剩余的数可以读入内存中,那么可以对这些数使用快速排序的变形或者归并排序进行处理。
5、Hash法
如果这些数据中有很多重复的数据,可以先通过hash法,把重复的数去掉。这样如果重复率很高的话,会减少很大的内存用量,从而缩小运算空间。处理后的数据如果能够读入内存,则可以直接排序;否则可以使用分治法或者最小堆法来处理数据。
红黑树的性质还有左右旋转
1)平衡二叉树(AVL树):
红黑树是在AVL树的基础上提出来的。
平衡二叉树又称为AVL树,是一种特殊的二叉排序树。其左右子树都是平衡二叉树,且左右子树高度之差的绝对值不超过1。
AVL树中所有结点为根的树的左右子树高度之差的绝对值不超过1。
将二叉树上结点的左子树深度减去右子树深度的值称为平衡因子BF,那么平衡二叉树上的所有结点的平衡因子只可能是-1、0和1。只要二叉树上有一个结点的平衡因子的绝对值大于1,则该二叉树就是不平衡的。
2)红黑树:
红黑树是在AVL树的基础上发展而来的。红黑树是一种二叉查找树,但在每个节点增加一个存储位表示节点的颜色,可以是红或黑(非红即黑)。通过对任何一条从根到叶子的路径上各个节点着色的方式的限制,红黑树确保没有一条路径会比其它路径长出两倍,因此,红黑树是一种弱平衡二叉树,相对于要求严格的AVL树来说,它的旋转次数少,所以对于搜索,插入,删除操作较多的情况下,通常使用红黑树。
性质:
每个节点非红即黑
根节点是黑的;
每个叶节点(叶节点即树尾端NULL指针或NULL节点)都是黑的;
如果一个节点是红色的,则它的子节点必须是黑色的。
对于任意节点而言,其到叶子点树NULL指针的每条路径都包含相同数目的黑节点;
从根到叶子的最长的可能路径不多于最短的可能路径的两倍长。它可以在O(log n)时间内做查找,插入和删除,这里的n 是树中元素的数目。恢复红黑属性需要少量(O(log n))的颜色变更(这在实践中是非常快速的)并且不超过三次树旋转(对于插入是两次)。这允许插入和删除保持为 O(log n) 次。
3)红黑树较AVL树的优点:
AVL 树是高度平衡的,频繁的插入和删除,会引起频繁的rebalance,导致效率下降;红黑树不是高度平衡的,算是一种折中,插入最多两次旋转,删除最多三次旋转。
所以红黑树在查找,插入删除的性能都是O(logn),且性能稳定,所以STL里面很多结构包括map底层实现都是使用的红黑树。
4)红黑树旋转:
旋转:红黑树的旋转是一种能保持二叉搜索树性质的搜索树局部操作。有左旋和右旋两种旋转,通过改变树中某些结点的颜色以及指针结构来保持对红黑树进行插入和删除操作后的红黑性质。
左旋:对某个结点x做左旋操作时,假设其右孩子为y而不是T.nil:以x到y的链为“支轴”进行。使y成为该子树新的根结点,x成为y的左孩子,y的左孩子成为x的右孩子。
右旋:对某个结点x做右旋操作时,假设其左孩子为y而不是T.nil:以x到y的链为“支轴”进行。使y成为该子树新的根结点,x成为y的右孩子,y的右孩子成为x的左孩子。
二叉树的层序遍历并输出
void layerTrace(BTreeNode *T)
{
if(T== nullptr)return;
BTreeNode *p=T;
queue<BTreeNode*>q;
q.push(p);
while(!q.empty())
{
p=q.front();
q.pop();
cout<<<<p->data;
if(p->left!= nullptr)
q.push(p->left);
if(p->right!= nullptr)
q.push(p->right);
}
}
叉树序列化反序列化
序列化:必须保存一个中序遍历结果,然后外加一个前序或者后序遍历结果
反序列化:根据两次遍历生成的结果恢复二叉树,代码如下(前序和中序):
TreeNode* helper(vector<int>pre,int startPre,int endPre,vector<int>in,int startIn,int endIn)
{
if(startPre>endPre||startIn>endIn)
return nullptr;
TreeNode * root=new TreeNode(pre[startPre]);
for(int i=startIn;i<=endIn;++i)
{
if(in[i]==pre[startPre])
{
root->left=helper(pre,startPre+1,startPre+i-startIn,in,startIn,i-1);
root->right=helper(pre,i-startIn+startPre+1,endPre,in,i+1,endIn);
break;
}
}
return root;
}
TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin)
{
TreeNode *root=helper(pre,0,pre.size()-1,vin,0,vin.size()-1);
return root;
}
简要说说二叉树以及如何遍历
每个结点最多有两棵子树,左子树和右子树,次序不可以颠倒。
先序遍历,中序遍历,后序遍历。
hash表的实现,包括STL中的哈希桶长度常数
hash表的实现主要包括构造哈希和处理哈希冲突两个方面:
对于构造哈希来说,主要包括直接地址法、平方取中法、除留余数法等。
对于处理哈希冲突来说,最常用的处理冲突的方法有开放定址法、再哈希法、链地址法、建立公共溢出区等方法。SGL版本使用链地址法,使用一个链表保持相同散列值的元素。
虽然链地址法并不要求哈希桶长度必须为质数,但SGI STL仍然以质数来设计哈希桶长度,并且将28个质数(逐渐呈现大约两倍的关系)计算好,以备随时访问,同时提供一个函数,用来查询在这28个质数之中,“最接近某数并大于某数”的质数。
hash表如何rehash,以及怎么处理其中保存的资源
C++的hash表中有一个负载因子loadFactor,当loadFactor<=1时,hash表查找的期望复杂度为O(1). 因此,每次往hash表中添加元素时,我们必须保证是在loadFactor <1的情况下,才能够添加。
因此,当Hash表中loadFactor==1时,Hash就需要进行rehash。rehash过程中,会模仿C++的vector扩容方式,Hash表中每次发现loadFactor ==1时,就开辟一个原来桶数组的两倍空间,称为新桶数组,然后把原来的桶数组中元素全部重新哈希到新的桶数组中。
哈希表的桶个数为什么是质数,合数有何不妥?
哈希表的桶个数使用质数,可以最大程度减少冲突概率,使哈希后的数据分布的更加均匀。如果使用合数,可能会
造成很多数据分布会集中在某些点上,从而影响哈希表效率。
算法:
给定一个数字数组,返回哈夫曼树的头指针
struct BTreeNode* CreateHuffman(ElemType a[], int n)
{
int i, j;
struct BTreeNode **b, *q;
b = malloc(n*sizeof(struct BTreeNode));
for (i = 0; i < n; i++)
{
b[i] = malloc(sizeof(struct BTreeNode));
b[i]->data = a[i];
b[i]->left = b[i]->right = NULL;
}
for (i = 1; i < n; i++)
{
int k1 = -1, k2;
for (j = 0; j < n; j++)
{
if (b[j] != NULL && k1 == -1)
{
k1 = j;
continue;
}
if (b[j] != NULL)
{
k2 = j;
break;
}
}
for (j = k2; j < n; j++)
{
if (b[j] != NULL)
{
if (b[j]->data < b[k1]->data)
{
k2 = k1;
k1 = j;
}
else if (b[j]->data < b[k2]->data)
k2 = j;
}
}
q = malloc(sizeof(struct BTreeNode));
q->data = b[k1]->data + b[k2]->data;
q->left = b[k1];
q->right = b[k2];
b[k1] = q;
b[k2] = NULL;
}
free(b);
return q;
}
哈希冲突的解决方法
1、开放定址
开放地址法有个非常关键的特征,就是所有输入的元素全部存放在哈希表里,也就是说,位桶的实现是不需要任何的链表来实现的,换句话说,也就是这个哈希表的装载因子不会超过1。它的实现是在插入一个元素的时候,先通过哈希函数进行判断,若是发生哈希冲突,就以当前地址为基准,根据再寻址的方法(探查序列),去寻找下一个地址,若发生冲突再去寻找,直至找到一个为空的地址为止。所以这种方法又称为再散列法。
有几种常用的探查序列的方法:
①线性探查
dii=1,2,3,…,m-1;这种方法的特点是:冲突发生时,顺序查看表中下一单元,直到找出一个空单元或查遍全表。
②二次探查
di=12,-12,22,-22,…,k2,-k2 ( k<=m/2 );这种方法的特点是:冲突发生时,在表的左右进行跳跃式探测,比较灵活。
③ 伪随机探测
di=伪随机数序列;具体实现时,应建立一个伪随机数发生器,(如i=(i+p) % m),生成一个位随机序列,并给定一个随机数做起点,每次去加上这个伪随机数++就可以了。
2、链地址
每个位桶实现的时候,采用链表或者树的数据结构来去存取发生哈希冲突的输入域的关键字,也就是被哈希函数映射到同一个位桶上的关键字。
紫色部分即代表哈希表,也称为哈希数组,数组的每个元素都是一个单链表的头节点,链表是用来解决冲突的,如果不同的key映射到了数组的同一位置处,就将其放入单链表中,即链接在桶后。
3、公共溢出区
建立一个公共溢出区域,把hash冲突的元素都放在该溢出区里。查找时,如果发现hash表中对应桶里存在其他元素,还需要在公共溢出区里再次进行查找。
4、再hash
再散列法其实很简单,就是再使用哈希函数去散列一个输入的时候,输出是同一个位置就再次散列,直至不发生冲突位置。
缺点:每次冲突都要重新散列,计算时间增加。
队列和栈都是线性存储结构,但是两者的插入和删除数据的操作不同,队列是“先进先出”,栈是“后进先出”。
注意:区别栈区和堆区。堆区的存取是“顺序随意”,而栈区是“后进先出”。栈由编译器自动分配释放 ,存放函数的参数值,局部变量的值等。其操作方式类似于数据结构中的栈。堆一般由程序员分配释放, 若程序员不释放,程序结束时可能由OS回收。分配方式类似于链表。
它与本题中的堆和栈是两回事。堆栈只是一种数据结构,而堆区和栈区是程序的不同内存存储区域。
栈和队列都属于一维链表
区别是:
栈是后进先出,进和出都是在同一端进行,称为"压栈"(push)和"弹栈"(pop),就好象一筒羽毛球,只有把上面拿出来,下面的才能拿出来。
队列是先进先出的,进和出分别在不同的端进行,比如排队的人,排在前面的人先到柜台办理业务,后面来的人后得到服务,所以称为"队列"是很形象的。
栈的应用:1.用于符号匹配
2.用于计算代数式。( 也可以用二叉树来解决 )
3.构造表达式。( 也可以用二叉树来解决 )
4.用于函数调用
队列应用:当多个任务分配给打印机时,为了防止冲突,创建一个队列,把任务入队,按先入先出的原则处理任务。
当多个用户要访问远程服务端的文件时,也用到队列,满足先来先服务的原则。
一个单链表遍历一次,如何找到倒数第二个数据?
通过一次遍历找到单链表中倒数第n个节点,链表可能相当大,可使用辅助空间,但是辅助空间的数目必须固定,不能和n有关。
单向链表的特点是遍历到末尾后不能反向重数N个节点。因此必须在到达尾部的同时找到倒数第N个节点。
不管是顺数n个还是倒数n个,其实都是距离-标尺问题。标尺是一段距离可以用线段的两个端点来衡量,我们能够判断倒数第一个节点,因为他的next==NULL。如果我们用两个指针,并保持他们的距离为n,那么当这个线段的右端指向末尾节点时,左端节点就指向倒数第n个节点。