数据结构(二叉树,堆)

小陈的进阶之路

于 2024-08-15 22:08:13 发布

阅读量518

点赞数 7

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/2301_79941274/article/details/141211193

版权

数据结构专栏收录该内容

7 篇文章 0 订阅

订阅专栏

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

孩子兄弟表示法

保存值域，也要保存结点和结点之间的关系

typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};

二叉树概念及结构

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

1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是2^k-1 ，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。前h-1层满的,最后一层从左到右必须是连续的

二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有2^(i-1) 个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是2^h-1 .

F(h)=2^0+2^1+2^2+2^3+....+2^(h-1)

F(h)=2^h-1

假设这棵树N个节点 F(h)=2^h-1=N h=log2(N+1)

3. 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,则有

n0＝n2 ＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h=log2(n+1) (ps:log2(n+1) 是log以2为底，n+1为对数)
5. 对于具有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否则无右孩子

二叉树的存储结构

顺序存储(完全二叉树,满二叉树)

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树
二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

链式存储

typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{

	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
};
// 三叉链
struct BinaryTreeNode
{
	struct BinTreeNode* _pParent; // 指向当前节点的双亲
	struct BinTreeNode* _pLeft; // 指向当前节点左孩子
	struct BinTreeNode* _pRight; // 指向当前节点右孩子
	BTDataType _data; // 当前节点值域
};

二叉树链式结构

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType _data;
	struct BinaryTreeNode* _left;
	struct BinaryTreeNode* _right;
}BTNode;
BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);
	node1->_left = node2;
	node1->_right = node4;
	node2->_left = node3;
	node4->_left = node5;
	node4->_right = node6;
	return node1;
}

二叉树的遍历

前序、中序以及后序遍历

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

前序：根左子树右子树

中序：左子树根右子树

后序：左子树右子树根

前序遍历

void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

中序遍历

void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

后序遍历

void LaOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}
	LaOrder(root->left);
	LaOrder(root->right);
	printf("%d ", root->data);
}

节点个数

void TreeSize(BTNode* root, int* psize)
{
	if (root == NULL)
		return 0;
	else
		++(*psize);

	TreeSize(root->left, psize);
	TreeSize(root->right, psize);
}

	int size = 0;
	TreeSize(root, &size);
	printf("TreeSize:%d\n", size);

空:0个

不为空:左子树+右子树+1

int TreeSize(BTNode* root)
{
	return root == NULL ? 0 :
		TreeSize(root->left) + TreeSize(root->right) + 1;
}

叶子节点

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right == NULL)
		return 1;

	return TreeLeafSize(root->left)
		+ TreeLeafSize(root->right);
}

二叉树高度

空:0

不为空: 左子树高度右子树高度大的那个+1

int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ?
		leftHeight + 1 : rightHeight + 1;
}

// 有效率问题  重复计算
int TreeHeight(BTNode* root)
{
	if (root == NULL)
		return 0;

	return TreeHeight(root->left) > TreeHeight(root->right) ?
		TreeHeight(root->left) + 1 : TreeHeight(root->right) + 1;
}

第k层节点个数

空：0

非空且k==1 :返回1

非空且k>1 :左子树的第k-1层 + 右子树的第k-1层

int TreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

	// 子问题
	return TreeLevelKSize(root->left, k - 1)
		+ TreeLevelKSize(root->right, k - 1);
}

查找值为x的节点

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

二叉树销毁

void TreeDestory(BTNode* root)
{
	if (root == NULL)
		return;

	TreeDestory(root->left);
	TreeDestory(root->right);
	free(root);
}

层序遍历 --- 上一层带下一层

从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程

void TreeLevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);//删除的是队列的节点

		printf("%d ", front->data);

		if(front->left)
			QueuePush(&q, front->left);

		if (front->right)
			QueuePush(&q, front->right);
	}

	QueueDestroy(&q);
}

判断二叉树是否是完全二叉树

bool TreeComplete(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;
}

堆(适用于完全二叉树,满二叉树)

大堆:

a.完全二叉树

b.任何一个父亲>=孩子

小堆:

a.完全二叉树

b.任何一个父亲<=孩子

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

堆的实现

把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中

堆的创建

给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆

1. 建堆
升序：建大堆
降序：建小堆
2. 利用堆删除思想来进行排序

堆向下调整算法

从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：

左右子树必须是一个堆，才能调整

int array[] = {27,15,19,18,28,34,65,49,25,37}; o(logN)

//AdjustDown(php->a, php->size, 0);
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent + 1) / 2;
	while (child < n)
	{
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		 }
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

堆的插入---向上调整

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while(parent>=0)  当child=0时,parent=(0-1)/2=0,但程序能跑通
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}//小堆

堆的删除

删除堆是删除堆顶的数据，将堆顶的数据跟最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法 (小堆时需要保证左右子树均为堆)

//AdjustDown(php->a, php->size, 0);
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent + 1) / 2;
	while (child < n)
	{
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		 }
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

建堆

**向上调整时间复杂度 o(N*logN)**

//int a[] = { 6,95,56,4,57,555 };
for(int i = 1; i < n; i++)
{
	AdjustUp(a, i);//约等于插入数据，向上排序
 }
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while(parent>=0)  当child=0时,parent=(0-1)/2=0,但程序能跑通
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

向下调整 ---- 先确保调整数左右均为堆时间复杂度o(N)

for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
	AdjustDown(a, n, i);
}
//AdjustDown(php->a, php->size, 0);
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = (parent + 1) / 2;
	while (child < n)
	{
		if (child+1<n&&a[child + 1] < a[child])
		{
			++child;
		 }
		if (a[child] < a[parent])
		{
			swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

从5开始向下调整，最后调整到根节点时，左右均为堆

升序，降序排序 **堆排序时间复杂度:o(N*logN)**

升序，建大堆

降序，建小堆

void HeapSort(int* a, int n)
{
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);//降序，建小堆
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

void HeapSort(int* a, int n)
{
    //建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
    {
	    AdjustDown(a, n, i);
    }
    //排序   o(N*logN)
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		--end;
	}
}

Top-k

求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

如果数据量非常大，排序就不太可取(可能数据都不能一下子全部加载到内存中)
1. 用数据集合中前K个元素来建堆 o(K)
前k个最大的元素，则建小堆
前k个最小的元素，则建大堆
2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素覆盖根位置，向下调整 o(logK*(N-K))
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

合计:o(N)

// 建K个数的小堆
	for (int i = (k-1-1)/2; i>=0 ; i--)
	{
		AdjustDown(kminheap, k, i);
	}

	// 读取剩下的N-K个数
	int x = 0;
	while (fscanf(fout, "%d", &x) > 0)
	{
		if (x > kminheap[0])
		{
			kminheap[0] = x;
			AdjustDown(kminheap, k, 0);
		}
	}

	printf("最大前%d个数：", k);
	for (int i = 0; i < k; i++)
	{
		printf("%d ", kminheap[i]);
	}
	printf("\n");
}