C语言数据结构之二叉树详解

 更新时间:2022年03月10日 11:12:12   作者:清欢有道  
二叉树(Binary tree)是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式。本文将通过示例详细讲解一下二叉树,需要的可以参考一下

脚本之家 / 编程助手:解决程序员“几乎”所有问题!
脚本之家官方知识库 → 点击立即使用

1. 树概念及结构

1.1树概念

树是一种非线性的数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。

  • 根结点:根节点没有前驱结点。
  • 除根节点外,其余结点被分成是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱,可以有0个或多个后继。
  • 因此,树是递归定义的。

  1. 节点的度:一个节点含有的子树的个数称为该节点的度; 如上图:A的为2
  2. 叶节点:度为0的节点称为叶节点; 如上图:G、H、I节点为叶节点
  3. 非终端节点或分支节点:度不为0的节点; 如上图:B、D、C、E、F节点为分支节点
  4. 双亲节点或父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点; 如上图:A是B的父节点
  5. 孩子节点或子节点:一个节点含有的子树的根节点称为该节点的子节点; 如上图:B是A的孩子节点
  6. 兄弟节点:具有相同父节点的节点互称为兄弟节点; 如上图:B、C是兄弟节点
  7. 树的度:一棵树中,最大的节点的度称为树的度; 如上图:树的度为2
  8. 节点的层次:从根开始定义起,根为第1层,根的子节点为第2层,以此类推;
  9. 树的高度或深度:树中节点的最大层次; 如上图:树的高度为4
  10. 堂兄弟节点:双亲在同一层的节点互为堂兄弟;如上图:H、I互为兄弟节点
  11. 节点的祖先:从根到该节点所经分支上的所有节点;如上图:A是所有节点的祖先
  12. 子孙:以某节点为根的子树中任一节点都称为该节点的子孙。如上图:所有节点都是A的子孙
  13. 森林:由m棵互不相交的树的集合称为森林;

1.2树的表示

树结构相对线性表就比较复杂了,要存储表示起来就比较麻烦了,实际中树有很多种表示方式,如:双亲表示法,孩子表示法、孩子兄弟表示法等等。我们这里就简单的了解其中最常用的孩子兄弟表示法。

1
2
3
4
5
6
7
typedef int DataType;
struct Node
{
     struct Node* firstChild1;
     struct Node* pNextBrother;
     DataType data;
};

2. 二叉树概念及结构

2.1概念

一棵二叉树是结点的一个有限集合,该集合或者为空,或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。

二叉树的特点:

  • 每个结点最多有两棵子树,即二叉树不存在度大于2的结点。
  • 二叉树的子树有左右之分,其子树的次序不能颠倒。

2.2数据结构中的二叉树

2.3特殊的二叉树

满二叉树:一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是(2^k) -1 ,则它就是满二叉树。

完全二叉树:完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

2.4二叉树的存储结构

二叉树一般可以使用两种存储结构,一种顺序结构,一种链式结构。

2.4.1顺序存储

顺序结构存储就是使用数组来存储,一般使用数组只适合表示完全二叉树,因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储。二叉树顺序存储在物理上是一个数组,在逻辑上是一颗二叉树。

2.4.2链式存储

二叉树的链式存储结构是指,用链表来表示一棵二叉树,即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成,数据域和左右指针域,左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链,当前我们学习中一般都是二叉链,后面课程学到高阶数据结构如红黑树等会用到三叉链。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 二叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}
// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
};

2.5二叉树的性质

  • 若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
  • 若规定根节点的层数为1,则深度为h的二叉树的最大结点数是2^h- 1.
  • 对任何一棵二叉树, 如果度为0其叶结点个数为 n0, 度为2的分支结点个数为 n2,则有n0=n2+1
  • 若规定根节点的层数为1,具有n个结点的满二叉树的深度,h=Log2(n+1). (ps:Log2(n+1)是log以2为
  • 底,n+1为对数)
  • 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的数组顺序对所有节点从0开始编号,则对于序号为i的结点有:

1. 若i>0,i位置节点的双亲序号:(i-1)/2;i=0,i为根节点编号,无双亲节点

2. 若2i+1<n,左孩子序号:2i+1,2i+1>=n否则无左孩子

3. 若2i+2<n,右孩子序号:2i+2,2i+2>=n否则无右孩子

3. 二叉树顺序结构及概念

3.1二叉树的顺序结构

普通的二叉树是不适合用数组来存储的,因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储,需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。

3.2堆的概念及结构

