黑桃K

M叉的B树1.根节点关键字的数量 [1,M-1]2.根节点孩子的数量 [2,M]3.非根节点关键字的数量 [M/2-1,M-1]4.非根节点孩子节点的数量 [M/2,M]5.一个节点中关键字按升序排列，孩子数量比关键字数量多16.所有叶子节点都在同一层，k[i[ k[i+1] 之间孩子中值大小在 k[i] k[i+1]// M叉树：即一个节点最多有M个孩子，M-1个数据域// 为实现简单期间，数据域与孩子与多增加一个(原因参见上文对插入过程的分析)template<class K,

一、什么是LRU最近最少使用的内存管理算法长期不被使用的数据，在未来被使用的概率也不大，所以当内存达到一定的交换阈值，会将最近最少使用的数据移除。二、使用方法采用哈希表和双向链表结合方式，使得访问数据。插入数据的效率达到O(1)。哈希表： unordered_map<int,list<int,pair<int,int>::iterator>链表： list<pair<int,int>>采用哈希表可以使得查找效率达到O(1) ，哈希表

定义：并查集是一种树型的数据结构，用于处理一些不相交集合的合并及查询问题（即所谓的合并、查询）。比如：我们可以用并查集来判断一个森林中有几棵树、某个节点是否属于某棵树等。主要构成：并查集主要由一个整型数组pre[ ]和两个函数：查找函数（findIndex）、**合并函(unionNum)**构成。数组 _ufs[ ] 记录了每个点的前驱节点是谁，函数 findIndex(x) 用于查找指定节点 x 属于哪个集合，函数 unionNum(x1,x2) 用于合并两个节点 x1 和 x2 。

文章目录插入排序希尔排序选择排序堆排冒泡排序快排归并排序计数排序总：插入排序//插入排序void insertSort(int* arr, int n){ for (int i = 1; i < n; i++){ int end = i - 1; int data = arr[i]; while (end>=0 && data<arr[end]){ arr[end + 1] = arr[end]; --end; } arr[end+1

二叉树节点的度：一个节点含有的子树的个数称为该节点的度； 如上图：A的为6 比特科技叶节点或终端节点：度为0的节点称为叶节点； 如上图：B、C、H、I…等节点为叶节点非终端节点或分支节点：度不为0的节点； 如上图：D、E、F、G…等节点为分支节点双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点； 如上图：A是B的父节点孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点； 如上图：B是A的孩子节点兄弟节点：具有相同父节点的节点互称为兄弟节点； 如上图：B、C是

如果有一个关键码的集合K = {k0，k1， k2，…，kn-1}，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足：Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0，1，2…，则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。堆的性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。#include<stdl.

环形队列环形队列可以使用数组实现，也可以使用链表实现；题：设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。你的实现应该支持如下操作：MyCircularQueue(k): 构造器，设置

头文件#pragma once#include<stdlib.h>typedef int QDataType;//节点typedef struct QNode{ struct QNode* _next; QDataType _data;}QNode;//队列typedef struct Queue{ QNode* _front; QNode* _rear; int _size;}Queue;//初始化void QueueInit(Queue* q);//创建队

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串 s ，判断字符串是否有效。有效字符串需满足：1.左括号必须用相同类型的右括号闭合。2.左括号必须以正确的顺序闭合。class Solution {public: bool isValid(string s) { if(s.size()%2==1) return false;//方法一： //每种情况的分析 // std::stack<char.

#include<stdlib.h>//双向带头循环链表typedef int LDataType;//数据类型typedef struct listNode{ LDataType _data; struct listNode* _prev;//指向上一个节点 struct listNode* _next;//指向下一个节点}listNode;//结构体定义 //双向带头循环链表typedef struct List{ listNode* _head;}List;//

#include<stdio.h>typedef int LDataType;//单链表节点typedef struct listNode{ LDataType _data; struct listNode* _next;}listNode;//头指针typedef struct list{ listNode* _head;}list;//初始化链表void listInit(list* lst){ if (lst == NULL) return; lst-&g

实现顺序表的头文件seqList.htypedef int SLDataType;typedef struct seqList{ SLDataType* _data;//需要动态开辟的数组 size_t _size;//有效元素个数 size_t _capacity;//元素容量大小}seqList;void initSeqList(seqList* sl);//初始化顺序表void push_back(seqList* sl, SLDataType val);//尾插void che

目录一、位图：1.1、位图概念：2.2、位图实现原理：2.2.1、构造位图：2.2.2、位图存储：2.2.3、位图删除：2.3、位图代码实现：2.4、位图的应用：一、位图：1.1、位图概念：用每个比特位判断某种状态，0/1 判断为两种状态，可以大大节省空间；适用于数据无重复，海量数据；通常判断数据存不存在；2.2、位图实现原理：2.2.1、构造位图：2.2.2、位图存储：2.2.3、位图删除：2.3、位图代码实现：#include<vector>using namespac

女：你一点都不注重细节；男：你说我不都细节？？ 你看看下面的红黑树讲解，，你说我不够细节？？随后男发送下面红黑树代码发给女朋友之后。女：哇，哥哥果然好细；男：细节拉满，关注又是一个细节；我们从一步一步一点一点的去挖这个红黑树，代码+图解红黑树的性质：首先记住它的性质：根节点是黑色的;如果一个节点是红色的，则它的两个孩子结点是黑色的;对于每个结点，从该结点到其所有后代叶结点的简单路径上，均包含相同数目的黑色结点;每个叶子结点都是黑色的(此处的叶子结点指的是空结点);对颜色进.

#include<stdio.h>typedef char DataType;typedef struct BNode{DataType _data;struct BNode* _left;struct BNode* _right;}BNode;//ABD##E#H##CF##G##BNode* creatBTree(DataType arr[], int idex){if (arr[idex] == ‘#’){(idex)++;return NULL;}else

//假设小堆typedef int HDataType;typedef struct heap{ HDataType* _data; int _size; int _capacity;}heap;void Swap(int* a, int* b){ int tmp = a; a = b; b = tmp;}void heapInit(heap* hp){ if (hp == NULL) return; //空堆 hp->_data = NULL; hp-&gt

栈的顺序表的实现# 栈的顺序表的实现#include<stdio.h>#include<stdio.h>typedef int STDataType;//顺序表结构实现typedef struct stack{ STDataType* _data; int _size; int _capacity;}stack;void stackInit(stack* st){ if (!st)return; st->_data = NULL; st->

顺序表：优点：1.空间连续2.支持随机访问3.空间利用率高，不容易造成内存碎片4.尾插尾删效率高缺点：1.头插头删，中间插入，删除效率低。不适合这些位置的插入，删除2.增容代价高：申请，拷贝，释放链表（双向带头循环）优点：1.任意位置插入，删除效率高2.空间利用率高（用就申请不用不申请）缺点:1.空间不连续，容易造成内存碎片2.不能随机访问...

#include<stdio.h>#include<stdlib.h>typedef int LDataType;//双向带头循环链表的节点typedef struct ListNode{ LDataType _data; //指向下一个节点的起始位置 struct ListNode* _next; //指向上一个节点的起始位置 struct ListNode* _prev;}ListNode;//双向带头循环链表typedef struct List{

线性表的链表的增删查改等的操作#include<stdio.h>//d定义类型typedef int LDateType;//定义结构体类型typedef struct listNode{ LDateType _date; struct listNode* _next;}listNode;//定义头指针typedef struct list{ listNode* _head;}list;//初始化头指针void InistList(list* lst){ if

线性表的增删查改等的实现#pragma once#include <stdio.h>#include <assert.h>#include <stdlib.h>// 对数据的管理:增删查改 typedef int SLDateType;typedef struct SeqList{ SLDateType* date; size_t size; size_t capacity; // unsigned int}SeqList;//检查顺序表容