目次
1.二分木
1. 二分木の概念と構造
1.1. ツリーの概念
ツリーは非線形データ構造であり、階層関係を持つ n 個の限定されたノードの集合です。その構造が木を逆さにしたような形をしていることからツリーと呼ばれています。以下に示すように:
木には次の特性があります。
(1) ツリーにはルート ノードと呼ばれる特別なノードがあり、ルート ノードには先行ノードがありません。
(2) ルート ノードを除く残りのノードは複数の素な集合に分割され、各集合は木と同様の構造を持つ部分木になります。各サブツリーのルート ノードには先行ノードが 1 つだけあり、複数の後続ノードを持つことができます。
(3) ツリー構造では、サブツリー間の交差があってはなりません。交差しないと、ツリー構造になりません。
(4). ツリーは再帰的に定義されます。
1.2. 二分木の概念
バイナリ ツリーは特別なツリー構造です。バイナリ ツリーの各ノードには最大 2 つの後続ノードがあり、左右のノードに分割できます。順序を逆にすることはできません。順序付きツリーです。バイナリ ツリーは、ルート ノード、ルート ノードの左側のサブツリー、およびルート ノードの右側のサブツリーの 3 つの部分で構成されます。
2 つの特別なバイナリ ツリー:
（１）完全二分木：二分木の各レベルのノードが最大値に達しており、この二分木は完全二分木である。つまり、二分木のレベル数が k で、要約点の数が 2^k-1 であれば、それは完全な二分木になります。
(2) 完全二分木: 二分木の最後の層を除く他のすべての層は完全二分木の性質に準拠しており、最後の層は左から右に連続しており、完全な二分木です。完全なバイナリ ツリーは、特別な種類の完全なバイナリ ツリーです。
1.3. バイナリツリーの記憶構造
バイナリ ツリーは通常、データ ストレージに 2 つの構造を使用できます。1 つはシーケンシャル構造、もう 1 つはチェーン構造です。
1.3.1. シーケンシャル構造のストレージ
シーケンシャル構造ストレージでは、ストレージに配列を使用します。不完全なバイナリ ツリー データを格納するためにシーケンシャル ストレージを使用すると領域の無駄が発生するため、この格納方法は完全なバイナリ ツリーにのみ適しています。実際のアプリケーションではシーケンシャル ストレージを使用するのはヒープのみですが、ヒープの内容については次のセクションで説明するため、ここでは紹介しません。
typedef struct Heap
{
HPDataType* a; //指向动态开辟的数组的指针
int size; //存储的数据个数
int capacity; //数组的容量
}Heap;
1.3.2. チェーン構造のストレージ
バイナリ ツリーのリンク ストレージとは、リンク リストを使用して要素間の論理関係を表すことを指します。通常の方法では、リンク リストの各ノードは、データ フィールドと 2 つの左右のポインタ フィールドの 3 つの部分で構成されます。左ポインタと右ポインタは、リンク リストの左の子ノードと右の子ノードのアドレスを格納するために使用されます。それぞれノード。
typedef struct BinaryTreeNode
{
BTDataType data; //该节点存储的数据
struct BinaryTreeNode* left; //指向左孩子节点
struct BinaryTreeNode* right; //指向右孩子节点
}BTNode;
2. バイナリーツリー（チェーン構造）の実装
2.1. バイナリツリートラバーサル
バイナリ ツリー トラバーサルとは、ある特定のルールに従ってバイナリ ツリー内のノードに対して対応する操作を順番に実行することを指し、各ノードは 1 回だけ操作されます。トラバーサルは、バイナリ ツリーに対する他の操作の基礎となります。
2.1.1. 事前順序、順序どおり、および順序後の走査
(1) 事前順序トラバーサル: ルート ノードにアクセスする操作は、その左右のサブツリーをトラバースする前に発生します。
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
printf("%c", root->data);
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(root->right);
}(2) 順序トラバーサル: ルート ノードにアクセスする操作は、その左右のサブツリーをトラバースする間に発生します。
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreePrevOrder(root->left);
printf("%c", root->data);
BinaryTreePrevOrder(root->right);
}(3) 事後トラバーサル: ルート ノードにアクセスする操作は、その左右のサブツリーをトラバースした後に発生します。
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(root->right);
printf("%c", root->data);
}再帰的走査プロセスをグラフィカルに分析するには、事前順序走査を例として取り上げます。
2.1.2. レイヤー順序のトラバーサル
プレオーダー、インオーダー、ポストオーダーのトラバーサルとは異なり、レベルオーダーのトラバーサルはツリーを上から下にトラバースします (つまり、ルート ノードが配置されている最初のレベルから開始して、レイヤーごとに下にアクセスします)。 、同じレイヤーを左から順に訪問して、ツリーのノードにアクセスするプロセスです。
(コード内で呼び出される関数については、この記事の次のセクションで説明します)
// 层序遍历
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);
}
}
printf("\n");
QueueDestroy(&q);
}走査プロセスは次のようになります。
2.2. バイナリツリーチェーン構造のコード実装
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
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;
int size;
}Queue;
// 初始化队列
void QueueInit(Queue* q)
{
assert(q);
q->front = q->rear = NULL;
q->size = 0;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
assert(q);
return q->size == 0 ? 1 : 0;
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->front->data;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
assert(q);
QNode* NewNode = (QNode*)malloc(sizeof(QNode));
if (NewNode == NULL)
{
perror("malloc:");
return;
}
NewNode->data = data;
NewNode->next = NULL;
if (q->size == 0)
{
q->front = q->rear = NewNode;
}
else
{
q->rear->next = NewNode;
q->rear = q->rear->next;
}
q->size++;
}
// 队头出队列
void QueuePop(Queue* q)
{
assert(q);
//assert(!QueueEmpty(q));
if (q->front == q->rear)
{
if (q->front == NULL)
{
return;
}
else
{
free(q->front);
q->front = q->rear = NULL;
}
}
else
{
QNode* Tmp = q->front;
q->front = Tmp->next;
free(Tmp);
Tmp = NULL;
}
q->size--;
}
// 销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
if (q->size != 0)
{
free(q->front);
free(q->rear);
q->front = q->rear = NULL;
}
}
//创建节点
BTNode* BuyNode(BTDataType x)
{
BTNode* Node = (BTNode*)malloc(sizeof(BTNode));
if (Node == NULL)
{
perror("BuyNode::malloc:");
return NULL;
}
Node->data = x;
Node->left = NULL;
Node->right = NULL;
return Node;
}
// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
if (a[*pi] == '#')
{
(*pi)++;
return NULL;
}
BTNode* root = BuyNode(a[*pi]);
(*pi)++;
root->left = BinaryTreeCreate(a, pi);
root->right = BinaryTreeCreate(a, pi);
return root;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreeDestory(root->left);
BinaryTreeDestory(root->right);
free(root);
}
// 二叉树节点个数
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;
}
return BinaryTreeFind(root->left, x) || BinaryTreeFind(root->right, x);
}
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
printf("%c", root->data);
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(root->right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreePrevOrder(root->left);
printf("%c", root->data);
BinaryTreePrevOrder(root->right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
{
return;
}
BinaryTreePrevOrder(root->left);
BinaryTreePrevOrder(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);
}
}
printf("\n");
QueueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
bool 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;
}
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
//检查后面节点是否全为空，若存在非空即非完全二叉树
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front)
{
QueueDestroy(&q);
return false;
}
}
QueueDestroy(&q);
return true;
}2. ヒープ
1. ヒープの概念と構造
1.1. ヒープの概念
ヒープは完全なバイナリ ツリーであり、ヒープ内の各ノードの値は常に親ノードの値を超えたり (大きなヒープ)、それ以下 (小さなヒープ) にはなりません。つまり、大きなヒープのルート ノードが最大であり、小さなヒープのルート ノードが最小になります。ヒープには、大きいヒープと小さいヒープの 2 種類しかありません。完全なバイナリ ツリーには、親ノードの値が子ノードの値よりも大きい状況があり、また、親ノードの値が子ノードの値よりも大きい状況もあります。子ノードが親ノードの値より大きい場合、完全なバイナリ ツリーはヒープではありません。
1.2. ヒープ構造
ヒープは、シーケンシャル構造の配列を使用して格納されます。つまり、ヒープの物理構造は配列であり、その論理構造は完全なバイナリ ツリーです。
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}Heap;
2. ヒープの実装
2.1. ヒープ下方調整アルゴリズム
配列は論理的には完全なバイナリ ツリーであり、ルート ノードから開始する下方調整アルゴリズムによってヒープに調整できます。下方調整アルゴリズムの前提は、左右のサブツリーの両方がヒープである必要があり、ルート ノードを適切な位置まで下方に調整するだけでヒープを形成できるということです。
2.2. ヒープの作成
完全なバイナリ ツリーは、下方調整アルゴリズムまたは上方調整アルゴリズムのいずれかによってヒープとして構築できます。ただし、下方調整アルゴリズムであっても上方調整アルゴリズムであっても、調整対象のノードを除くすべてのノードがヒーププロパティを満たしている必要があるため、最後から最初の非リーフノードのサブツリーから下方調整のみ可能です。ルートノードはヒープに調整できます。
2.3. ヒープへの挿入
ヒープ挿入とは、挿入する要素をヒープの最後の子ノードの後に挿入することであり、挿入後にヒープのプロパティが破壊された場合は、ヒープのプロパティが再び満たされるまで、新しく挿入した要素を上方修正する必要があります。注: 上方調整の前提は、リーフ ノードを除いて、リーフ ノードより上の他のすべてのノードがヒープのプロパティを満たすことです。
2.4. ヒープの削除
ヒープを削除すると、デフォルトでヒープの最上位要素が削除されます。ヒープの先頭データをヒープの最後のデータと交換し、最後のデータを削除して、ヒープのプロパティを満たすまでルート ノードを下方に調整します。(下方調整アルゴリズムの図を参照してください。ここでは分析を繰り返しません)
2.5. ヒープコードの実装
#pragma once
#include<assert.h>
#include<stdlib.h>
#include<stdio.h>
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}Heap;
//堆的初始化
void HeapInitial(Heap* hp)
{
assert(hp);
hp->a = NULL;
hp->size = 0;
hp->capacity = 0;
}
// 堆的构建
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
//assert(hp);
HPDataType* tmp = (HPDataType*)malloc(sizeof(HPDataType) * n);
if (tmp == NULL)
{
perror("HeapCreate::malloc:");
return;
}
hp->a = tmp;
hp->capacity = n;
hp->a[0] = a[0];
for (int i = 1; i < n; i++)
{
int child = i;
hp->a[child] = a[child];
while (child>0)
{
int parent = (child - 1) / 2;
//小堆：
if (hp->a[child] < hp->a[parent])
{
HPDataType tmp = hp->a[parent];
hp->a[parent] = hp->a[child];
hp->a[child] = tmp;
child = parent;
}
else
{
break;
}
}
}
hp->size = n;
}
// 堆的判空(如果为空返回1，非空返回0)
int HeapEmpty(Heap* hp)
{
assert(hp);
if (hp->size == 0)
{
return 1;
}
return 0;
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
assert(hp);
if (!HeapEmpty(hp))
{
return hp->a[0];
}
return -1;
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
assert(hp);
return hp->size;
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
assert(hp);
if (hp->size == hp->capacity)
{
int newcapacity = hp->capacity == 0 ? 5 : 2 * hp->capacity;
HPDataType* tmp = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("HeapPush::realloc:");
return;
}
hp->capacity = newcapacity;
}
hp->a[hp->size] = x;
hp->size++;
//向上调整算法
int child = hp->size - 1;
while (child > 0)
{
int parent = (child - 1) / 2;
if (hp->a[child] < hp->a[parent])
{
HPDataType tmp = hp->a[parent];
hp->a[parent] = hp->a[child];
hp->a[child] = tmp;
child = parent;
}
else
{
break;
}
}
}
// 堆的删除(默认删除堆顶元素)
void HeapPop(Heap* hp)
{
assert(hp);
if (HeapEmpty(hp))
{
return;
}
//交换首尾元素
HPDataType tmp = hp->a[0];
hp->a[0] = hp->a[hp->size - 1];
hp->a[hp->size - 1] = tmp;
//删除最后一个元素
hp->size--;
//向下调整算法
int parent = 0;
while (parent <= (hp->size - 2) / 2)
{
int childleft = 2 * parent + 1;
int childright = 2 * parent + 2;
int small = hp->a[childleft] < hp->a[childright] ? childleft : childright;
if (hp->a[parent] > hp->a[small])
{
HPDataType tmp1 = hp->a[parent];
hp->a[parent] = hp->a[small];
hp->a[small] = tmp1;
parent = small;
}
else
{
break;
}
}
for (int i = 1; i < hp->size; i++)
{
int child = i;
while (child > 0)
{
int parent = (child - 1) / 2;
//小堆：
if (hp->a[child] < hp->a[parent])
{
HPDataType tmp = hp->a[parent];
hp->a[parent] = hp->a[child];
hp->a[child] = tmp;
child = parent;
}
else
{
break;
}
}
}
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
assert(hp);
free(hp->a);
hp->a = NULL;
hp->capacity = 0;
}