如果有一个关键码的集合K = {k0,k1, k2,…,kn-1},把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中,并满足:Ki <= K2i+1 且 Ki<= K2i+2 (Ki >= K2i+1 且 Ki >= K2i+2) i = 0,1,2…,则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆,根节点最小的堆叫做最小堆或小根堆。

堆的性质:

  • 堆中某个节点的值总是不大于或不小于其父节点的值;
  • 堆总是一棵完全二叉树。

3.3堆的实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
typedef int HPDataType;
typedef struct Heap
{
    HPDataType* _a;
    int _size;
    int _capacity;
}Heap;
 
void swap(int *a, int *b);
void AdjustDown(int *a, int parent, int n);
void AdjustUp(int *a, int child, int n);
 
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n);
// 堆的销毁
void HeapDestory(Heap* hp);
// 堆的插入
void HeapPush(Heap* hp, HPDataType x);
// 堆的删除
void HeapPop(Heap* hp);
// 取堆顶的数据
HPDataType HeapTop(Heap* hp);
// 堆的数据个数
int HeapSize(Heap* hp);
// 堆的判空
int HeapEmpty(Heap* hp);
 
// 对数组进行堆排序
void HeapSort(int* a, int n);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
void swap(int *a, int *b)
{
    int tmp = *a;
    *a = *b;
    *b = tmp;
}
 
void AdjustUp(int *a, int child, int n)
{
    int parent = (child - 1) / 2;
    while (child > 0)
    {
        if (a[child] > a[parent])
        {
            swap(&a[child], &a[parent]);
            child = parent;
            parent = (child - 1) / 2;
        }
        else
        {
            break;
        }
    }
}
 
void AdjustDown(int *a, int parent,int n)
{
    int child = parent * 2 + 1;
    while ( child < n)
    {
        if (child + 1 < n && a[child]<a[child + 1])
        {
            ++child;
        }
        if(a[child]>a[parent])
        {
            swap(&a[child], &a[parent]);
            parent = child;
            child = (parent * 2) + 1;
        }
        else
        {
            break;
        }
    }
}
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
    assert(hp);
    hp->_a = (HPDataType*)malloc(sizeof(HPDataType)*n);
    if (hp->_a == NULL)
    {
        printf("malloc fail");
        exit(-1);
    }
    for (int i = 0; i < n; ++i)
    {
        hp->_a[i] = a[i];
    }
    hp->_size = hp->_capacity = n;
    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        AdjustDown(hp->_a,i, hp->_size);
    }
}
 
// 堆的销毁
void HeapDestory(Heap* hp)
{
    assert(hp);
    hp->_size = hp->_capacity = 0;
    free(hp);
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
    assert(hp);
    if (hp->_size == hp->_capacity)
    {
        HPDataType* tmp = (HPDataType*)realloc(hp->_a, sizeof(HPDataType)* 2 * hp->_capacity);
        if (tmp == NULL)
        {
            printf("realloc fail");
            exit(-1);
        }
        hp->_a = tmp;
        hp->_a[hp->_size] = x;
        ++hp->_size;
        hp->_capacity *= 2;
    }
    else
    {
        hp->_a[hp->_size] = x;
        ++hp->_size;
    }
    AdjustUp(hp->_a, hp->_size-1, hp->_size);
 
}
// 堆的删除
void HeapPop(Heap* hp)
{
    assert(hp);
    assert(hp->_size>0);
    swap(&hp->_a[hp->_size-1], &hp->_a[0]);
    --hp->_size;
    AdjustDown(hp->_a, 0, hp->_size);
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
    assert(hp);
    assert(hp->_size>0);
    return hp->_a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
    assert(hp);
    return hp->_size;
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
    assert(hp);
    return hp->_size == 0 ? 1 : 0;
 
    for (int i = 0; i < 3; ++i)}
 
// 对数组进行堆排序
void HeapSort(int* a, int n)
{
    assert(a);
    for (int i = (n - 2) / 2; i >= 0; --i)
    {
        AdjustDown(a, i, n);
    }
    int end = n - 1;
    while (end > 0)
    {
        swap(&a[0], &a[end]);
        AdjustDown(a, 0, end);
        --end;
    }
}

4. 二叉树链式结构及实现

4.1二叉树链式结构的遍历

所谓遍历(Traversal)是指沿着某条搜索路线,依次对树中每个结点均做一次且仅做一次访问。访问结点所做的操作依赖于具体的应用问 题。 遍历是二叉树上最重要的运算之一,是二叉树上进行其它运算之基础。

