# 插入 B 树
> 原文： [https://www.programiz.com/dsa/insertion-into-a-b-tree](https://www.programiz.com/dsa/insertion-into-a-b-tree)
#### 在本教程中，您将学习如何将键插入 B 树。 此外，您还将找到在 C，C++ ，Java 和 Python 中将键插入 B 树的工作示例。
在 B 树上插入元素包括两个事件：搜索适当的节点**来插入元素**，以及**拆分节点**。如有必要，插入操作始终从下往上进行。
让我们在下面了解这些事件。
* * *
## 插入操作
1. 如果树为空，请分配一个根节点并插入键。
2. 更新节点中允许的键数。
3. 搜索适当的节点以进行插入。
4. 如果节点已满，请执行以下步骤。
5. 按递增顺序插入元素。
6. 现在，有一些元素超出了其限制。 因此，将中位数拆分。
7. 向上推中键，将左键作为左子代，将右键作为右子代。
8. 如果节点未满，请执行以下步骤。
9. 按升序插入节点。
* * *
## 插入示例
让我们通过以下插图了解插入操作。
要插入的元素是 8、9、10、11、15、16、17、18、20、23。
将元素插入 B 树
* * *
## 元素插入算法
```
BreeInsertion(T, k)
r root[T]
if n[r] = 2t - 1
s = AllocateNode()
root[T] = s
leaf[s] = FALSE
n[s] <- 0
c1[s] <- r
BtreeSplitChild(s, 1, r)
BtreeInsertNonFull(s, k)
else BtreeInsertNonFull(r, k)
BtreeInsertNonFull(x, k)
i = n[x]
if leaf[x]
while i ≥ 1 and k < keyi[x]
keyi+1 [x] = keyi[x]
i = i - 1
keyi+1[x] = k
n[x] = n[x] + 1
else while i ≥ 1 and k < keyi[x]
i = i - 1
i = i + 1
if n[ci[x]] == 2t - 1
BtreeSplitChild(x, i, ci[x])
if k &rt; keyi[x]
i = i + 1
BtreeInsertNonFull(ci[x], k)
BtreeSplitChild(x, i)
BtreeSplitChild(x, i, y)
z = AllocateNode()
leaf[z] = leaf[y]
n[z] = t - 1
for j = 1 to t - 1
keyj[z] = keyj+t[y]
if not leaf [y]
for j = 1 to t
cj[z] = cj + t[y]
n[y] = t - 1
for j = n[x] + 1 to i + 1
cj+1[x] = cj[x]
ci+1[x] = z
for j = n[x] to i
keyj+1[x] = keyj[x]
keyi[x] = keyt[y]
n[x] = n[x] + 1
```
* * *
## Python，Java 和 C/C++ 示例
```py
# Inserting a key on a B-tree in Python
# Create a node
class BTreeNode:
def __init__(self, leaf=False):
self.leaf = leaf
self.keys = []
self.child = []
# Tree
class BTree:
def __init__(self, t):
self.root = BTreeNode(True)
self.t = t
# Insert node
def insert(self, k):
root = self.root
if len(root.keys) == (2 * self.t) - 1:
temp = BTreeNode()
self.root = temp
temp.child.insert(0, root)
self.split_child(temp, 0)
self.insert_non_full(temp, k)
else:
self.insert_non_full(root, k)
# Insert nonfull
def insert_non_full(self, x, k):
i = len(x.keys) - 1
if x.leaf:
x.keys.append((None, None))
while i >= 0 and k[0] < x.keys[i][0]:
x.keys[i + 1] = x.keys[i]
i -= 1
x.keys[i + 1] = k
else:
while i >= 0 and k[0] < x.keys[i][0]:
i -= 1
i += 1
if len(x.child[i].keys) == (2 * self.t) - 1:
self.split_child(x, i)
if k[0] > x.keys[i][0]:
i += 1
self.insert_non_full(x.child[i], k)
# Split the child
def split_child(self, x, i):
t = self.t
y = x.child[i]
z = BTreeNode(y.leaf)
x.child.insert(i + 1, z)
x.keys.insert(i, y.keys[t - 1])
z.keys = y.keys[t: (2 * t) - 1]
y.keys = y.keys[0: t - 1]
if not y.leaf:
z.child = y.child[t: 2 * t]
y.child = y.child[0: t - 1]
# Print the tree
def print_tree(self, x, l=0):
print("Level ", l, " ", len(x.keys), end=":")
for i in x.keys:
print(i, end=" ")
print()
l += 1
if len(x.child) > 0:
for i in x.child:
self.print_tree(i, l)
def main():
B = BTree(3)
for i in range(10):
B.insert((i, 2 * i))
B.print_tree(B.root)
if __name__ == '__main__':
main()
```
```java
// Inserting a key on a B-tree in Java
public class BTree {
private int T;
// Node Creation
public class Node {
int n;
int key[] = new int[2 * T - 1];
Node child[] = new Node[2 * T];
boolean leaf = true;
public int Find(int k) {
for (int i = 0; i < this.n; i++) {
if (this.key[i] == k) {
return i;
}
}
return -1;
};
}
public BTree(int t) {
T = t;
root = new Node();
root.n = 0;
root.leaf = true;
}
private Node root;
// split
private void split(Node x, int pos, Node y) {
Node z = new Node();
z.leaf = y.leaf;
z.n = T - 1;
for (int j = 0; j < T - 1; j++) {
z.key[j] = y.key[j + T];
}
if (!y.leaf) {
for (int j = 0; j < T; j++) {
z.child[j] = y.child[j + T];
}
}
y.n = T - 1;
for (int j = x.n; j >= pos + 1; j--) {
x.child[j + 1] = x.child[j];
}
x.child[pos + 1] = z;
for (int j = x.n - 1; j >= pos; j--) {
x.key[j + 1] = x.key[j];
}
x.key[pos] = y.key[T - 1];
x.n = x.n + 1;
}
// insert key
public void insert(final int key) {
Node r = root;
if (r.n == 2 * T - 1) {
Node s = new Node();
root = s;
s.leaf = false;
s.n = 0;
s.child[0] = r;
split(s, 0, r);
_insert(s, key);
} else {
_insert(r, key);
}
}
// insert node
final private void _insert(Node x, int k) {
if (x.leaf) {
int i = 0;
for (i = x.n - 1; i >= 0 && k < x.key[i]; i--) {
x.key[i + 1] = x.key[i];
}
x.key[i + 1] = k;
x.n = x.n + 1;
} else {
int i = 0;
for (i = x.n - 1; i >= 0 && k < x.key[i]; i--) {
}
;
i++;
Node tmp = x.child[i];
if (tmp.n == 2 * T - 1) {
split(x, i, tmp);
if (k > x.key[i]) {
i++;
}
}
_insert(x.child[i], k);
}
}
public void display() {
display(root);
}
// Display the tree
private void display(Node x) {
assert (x == null);
for (int i = 0; i < x.n; i++) {
System.out.print(x.key[i] + " ");
}
if (!x.leaf) {
for (int i = 0; i < x.n + 1; i++) {
display(x.child[i]);
}
}
}
public static void main(String[] args) {
BTree b = new BTree(3);
b.insert(8);
b.insert(9);
b.insert(10);
b.insert(11);
b.insert(15);
b.insert(20);
b.insert(17);
b.display();
}
}
```
```c
// insertioning a key on a B-tree in C
#include <stdio.h>
#include <stdlib.h>
#define MAX 3
#define MIN 2
struct btreeNode {
int item[MAX + 1], count;
struct btreeNode *link[MAX + 1];
};
struct btreeNode *root;
// Node creation
struct btreeNode *createNode(int item, struct btreeNode *child) {
struct btreeNode *newNode;
newNode = (struct btreeNode *)malloc(sizeof(struct btreeNode));
newNode->item[1] = item;
newNode->count = 1;
newNode->link[0] = root;
newNode->link[1] = child;
return newNode;
}
// Insert
void insertValue(int item, int pos, struct btreeNode *node,
struct btreeNode *child) {
int j = node->count;
while (j > pos) {
node->item[j + 1] = node->item[j];
node->link[j + 1] = node->link[j];
j--;
}
node->item[j + 1] = item;
node->link[j + 1] = child;
node->count++;
}
// Split node
void splitNode(int item, int *pval, int pos, struct btreeNode *node,
struct btreeNode *child, struct btreeNode **newNode) {
int median, j;
if (pos > MIN)
median = MIN + 1;
else
median = MIN;
*newNode = (struct btreeNode *)malloc(sizeof(struct btreeNode));
j = median + 1;
while (j <= MAX) {
(*newNode)->item[j - median] = node->item[j];
(*newNode)->link[j - median] = node->link[j];
j++;
}
node->count = median;
(*newNode)->count = MAX - median;
if (pos <= MIN) {
insertValue(item, pos, node, child);
} else {
insertValue(item, pos - median, *newNode, child);
}
*pval = node->item[node->count];
(*newNode)->link[0] = node->link[node->count];
node->count--;
}
// Set the value of node
int setNodeValue(int item, int *pval,
struct btreeNode *node, struct btreeNode **child) {
int pos;
if (!node) {
*pval = item;
*child = NULL;
return 1;
}
if (item < node->item[1]) {
pos = 0;
} else {
for (pos = node->count;
(item < node->item[pos] && pos > 1); pos--)
;
if (item == node->item[pos]) {
printf("Duplicates not allowed\n");
return 0;
}
}
if (setNodeValue(item, pval, node->link[pos], child)) {
if (node->count < MAX) {
insertValue(*pval, pos, node, *child);
} else {
splitNode(*pval, pval, pos, node, *child, child);
return 1;
}
}
return 0;
}
// Insert the value
void insertion(int item) {
int flag, i;
struct btreeNode *child;
flag = setNodeValue(item, &i, root, &child);
if (flag)
root = createNode(i, child);
}
// Copy the successor
void copySuccessor(struct btreeNode *myNode, int pos) {
struct btreeNode *dummy;
dummy = myNode->link[pos];
for (; dummy->link[0] != NULL;)
dummy = dummy->link[0];
myNode->item[pos] = dummy->item[1];
}
// Do rightshift
void rightShift(struct btreeNode *myNode, int pos) {
struct btreeNode *x = myNode->link[pos];
int j = x->count;
while (j > 0) {
x->item[j + 1] = x->item[j];
x->link[j + 1] = x->link[j];
}
x->item[1] = myNode->item[pos];
x->link[1] = x->link[0];
x->count++;
x = myNode->link[pos - 1];
myNode->item[pos] = x->item[x->count];
myNode->link[pos] = x->link[x->count];
x->count--;
return;
}
// Do leftshift
void leftShift(struct btreeNode *myNode, int pos) {
int j = 1;
struct btreeNode *x = myNode->link[pos - 1];
x->count++;
x->item[x->count] = myNode->item[pos];
x->link[x->count] = myNode->link[pos]->link[0];
x = myNode->link[pos];
myNode->item[pos] = x->item[1];
x->link[0] = x->link[1];
x->count--;
while (j <= x->count) {
x->item[j] = x->item[j + 1];
x->link[j] = x->link[j + 1];
j++;
}
return;
}
// Merge the nodes
void mergeNodes(struct btreeNode *myNode, int pos) {
int j = 1;
struct btreeNode *x1 = myNode->link[pos], *x2 = myNode->link[pos - 1];
x2->count++;
x2->item[x2->count] = myNode->item[pos];
x2->link[x2->count] = myNode->link[0];
while (j <= x1->count) {
x2->count++;
x2->item[x2->count] = x1->item[j];
x2->link[x2->count] = x1->link[j];
j++;
}
j = pos;
while (j < myNode->count) {
myNode->item[j] = myNode->item[j + 1];
myNode->link[j] = myNode->link[j + 1];
j++;
}
myNode->count--;
free(x1);
}
// Adjust the node
void adjustNode(struct btreeNode *myNode, int pos) {
if (!pos) {
if (myNode->link[1]->count > MIN) {
leftShift(myNode, 1);
} else {
mergeNodes(myNode, 1);
}
} else {
if (myNode->count != pos) {
if (myNode->link[pos - 1]->count > MIN) {
rightShift(myNode, pos);
} else {
if (myNode->link[pos + 1]->count > MIN) {
leftShift(myNode, pos + 1);
} else {
mergeNodes(myNode, pos);
}
}
} else {
if (myNode->link[pos - 1]->count > MIN)
rightShift(myNode, pos);
else
mergeNodes(myNode, pos);
}
}
}
// Traverse the tree
void traversal(struct btreeNode *myNode) {
int i;
if (myNode) {
for (i = 0; i < myNode->count; i++) {
traversal(myNode->link[i]);
printf("%d ", myNode->item[i + 1]);
}
traversal(myNode->link[i]);
}
}
int main() {
int item, ch;
insertion(8);
insertion(9);
insertion(10);
insertion(11);
insertion(15);
insertion(16);
insertion(17);
insertion(18);
insertion(20);
insertion(23);
traversal(root);
}
```
```cpp
// Inserting a key on a B-tree in C++
#include <iostream>
using namespace std;
class Node {
int *keys;
int t;
Node **C;
int n;
bool leaf;
public:
Node(int _t, bool _leaf);
void insertNonFull(int k);
void splitChild(int i, Node *y);
void traverse();
friend class BTree;
};
class BTree {
Node *root;
int t;
public:
BTree(int _t) {
root = NULL;
t = _t;
}
void traverse() {
if (root != NULL)
root->traverse();
}
void insert(int k);
};
Node::Node(int t1, bool leaf1) {
t = t1;
leaf = leaf1;
keys = new int[2 * t - 1];
C = new Node *[2 * t];
n = 0;
}
// Traverse the nodes
void Node::traverse() {
int i;
for (i = 0; i < n; i++) {
if (leaf == false)
C[i]->traverse();
cout << " " << keys[i];
}
if (leaf == false)
C[i]->traverse();
}
// Insert the node
void BTree::insert(int k) {
if (root == NULL) {
root = new Node(t, true);
root->keys[0] = k;
root->n = 1;
} else {
if (root->n == 2 * t - 1) {
Node *s = new Node(t, false);
s->C[0] = root;
s->splitChild(0, root);
int i = 0;
if (s->keys[0] < k)
i++;
s->C[i]->insertNonFull(k);
root = s;
} else
root->insertNonFull(k);
}
}
// Insert non full condition
void Node::insertNonFull(int k) {
int i = n - 1;
if (leaf == true) {
while (i >= 0 && keys[i] > k) {
keys[i + 1] = keys[i];
i--;
}
keys[i + 1] = k;
n = n + 1;
} else {
while (i >= 0 && keys[i] > k)
i--;
if (C[i + 1]->n == 2 * t - 1) {
splitChild(i + 1, C[i + 1]);
if (keys[i + 1] < k)
i++;
}
C[i + 1]->insertNonFull(k);
}
}
// split the child
void Node::splitChild(int i, Node *y) {
Node *z = new Node(y->t, y->leaf);
z->n = t - 1;
for (int j = 0; j < t - 1; j++)
z->keys[j] = y->keys[j + t];
if (y->leaf == false) {
for (int j = 0; j < t; j++)
z->C[j] = y->C[j + t];
}
y->n = t - 1;
for (int j = n; j >= i + 1; j--)
C[j + 1] = C[j];
C[i + 1] = z;
for (int j = n - 1; j >= i; j--)
keys[j + 1] = keys[j];
keys[i] = y->keys[t - 1];
n = n + 1;
}
int main() {
BTree t(3);
t.insert(8);
t.insert(9);
t.insert(10);
t.insert(11);
t.insert(15);
t.insert(16);
t.insert(17);
t.insert(18);
t.insert(20);
t.insert(23);
cout << "The B-tree is: ";
t.traverse();
}
```
- Programiz C 语言教程
- C 简介
- C 关键字和标识符
- C 变量，常量和字面值
- C 数据类型
- C 输入输出（I/O）
- C 编程运算符
- C 简单示例
- C 流程控制
- C if...else语句
- C for循环
- C while和do...while循环
- C break和continue
- C switch语句
- C goto声明
- C 控制流程示例
- C 函数
- C 函数
- C 用户定义的函数
- C 编程中用户定义函数的类型
- C 递归
- C 存储类
- C 函数示例
- C 数组
- C 数组
- C 多维数组
- 将数组传递给 C 中的函数
- C 编程指针
- C 指针
- 数组和指针之间的关系
- C 按引用调用：使用指针
- C 动态内存分配
- C 数组和指针示例
- C 字符串
- C 编程字符串
- 使用库函数进行 C 编程中的字符串操作
- C 编程中的字符串示例
- 结构与联合
- 结构
- 结构和指针
- C 结构与函数
- C 联合
- C 结构示例
- C 文件
- C 文件处理
- C 文件示例
- 其他主题
- 枚举
- C 预处理器和宏
- C 标准库函数
- C 示例
- C 程序：打印金字塔和图案
- C 程序：检查数字是否为质数
- C 程序：检查数字是否为回文
- C 程序：HelloWorld
- C 程序：打印整数（由用户输入）
- C 程序：相加两个整数
- C 程序：将两个浮点数相乘
- C 程序：查找字符的 ASCII 值
- C 程序：商和余数
- C 程序：查找int，float，double和char的大小
- C 程序：long关键字演示
- C 程序：交换两个数字
- C 程序：检查数字是偶数还是奇数
- C 程序：检查字符是元音还是辅音
- C 程序：查找三个数字中最大的数字
- C 程序：查找二次方程的根
- C 程序：检查闰年
- C 程序：检查数字是正数还是负数
- C 程序：检查字符是否为字母
- C 程序：计算自然数之和
- C 程序：查找数字阶乘
- C 程序：生成乘法表
- C 程序：显示斐波那契数列
- C 程序：查找两个数字的 GCD
- C 程序：查找两个数字的 LCM
- C 程序：使用循环从 A 到 Z 显示字符
- C 程序：计算整数中的位数
- C 程序：反转数字
- C 程序：计算数字的幂
- C 程序：显示两个间隔之间的质数
- C 程序：检查阿姆斯特朗数
- C 程序：在两个间隔之间显示阿姆斯特朗数
- C 程序：显示数字因数
- C 程序：使用switch...case制作一个简单的计算器
- C 程序：使用函数显示区间内的质数
- C 程序：使用用户定义的函数检查质数或阿姆斯特朗数
- C 程序：检查一个数字是否可以表示为两个质数之和
- C 程序：使用递归查找自然数之和
- C 程序：使用递归查找数字的阶乘
- C 程序：使用递归查找 GCD
- C 程序：将二进制数转换为十进制，反之亦然
- C 程序：将八进制数转换为十进制，反之亦然
- C 程序：将二进制数转换为八进制，反之亦然
- C 程序：使用递归来反转句子
- C 程序：使用递归计算幂
- C 程序：使用数组计算平均值
- C 程序：查找数组中的最大元素
- C 程序：计算标准差
- C 程序：使用多维数组相加两个矩阵
- C 程序：使用多维数组将两个矩阵相乘
- C 程序：查找矩阵的转置
- C 程序：通过将矩阵传递给函数来将两个矩阵相乘
- C 程序：使用指针访问数组元素
- C 程序：使用按引用调用以循环顺序交换数字
- C 程序：使用动态内存分配查找最大数字
- C 程序：查找字符串中字符的频率
- C 程序：计算元音，辅音等的数量
- C 程序：删除字符串中除字母之外的所有字符
- C 程序：查找字符串的长度
- C 程序：连接两个字符串
- C 程序：不使用strcpy()复制字符串
- C 程序：按字典顺序（字典顺序）对元素进行排序
- C 程序：使用程序存储学生信息
- C 程序：使用结构相加两个距离（以英寸-英尺系统为单位）
- C 程序：通过将结构传递给函数来相加两个复数
- C 程序：计算两个时间段之间的差异
- C 程序：使用结构存储学生信息
- C 程序：在结构中动态存储数据
- C 程序：将句子写入文件
- C 程序：从文件中读取一行并显示它
- C 程序：显示自己的源代码作为输出
- Programiz C++ 教程
- C++ 简介
- C++ 变量，文字和常量
- C++ 数据类型
- C++ 基本输入/输出
- C++ 类型转换
- C++ 运算符
- C++ 注释
- C++ 流控制
- C++ if，if...else和嵌套if...else
- C++ for循环
- C++ while和do...while循环
- C++ break语句
- C++ switch..case语句
- C++ goto语句
- C++ 函数
- C++ 函数
- C++ 中用户定义函数的类型
- C++ 函数重载
- C++ 编程默认参数（参数）
- C++ 存储类
- C++ 递归
- C++ 通过引用返回
- C++ 数组和字符串
- C++ 数组
- C++ 多维数组
- 在 C++ 编程中将数组传递给函数
- C++ 字符串
- C++ 结构
- C++ 结构
- C++ 结构与功能
- C++ 结构指针
- C++ 枚举
- C++ 对象和类
- C++ 类和对象
- C++ 构造器
- 如何通过 C++ 中的函数传递和返回对象？
- C++ 运算符重载
- C++ 指针
- C++ 指针
- C++ 指针和数组
- 通过引用进行 C++ 调用：使用指针[包含示例]
- C++ 内存管理：new和delete
- C++ 继承
- C++ 继承
- C++ 编程中的公共，受保护和私有继承
- C++ 函数覆盖
- C++ 多重，多层和层次继承
- C++ 友元函数和友元类
- C++ 虚函数
- C++ 模板
- C++ 示例
- C++ 程序：HelloWorld
- C++ 程序：检查数字是否为质数
- C++ 程序：创建金字塔和图案
- C++ 程序：加两个数字
- C++ 程序：打印用户输入的数字
- C++ 程序：查找商数和余数
- C++ 程序：在系统中查找int，float，double和char的大小
- C++ 程序：交换两个数字
- C++ 程序：检查数字是偶数还是奇数
- C++ 程序：检查字符是元音还是辅音
- C++ 程序：查找三个数字中最大的数字
- C++ 程序：查找二次方程式的所有根
- C++ 程序：计算自然数之和
- C++ 程序：检查闰年
- C++ 程序：查找阶乘
- C++ 程序：生成乘法表
- C++ 程序：显示斐波那契数列
- C++ 程序：查找 GCD
- C++ 程序：查找 LCM
- C++ 程序：反转数字
- C++ 程序：计算数字的幂
- C++ 程序：递增++和递减--运算符重载
- C++ 程序：使用运算符重载减去复数
- C++ 程序：查找字符的 ASCII 值
- C++ 程序：将两个数相乘
- C++ 程序：检查数字是否为回文
- C++ 程序：显示两个间隔之间的质数
- C++ 程序：检查阿姆斯特朗数
- C++ 程序：显示两个间隔之间的阿姆斯特朗数
- C++ 程序：显示数字的因数
- C++ 程序：使用switch...case的简单的加减乘除计算器
- C++ 程序：使用函数显示两个时间间隔之间的质数
- C++ 程序：通过创建函数来检查质数
- C++ 程序：检查数字是否可以表示为两个质数之和
- C++ 程序：使用递归查找自然数之和
- C++ 程序：使用递归计算数字的阶乘
- C++ 程序：使用递归查找 GCD
- C++ 程序：将二进制数转换为十进制，反之亦然
- C++ 程序：将八进制数转换为十进制，反之亦然
- C++ 程序：将二进制数转换为八进制，反之亦然
- C++ 程序：使用递归来反转句子
- C++ 程序：使用递归计算幂
- C++ 程序：使用数组计算数字平均值
- C++ 程序：查找数组的最大元素
- C++ 程序：计算标准差
- C++ 程序：使用多维数组相加两个矩阵
- C++ 程序：使用多维数组将两个矩阵相乘
- C++ 程序：查找矩阵的转置
- C++ 程序：通过将矩阵传递给函数将两个矩阵相乘
- C++ 程序：使用指针访问数组元素
- C++ 程序：使用引用调用以循环顺序交换数字
- C++ 程序：查找字符串中字符的频率
- C++ 程序：查找字符串中元音，辅音，数字和空白的数量
- C++ 程序：删除字符串中除字母之外的所有字符
- C++ 程序：查找字符串的长度
- C++ 程序：连接两个字符串
- C++ 程序：复制字符串
- C++ 程序：按字典顺序（字典顺序）对元素进行排序
- C++ 程序：在结构中存储学生的信息
- C++ 程序：使用结构相加两个距离（以英寸-英尺为单位）
- C++ 程序：通过将结构传递给函数来添加复数
- C++ 程序：计算两个时间段之间的差异
- C++ 程序：使用结构存储和显示信息
- Programiz C# 教程
- 简介
- C# Hello World - 您的第一个 C# 程序
- C# 关键字和标识符
- C# 变量和（原始）数据类型
- C# 运算符
- C# 基本输入和输出
- C# 表达式，语句和块（带有示例）
- C# 注释
- 流程控制
- C# if，if...else，if...else if和嵌套if语句
- C# for循环
- C# while和do...while循环
- C# foreach循环
- C# switch语句
- C# 三元（?:）运算符
- 其他话题
- C# 按位和移位运算符
- C# 预处理程序指令
- C# 编程中的命名空间
- C# 部分类和部分方法
- Programiz 数据结构和算法教程
- DSA 简介
- 什么是算法？
- 为什么要学习数据结构和算法？
- 渐近分析
- 主定理
- 分治算法
- 数据结构（一）
- 栈
- 队列
- 队列类型
- 循环队列
- 优先队列
- 双端队列
- 数据结构（二）
- 链表
- 链表操作：遍历，插入和删除
- 链表的类型 - 单链，双链和循环链
- 哈希表
- 堆数据结构
- 斐波那契堆
- 减小斐波那契堆上的键和删除节点的操作
- 基于树的 DSA（I）
- 树数据结构
- 树遍历 - 中序，前序和后序
- 满二叉树
- 满二叉树
- 完美二叉树
- 完全二叉树
- 平衡二叉树
- 二叉搜索树（BST）
- AVL 树
- 基于树的 DSA（II）
- B 树
- 插入 B 树
- 从 B 树删除
- B+ 树
- 在 B+ 树上插入
- 从 B+ 树中删除
- 红黑树
- 插入红黑树
- 从红黑树中删除
- 基于图的 DSA
- 图数据结构
- 生成树和最小生成树
- 强连通的组件
- 邻接矩阵
- 邻接表
- DFS 算法
- BFS 算法
- Bellman Ford 算法
- 排序和搜索算法
- 冒泡排序算法
- 选择排序算法
- 插入排序算法
- 归并排序算法
- 快速排序算法
- 计数排序算法
- 基数排序算法
- 桶排序算法
- 堆排序算法
- Shell 排序算法
- 线性搜索
- 二分搜索
- 贪婪算法
- 贪婪算法
- Ford-Fulkerson 算法
- Dijkstra 算法
- Kruskal 算法
- Prim 算法
- 霍夫曼编码
- 动态规划
- 动态规划
- Floyd-Warshall 算法
- 最长公共子序列
- 其他算法
- 回溯算法
- Rabin-Karp 算法
- Programiz Java 教程
- Java 简介
- Java HelloWorld 程序
- Java JDK，JRE 和 JVM
- Java 变量和（原始）数据类型
- Java 运算符
- Java 基本输入和输出
- Java 表达式，语句和块
- Java 注释
- Java 流程控制
- Java if，if...else语句
- Java switch语句
- Java for循环
- Java for-each循环（增强循环）
- Java while和do...while循环
- Java Break语句
- Java continue语句
- Java 数组
- Java 数组
- Java 多维数组
- Java 复制数组
- Java OOP（I）
- Java 类和对象
- Java 方法
- Java 构造器
- Java 字符串
- Java 访问修饰符
- Java this关键字
- Java final关键字
- Java 递归
- Java instanceof
- Java OOP（II）
- Java 继承
- Java 方法覆盖
- Java super
- Java 抽象类和抽象方法
- Java 接口
- Java 多态
- Java 封装
- Java OOP（III）
- Java 嵌套和内部类
- Java 静态嵌套类
- Java 匿名类
- Java 单例
- Java 枚举
- Java 枚举构造器
- Java 枚举字符串
- Java 反射
- Java 异常处理
- Java 异常
- Java 异常处理
- Java throw
- Java 捕获多个异常
- Java try-with-resources
- Java 注解
- Java 注解类型
- Java 日志
- Java 断言
- Java 列表
- Java 集合框架
- Java Collection接口
- Java List接口
- Java ArrayList类
- Java Vector
- Java Stack类
- Java 队列
- Java Queue接口
- Java PriorityQueue
- Java Deque接口
- Java LinkedList
- Java ArrayDeque
- Java BlockingQueue
- Java ArrayBlockingQueue
- Java LinkedBlockingQueue
- Java 映射
- Java Map接口
- Java HashMap
- Java LinkedHashMap
- Java WeakHashMap
- Java EnumMap
- Java SortedMap接口
- Java NavigableMap接口
- Java TreeMap
- Java ConcurrentMap接口
- Java ConcurrentHashMap
- Java 集
- Java Set接口
- Java HashSet类
- Java EnumSet
- Java LinkedHashSet
- Java SortedSet接口
- Java NavigableSet接口
- Java TreeSet
- Java 算法
- Java Iterator接口
- Java ListIterator接口
- Java I/O 流
- Java I/O 流
- Java InputStream类
- Java OutputStream类
- Java FileInputStream类
- Java FileOutputStream类
- Java ByteArrayInputStream类
- Java ByteArrayOutputStream类
- Java ObjectInputStream类
- Java ObjectOutputStream类
- Java BufferedInputStream类
- Java BufferedOutputStream类
- Java PrintStream类
- Java 读取器/写入器
- Java Reader类
- Java Writer类
- Java InputStreamReader类
- Java OutputStreamWriter类
- Java FileReader类
- Java FileWriter类
- Java BufferedReader类
- Java BufferedWriter类
- Java StringReader类
- Java StringWriter类
- Java PrintWriter类
- 其他主题
- Java Scanner类
- Java 类型转换
- Java 自动装箱和拆箱
- Java Lambda 表达式
- Java 泛型
- Java File类
- Java 包装器类
- Java 命令行参数
- Java 实例
- Java 程序：检查数字是否为质数
- Java 程序：显示斐波那契数列
- Java 程序：创建金字塔和图案
- Java 程序：反转数字
- Java 程序：打印整数（由用户输入）
- Java 程序：相加两个整数
- Java 程序：将两个浮点数相乘
- Java 程序：查找字符的 ASCII 值
- Java 程序：计算商数和余数
- Java 程序：交换两个数字
- Java 程序：检查数字是偶数还是奇数
- Java 程序：检查字母是元音还是辅音
- Java 程序：在三个数字中找到最大值
- Java 程序：查找二次方程式的所有根
- Java 程序：检查闰年
- Java 程序：检查数字是正数还是负数
- Java 程序：检查字符是否为字母
- Java 程序：计算自然数之和
- Java 程序：查找数字的阶乘
- Java 程序：生成乘法表
- Java 程序：显示斐波那契数列
- Java 程序：查找两个数字的 GCD
- Java 程序：查找两个数字的 LCM
- Java 程序：使用循环从 A 到 Z 显示字符
- Java 程序：计算整数的位数
- Java 程序：计算数字的幂
- Java 程序：检查数字是否为回文
- Java 程序：检查数字是否为质数
- Java 程序：显示两个时间间隔之间的质数
- Java 程序：检查阿姆斯特朗数
- Java 程序：显示两个间隔之间的阿姆斯特朗数
- Java 程序：使用函数显示间隔之间的质数
- Java 程序：使用函数显示间隔之间的阿姆斯特朗数
- Java 程序：以显示数字的因数
- Java 程序：使用switch...case创建一个简单的计算器
- Java 程序：检查一个数字是否可以表示为两个质数之和
- Java 程序：使用递归查找自然数之和
- Java 程序：使用递归查找数字的阶乘
- Java 程序：使用递归查找 GCD
- Java 程序：将二进制数转换为十进制，反之亦然
- Java 程序：将八进制数转换为十进制，反之亦然
- Java 程序：将二进制数转换为八进制，反之亦然
- Java 程序：使用递归来反转句子
- Java 程序：使用递归来计算幂
- Java 程序：使用数组计算平均值
- Java 程序：查找数组的最大元素
- Java 程序：计算标准差
- Java 程序：使用多维数组相加两个矩阵
- Java 程序：使用多维数组相乘矩阵
- Java 程序：通过将矩阵传递给函数来将两个矩阵相乘
- Java 程序：查找矩阵转置
- Java 程序：查找字符串中字符的频率
- Java 程序：计算句子中元音和辅音的数量
- Java 程序：按字典顺序对元素进行排序
- Java 程序：通过将对象传递给函数来相加两个复数
- Java 程序：计算两个时间段之间的差异
- Java 程序：从字符串中删除所有空格
- Java 程序：打印数组
- Java 程序：将字符串转换为日期
- Java 程序：将数字四舍五入到 n 个小数位
- Java 程序：连接两个数组
- Java 程序：将字符转换为字符串，反之亦然
- Java 程序：检查数组是否包含给定值
- Java 程序：检查字符串是否为空或null
- Java 程序：获取当前日期/时间
- Java 程序：将毫秒转换为分钟和秒
- Java 程序：相加两个日期
- Java 程序：连接两个列表
- Java 程序：将列表（ArrayList）转换为数组，反之亦然
- Java 程序：获取当前工作目录
- Java 程序：将映射（HashMap）转换为列表
- Java 程序：将数组转换为集（HashSet），反之亦然
- Java 程序：将字节数组转换为十六进制
- Java 程序：从文件内容创建字符串
- Java 程序：将文本附加到现有文件
- Java 程序：将栈跟踪转换为字符串
- Java 程序：将文件转换为字节数组，反之亦然
- Java 程序：将InputStream转换为字符串
- Java 程序：将OutputStream转换为字符串
- Java 程序：按字符串值查找枚举
- Java 程序：比较字符串
- Java 程序：按值对映射进行排序
- Java 程序：按属性对自定义对象的ArrayList进行排序
- Java 程序：检查字符串是否为数字
- Java 程序：创建目录
- Java 程序：重命名文件
- Java 程序：列出目录中的文件
- Java 程序：复制文件
- Programiz Kotlin 教程
- Kotlin 简介
- Kotlin HelloWorld - 您的 Kotlin 程序
- Kotlin 变量和原始类型
- Kotlin 运算符
- Kotlin 类型转换
- Kotlin 表达式，语句和块
- Kotlin 注释
- Kotlin 基本输入/输出
- Kotlin 流程控制
- Kotlin if表达式
- Kotlin when表达式
- Kotlin while和do...while循环
- Kotlin for循环
- Kotlin break表达式
- Kotlin continue表达式
- Kotlin 函数
- Kotlin 函数
- Kotlin 中缀函数调用
- Kotlin 默认和命名参数
- Kotlin 递归（递归函数）和尾递归
- Kotlin OOP
- Kotlin 类和对象
- Kotlin 构造器
- Kotlin 获取器和设置器
- Kotlin 继承
- Kotlin 可见性修饰符
- Kotlin 抽象类
- Kotlin 接口
- Kotlin 嵌套和内部类
- Kotlin 数据类
- Kotlin 密封类
- Kotlin 对象声明和表达式
- Kotlin 伴随对象
- Kotlin 扩展函数
- Kotlin 运算符重载
- Kotlin 示例
- Kotlin 程序：获取当前日期/时间
- Kotlin 程序：将列表（ArrayList）转换为Array，反之亦然
- Kotlin 程序：将字符串转换为日期
- Kotlin 程序：按属性对自定义对象的ArrayList进行排序
- Kotlin 程序：打印整数（由用户输入）
- Kotlin 程序：相加两个整数
- Kotlin 程序：将两个浮点数相乘
- Kotlin 程序：查找字符的 ASCII 值
- Kotlin 程序：计算商数和余数
- Kotlin 程序：交换两个数字
- Kotlin 程序：检查数字是偶数还是奇数
- Kotlin 程序：检查字母是元音还是辅音
- Kotlin 程序：在三个数字中找到最大的一个
- Kotlin 程序：查找二次方程的所有根
- Kotlin 程序：检查闰年
- Kotlin 程序：检查数字是正数还是负数
- Kotlin 程序：检查字符是否为字母
- Kotlin 程序：计算自然数之和
- Kotlin 程序：查找数字的阶乘
- Kotlin 程序：生成乘法表
- Kotlin 程序：展示斐波那契数列
- Kotlin 程序：查找两个数字的 GCD
- Kotlin 程序：查找两个数字的 LCM
- Kotlin 程序：使用循环从 A 到 Z 显示字符
- Kotlin 程序：计算整数位数
- Kotlin 程序：反转数字
- Kotlin 程序：计算数字的幂
- Kotlin 程序：检查数字是否为回文
- Kotlin 程序：检查数字是否为质数
- Kotlin 程序：显示两个间隔之间的质数
- Kotlin 程序：检查阿姆斯特朗数
- Kotlin 程序：显示两个间隔之间的阿姆斯特朗数
- Kotlin 程序：使用函数显示间隔之间的质数
- Kotlin 程序：使用函数显示间隔之间的阿姆斯特朗数
- Kotlin 程序：显示数字因数
- Kotlin 程序：使用switch...case制作一个简单的计算器
- Kotlin 程序：检查一个数字是否可以表示为两个质数之和
- Kotlin 程序：使用递归找到自然数之和
- Kotlin 程序：使用递归查找数字的阶乘
- Kotlin 程序：使用递归查找 GCD
- Kotlin 程序：将二进制数转换为十进制，反之亦然
- Kotlin 程序：将八进制数转换为十进制，反之亦然
- Kotlin 程序：将二进制数转换为八进制，反之亦然
- Kotlin 程序：使用递归来反转句子
- Kotlin 程序：使用递归来计算幂
- Kotlin 程序：使用数组计算平均值
- Kotlin 程序：在数组中查找最大的元素
- Kotlin 程序：计算标准差
- Kotlin 程序：使用多维数组相加两个矩阵
- Kotlin 程序：使用多维数组乘以矩阵
- Kotlin 程序：通过将矩阵传递给函数来将两个矩阵相乘
- Kotlin 程序：查找矩阵的转置
- Kotlin 程序：查找字符串中字符的频率
- Kotlin 程序：计算句子中元音和辅音的数量
- Kotlin 程序：按字典顺序（字典顺序）对元素进行排序
- Kotlin 程序：通过将类传递给函数来相加两个复数
- Kotlin 程序：计算两个时间段之间的差异
- Kotlin 程序：创建金字塔和图案
- Kotlin 程序：从字符串中删除所有空格
- Kotlin 程序：打印数组
- Kotlin 程序：将数字四舍五入到 n 个小数位
- Kotlin 程序：连接两个数组
- Kotlin 程序：将字符转换为字符串并反之
- Kotlin 程序：检查数组是否包含给定值
- Kotlin 程序：检查字符串是否为空或null
- Kotlin 程序：将毫秒转换为分钟
- Kotlin 程序：相加两个日期
- Kotlin 程序：连接两个列表
- Kotlin 程序：获取当前工作目录
- Kotlin 程序：将映射（HashMap）转换为列表
- Kotlin 程序：将数组转换为Set（HashSet），反之亦然
- Kotlin 程序：将字节数组转换为十六进制
- Kotlin 程序：从文件内容创建字符串
- Kotlin 程序：将文本附加到现有文件
- Kotlin 程序：将栈跟踪转换为字符串
- Kotlin 程序：将文件转换为字节数组，反之亦然
- Kotlin 程序：将InputStream转换为字符串
- Kotlin 程序：将OutputStream转换为字符串
- Kotlin 程序：通过字符串值查找枚举
- Kotlin 程序：比较字符串
- Kotlin 程序：按值对映射排序
- Kotlin 程序：检查字符串是否为数字
- Programiz Python 教程
- Python 简介
- 如何开始使用 Python？
- Python 关键字和标识符
- Python 语句，缩进和注释
- Python 变量，常量和字面值
- Python 数据类型
- Python 类型转换
- Python 输入，输出和导入
- Python 运算符
- Python 命名空间和范围
- Python 流程控制
- Python if...else语句
- Python for循环
- Python While循环
- Python break和continue
- Python pass语句
- Python 函数
- Python 函数
- Python 函数参数
- Python 递归
- Python 匿名/ Lambda 函数
- Python 全局，局部和非局部变量
- Python global关键字
- Python 模块
- Python 包
- Python 数据类型
- Python 数字，类型转换和数学
- Python 列表
- Python 元组
- Python 字符串
- Python 集
- Python 字典
- Python 文件
- Python 文件 I/O
- Python 目录和文件管理
- Python 错误和内置异常
- Python 使用try，except和finally语句的异常处理
- Python 自定义异常
- Python 对象和类
- Python 面向对象编程
- Python 对象和类
- Python 继承
- Python 多重继承
- Python 运算符重载
- Python 高级主题
- Python 迭代器
- Python 生成器
- Python 闭包
- Python 装饰器
- Python @property装饰器
- Python 正则表达式
- Python 日期时间
- Python 日期时间
- Python strftime()
- Python strptime()
- 如何在 Python 中获取当前日期和时间？
- Python 获取当前时间
- Python 日期时间到时间戳，反之亦然
- Python time模块
- Python sleep()
- Python 示例
- Python 程序：检查质数
- Python 程序：相加两个数字
- Python 程序：查找数字阶乘
- Python 程序：制作一个简单的计算器
- Python 程序：打印 Helloworld
- Python 程序：查找平方根
- Python 程序：计算三角形的面积
- Python 程序：求解二次方程式
- Python 程序：交换两个变量
- Python 程序：生成随机数
- Python 程序：将公里转换为英里
- Python 程序：将摄氏温度转换为华氏温度
- Python 程序：检查数字是正数，负数还是 0
- Python 程序：检查数字是奇数还是偶数
- Python 程序：检查闰年
- Python 程序：在三个数字中找到最大的
- Python 程序：检查质数
- Python 程序：打印一个间隔内的所有质数
- Python 程序：查找数字阶乘
- Python 程序：显示乘法表
- Python 程序：打印斐波那契序列
- Python 程序：检查阿姆斯特朗数
- Python 程序：查找间隔内的阿姆斯特朗数
- Python 程序：查找自然数总和
- Python 程序：使用匿名函数显示 2 的幂
- Python 程序：查找可被另一个数整除的数字
- Python 程序：将十进制转换为二进制，八进制和十六进制
- Python 程序：查找字符的 ASCII 值
- Python 程序：查找 HCF 或 GCD
- Python 程序：查找 LCM
- Python 程序：查找数字的因数
- Python 程序：制作一个简单的计算器
- Python 程序：打乱纸牌
- Python 程序：显示日历
- Python 程序：使用递归显示斐波那契数列
- Python 程序：使用递归查找自然数之和
- Python 程序：使用递归查找数字的阶乘
- Python 程序：使用递归将十进制转换为二进制
- Python 程序：相加两个矩阵
- Python 程序：转置矩阵
- Python 程序：将两个矩阵相乘
- Python 程序：检查字符串是否为回文
- Python 程序：从字符串中删除标点符号
- Python 程序：按字母顺序对单词进行排序
- Python 程序：演示不同的集合操作
- Python 程序：计算每个元音的数量
- Python 程序：合并邮件
- Python 程序：查找图像的大小（分辨率）
- Python 程序：查找文件哈希
- Programiz Swift 教程
- Swift 介绍
- Swift HelloWorld 程序
- Swift 变量，常量和字面值
- Swift 数据类型
- Swift 可选项
- Swift 的字符和字符串
- Swift 基本输入和输出
- Swift 表达式，语句和代码块
- Swift 注释
- Swift 运算符
- Swift 运算符
- Swift 运算符的优先级和关联性
- Swift 三元条件运算符
- Swift 按位和移位运算符
- Seift 流程控制
- Swift if，if...else语句
- switch语句
- Swift for-in循环
- Swift while和repeat...while循环
- Swift 中的嵌套循环
- break语句
- continue语句
- Guard语句
- Swift 集合
- Swift 数组
- Swift 集
- Swift 字典
- Swift 函数
- Swift 函数
- Swift 函数参数和返回值
- Swift 嵌套函数
- Swift 递归
- Swift 范围
- Swift 函数重载
- Swift 进阶
- Swift 闭包
- Swift 类型别名