前序/中序/后序的递归结构遍历:是根据访问结点操作发生位置命名

NLR:前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。

LNR:中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中(间)。

LRN:后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

由于被访问的结点必是某子树的根,所以N(Node)、L(Left subtree)和R(Right subtree)又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

层序遍历:除了先序遍历、中序遍历、后序遍历外,还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1,层序遍历就是从所在二叉树的根节点出发,首先访问第一层的树根节点,然后从左到右访问第2层上的节点,接着是第三层的节点,以此类推,自上而下,自左至右逐层访问树的结点的过程就是层序遍历。

4.2二叉树的链式实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
typedef char BTDataType;
 
typedef struct BinaryTreeNode
{
    BTDataType _data;
    struct BinaryTreeNode* _left;
    struct BinaryTreeNode* _right;
}BTNode;
 
 
 
 
typedef BTNode* QDataType;
// 链式结构:表示队列
typedef struct QListNode
{
    struct QListNode* _next;
    QDataType _data;
}QNode;
 
// 队列的结构
typedef struct Queue
{
    QNode* _front;
    QNode* _rear;
}Queue;
 
 
 
 
BTNode* CreateBTNode(BTDataType x);
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
 
 
 
// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);
 
 
 
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
// 初始化队列
void QueueInit(Queue* q)
{
    assert(q);
    q->_front = q->_rear = NULL;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
    assert(q);
    QNode *newnode = ((QNode*)malloc(sizeof(QNode)));
    newnode->_data = data;
    newnode->_next = NULL;
    if (q->_rear == NULL)
    {
        q->_front = q->_rear = newnode;
    }
    else
    {
        q->_rear->_next = newnode;
        //q->_rear = q->_rear->_next;
        q->_rear = newnode;
    }
}
// 队头出队列
void QueuePop(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    if (q->_front == q->_rear)
    {
        free(q->_front);
        //free(q->_rear);
        q->_front = q->_rear = NULL;
    }
    else
    {
        QNode *cur = q->_front->_next;
        free(q->_front);
        q->_front = cur;
    }
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    return q->_front->_data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
    assert(q);
    assert(!QueueEmpty(q));
    return q->_rear->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
    assert(q);
    int size = 0;
    QNode* cur = q->_front;
    while (cur)
    {
        ++size;
        cur = cur->_next;
    }
    return size;
}
// 检测队列是否为空,如果为空返回非零结果,如果非空返回0
int QueueEmpty(Queue* q)
{
    assert(q);
    return q->_front == NULL ? 1 : 0;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
    assert(q);
    QNode *cur = q->_front;
    while (cur)
    {
        QNode *next = cur->_next;
        free(cur);
        cur = next;
    }
    q->_front = q->_rear = NULL;
}
 
 
 
 
 
 
BTNode* CreateBTNode(BTDataType x)
{
    BTNode *node = (BTNode*)malloc(sizeof(BTNode));
    node->_data = x;
    node->_left = NULL;
    node->_right = NULL;
    return node;
}
 
 
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
    if (a[*pi] == '#')
    {
        return NULL;
    }
    BTNode *node = (BTNode*)malloc(sizeof(BTNode));
    node->_data = a[*pi];
    ++*pi;
    node->_left = BinaryTreeCreate(a, n, pi);
    ++*pi;
    node->_right = BinaryTreeCreate(a, n, pi);
    return node;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode** root)
{
    if (*root != NULL)
    {
        if ((*root)->_left) // 有左孩子
            BinaryTreeDestory(&(*root)->_left); // 销毁左孩子子树
        if ((*root)->_right) // 有右孩子
            BinaryTreeDestory(&(*root)->_right); // 销毁右孩子子树
 
        free(*root); // 释放根结点
        *root = NULL; // 空指针赋NULL
    }
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
    if (root == NULL)
    {
        return 0;
    }
    if (root->_left == NULL&&root->_right == NULL)
    {
        return 1;
    }
    return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
    if (root == NULL)
    {
        return 0;
    }
    if (k == 1)
    {
        return 1;
    }
    return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
    if (root == NULL)
    {
        return NULL;
    }
    if (root->_data == x)
    {
        return root;
    }
    BTNode* ret=BinaryTreeFind(root->_left,x);
    if (ret != NULL)
    {
        return ret;
    }
    ret = BinaryTreeFind(root->_right, x);
    if (ret != NULL)
    {
        return ret;
    }
    return NULL;
}
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
    if (root == NULL)
    {
        //printf("NULL  ");
        return;
    }
    printf("%c  ", root->_data);
    BinaryTreePrevOrder(root->_left);
    BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
    if (root == NULL)
    {
        //printf("NULL  ");
        return;
    }
    BinaryTreeInOrder(root->_left);
    printf("%c  ", root->_data);
    BinaryTreeInOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
    if (root == NULL)
    {
        //printf("NULL  ");
        return;
    }
    BinaryTreePostOrder(root->_left);
    BinaryTreePostOrder(root->_right);
    printf("%c  ", root->_data);
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q, root);
    }
    while (!QueueEmpty(&q))
    {
        BTNode *front = QueueFront(&q);
        QueuePop(&q);
        printf("%c  ", front->_data);
        if (front->_left)
        {
            QueuePush(&q, front->_left);
        }
        if (front->_right)
        {
            QueuePush(&q, front->_right);
        }
    }
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q, root);
    }
    while (!QueueEmpty(&q))
    {
        BTNode *front = QueueFront(&q);
        QueuePop(&q);
        if (front == NULL)
        {
            break;
        }
        printf("%s ", front->_data);
        if (front->_left)
        {
            QueuePush(&q, front->_left);
        }
        if (front->_right)
        {
            QueuePush(&q, front->_right);
        }
    }
    while (!QueueEmpty(&q))
    {
        BTNode *front = QueueFront(&q);
        QueuePop(&q);
        if (front != NULL)
        {
            return 0;
        }
    }
    return 1;
 
}

到此这篇关于C语言数据结构之二叉树详解的文章就介绍到这了,更多相关C语言二叉树内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家!

蓄力AI

微信公众号搜索 “ 脚本之家 ” ,选择关注

程序猿的那些事、送书等活动等着你

原文链接:https://blog.csdn.net/weixin_45796387/article/details/114994648

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若内容造成侵权/违法违规/事实不符,请将相关资料发送至 reterry123@163.com 进行投诉反馈,一经查实,立即处理!

相关文章

  • c语言算术运算符越界问题解决方案

    c语言算术运算符越界问题解决方案

    大量的安全漏洞是由于计算机算术运算的微妙细节引起的, 具体的C语言, 诸如符号数和无符号数之间转换, 算术运算的越界都会导致不可预知的错误和安全漏洞, 具体的案例数不胜数.
    2012-11-11
  • 关于STL的erase()陷阱-迭代器失效问题的总结

    关于STL的erase()陷阱-迭代器失效问题的总结

    下面小编就为大家带来一篇关于STL的erase()陷阱-迭代器失效问题的总结。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
    2016-12-12
  • C++运算符重载的详细讲解

    C++运算符重载的详细讲解

    这篇文章主要给大家介绍了关于C++运算符重载的相关资料,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
    2021-04-04
  • C语言二维数组中的查找的实例

    C语言二维数组中的查找的实例

    这篇文章主要介绍了C语言二维数组中的查找的实例的相关资料,需要的朋友可以参考下
    2017-07-07
  • Qt利用QChart实现实时波形图的绘制

    Qt利用QChart实现实时波形图的绘制

    这篇文章主要介绍了Qt如何利用QChart实现实时波形图的绘制,文中的示例代码讲解详细,对我们学习有一定是参考价值,需要的可以参考一下
    2022-06-06
  • DSP中浮点转定点运算--浮点数的存储格式

    DSP中浮点转定点运算--浮点数的存储格式

    本文主要介绍DSP中浮点数的存储格式,很值得学习一下,需要的朋友可以参考一下。
    2016-06-06
  • CMakeList中自动编译protobuf文件过程

    CMakeList中自动编译protobuf文件过程

    这篇文章主要介绍了CMakeList中自动编译protobuf文件过程,具有很好的参考价值,希望对大家有所帮助。如有错误或未考虑完全的地方,望不吝赐教
    2022-12-12
  • C语言通讯录实例分享

    C语言通讯录实例分享

    这篇文章主要为大家分享了C语言通讯录实例,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2018-02-02
  • C++图文并茂分析讲解模板

    C++图文并茂分析讲解模板

    C++语言的模板技术包括函数模板和类模板,模板技术是一种代码重用技术,函数和类是C++语言中两种主要的重用代码形式,这篇文章主要介绍了C++函数模板和类模板,需要的朋友可以参考下
    2022-09-09
  • Qt自定义控件实现简易仪表盘

    Qt自定义控件实现简易仪表盘

    这篇文章主要为大家详细介绍了Qt自定义控件实现简易仪表盘,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
    2019-12-12

最新评论