前言

本篇文章主要讲解堆的应用以及链式二叉树的实现与应用
通过这篇文章，大家应该能对堆与二叉树更好的理解

1.堆的应用

1.1堆排序

升序 -- 建大堆
降序 -- 建小堆
如果每次都使用建堆选数，整体的时间复杂度是O（N）
利用堆删除思想来进行排序

//  1、你得先写一个Hp数据结构，反而复杂
//  2、有O(N)空间复杂度//void HeapSort(int* a, int n)//{// HP hp;//    HeapInit(&hp);//    for (int i = 0; i < n; ++i)// {//     HeapPush(&hp, a[i]);//  }////   int i = 0;//   while (!HeapEmpty(&hp))//   {//     a[i++] = HeapTop(&hp);//     HeapPop(&hp);// }// HeapDestroy(&hp);//}
// 升序 -- 建大堆// 降序 -- 建小堆void HeapSort(int* a, int n){ 建堆方式1：O(N*logN)//for (int i = 1; i < n; ++i)//{//    AdjustUp(a, i);//}// 建堆方式2：O(N)for (int i = (n-1-1)/2; i >= 0; --i){AdjustDwon(a, n, i);}// O(N*logN)int end = n - 1;while (end > 0){Swap(&a[0], &a[end]);AdjustDwon(a, end, 0);--end;}
}void TestHeapSort(){// 升序打印 -- 小堆// 降序打印 -- 大堆/*HP hp;HeapInit(&hp);int a[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };for (int i = 0; i < sizeof(a) / sizeof(int); ++i){HeapPush(&hp, a[i]);}while (!HeapEmpty(&hp)){printf("%d ", HeapTop(&hp));HeapPop(&hp);}printf("\n");*/int a[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };HeapSort(a, sizeof(a) / sizeof(int));}int main(){TestHeapSort();return 0;
}

1.2时间复杂度

向上调整是从最后一排开始调整，但向下调整没算最后一排，而且，最后一排结点数比较多，差不多占了总结点的一半，所以向上调整的时间复杂度就比较大

1.3topk问题

N个数中找出最大或最小的前k个
N是远大于k的

找最大前k个：
排序 O(N*logN)
N个数的大堆，Top/Pop k次 O(N+logN*K)

假设N非常大（100亿），k比较小（100），该如何求解？

建立k个数的小堆 O(k+(N-k)*logk) 空间效率比较高

剩下的N-k个一次跟堆顶的数据比较，若比堆顶数据大，就替换堆顶数据进堆走完以后，堆里面的k个数就是最大的前k个

void PrintTopK(int* a, int n, int k)
{// 1. 建堆--用a中前k个元素建堆int* kMinHeap = (int*)malloc(sizeof(int)*k);assert(kMinHeap);for (int i = 0; i < k; ++i){kMinHeap[i] = a[i];}for (int i = (k - 1 - 1) / 2; i >= 0; --i){AdjustDwon(kMinHeap, k, i);}// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换for (int j = k; j < n; ++j){if (a[j] > kMinHeap[0]){kMinHeap[0] = a[j];AdjustDwon(kMinHeap, k, 0);}}for (int i = 0; i < k; ++i){printf("%d ", kMinHeap[i]);}printf("\n");
}void TestTopk()
{int n = 10000;int* a = (int*)malloc(sizeof(int)*n);srand(time(0));for (int i = 0; i < n; ++i){a[i] = rand() % 1000000;}a[5] = 1000000 + 1;a[1231] = 1000000 + 2;a[531] = 1000000 + 3;a[5121] = 1000000 + 4;a[120] = 1000000 + 5;a[99] = 1000000 + 6;a[0] = 1000000 + 7;a[76] = 1000000 + 8;a[423] = 1000000 + 9;a[3144] = 1000000 + 10;PrintTopK(a, n, 10);
}int main()
{TestTopk();return 0;
}

2.二叉树链式结构的实现

注意：
普通二叉树的增删查改并没有意义

如果只用二叉树存储数据，不如用顺序表和链表，那为什么还要学呢？

为学习后面更复杂的二叉树打基础（搜索二叉树，红黑树，B树，AVL树……）快速搜索数据，他们的增删查找才有意义

许多有关二叉树的oj算法题，都是出在普通二叉树上

2.1二叉树的遍历

递归结构遍历：
区别在于：访问根的时机

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

注意：
任何一棵子树都要被分成根，左子树和右子树，只有空树才是不能再被分割的

2.2部分代码递归图解

前序递归

//前序遍历
void PreOrder(BTNode* root)
{if (root == NULL){printf("# ");return;}printf("%d ", root->data);//根PreOrder(root->left);//左子树PreOrder(root->right);//右子树
}

中序递归


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

求第k层的结点

二叉树查找值为x的结点

假设查找的是5，用前序最方便
注意：递归是层层调用，不是一次就返回过去
如果右边没有找到才会去左边找，如果右边找到是直接返回的

2.3完整代码：

//定义一个链式二叉树
typedef int BTDataType;
typedef struct BinaryTreeNode
{struct BinaryTreeNode* left;struct BinaryTreeNode* right;BTDataType data;}BTNode;//处理空树
BTNode* BuyNode(BTDataType x)
{BTNode* node = (BTNode*)malloc(sizeof(BTNode));assert(node);node->data = x;node->left = NULL;node->right = NULL;return node;
}//手搓一个二叉树
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;
}//前序遍历
void PreOrder(BTNode* root)
{if (root == NULL){printf("# ");return;}printf("%d ", root->data);//根PreOrder(root->left);//左子树PreOrder(root->right);//右子树
}//中序
void InOrder(BTNode* root){if (root == NULL){printf("# ");return;}InOrder(root->left);printf("%d ", root->data);InOrder(root->right);
}//后序
void PostOrder(BTNode* root){if (root == NULL){printf("# ");return;}PostOrder(root->left);PostOrder(root->right);printf("%d ", root->data);
}//计数
//定义全局变量
int count = 0;
void TreeSize1(BTNode* root)
{if (root == NULL){return;}++count;TreeSize1(root->left);TreeSize1(root->right);
}//解决不用置空的问题，用分治的思路
int TreeSize2(BTNode* root)
{return root == NULL ? 0 : TreeSize2(root->left) + TreeSize2(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);
}//求第k层结点数
//转换成子问题：求左子树的第k-1层 + 求右子树的第k-1层
int TreeKLevel(BTNode* root, int k)
{assert(k >= 1);if (root == NULL)return 0;if (k == 1)return 1;return TreeKLevel(root->left, k - 1)+ TreeKLevel(root->right, k - 1);
}int main()
{BTNode* root = CreatBinaryTree();PreOrder(root);printf("\n");InOrder(root);printf("\n");PostOrder(root);printf("\n");//每次调用之前要置空，防止叠加count = 0;TreeSize1(root);printf("TreeSize:%d\n", count);count = 0;TreeSize1(root);printf("TreeSize:%d\n", count);printf("TreeSize:%d\n", TreeSize2(root));printf("TreeSize:%d\n", TreeSize2(root));printf("LeafSize:%d\n", TreeLeafSize(root));printf("KLevelSize:%d\n", TreeKLevel(root, 2));printf("KLevelSize:%d\n", TreeKLevel(root, 3));printf("KLevelSize:%d\n", TreeKLevel(root, 4));return 0;
}// 二叉树查找值为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;
}// 二叉树查找值为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;
}// 求二叉树深度
//求左子树的深度和右子树的深度，在其中大的那个加一就是总的深度
//后序
int TreeDepth(BTNode* root);
{if (root == NULL){return 0;}int leftDepth = TreeDepth(root->left);int rightDepth = TreeDepth(root->right);return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}//二叉树的销毁
//用后序销毁
//先销毁左子树再销毁右子树最后销毁根结点
void TreeDestroy(BTNode* root)
{if(root == NULL){return;}TreeDestroy(root->left);TreeDestroy(root->right);free(root);
}

一目了然——堆与二叉树相关推荐

java sbt二叉树,Treap——堆和二叉树的完美结合，性价比极值的搜索树
大家好,今天和大家聊一个新的数据结构,叫做Treap. Treap本质上也是一颗BST(平衡二叉搜索树),和我们之前介绍的SBT是一样的.但是Treap维持平衡的方法和SBT不太一样,有些许区别,相比 ...
【CCCC】L2-012 关于堆的判断 (25分)，，手写堆，二叉树编号，向上调整
problem L2-012 关于堆的判断 (25分) 将一系列给定数字顺序插入一个初始为空的小顶堆H[].随后判断一系列相关命题是否为真.命题分下列几种: x is the root:x是根结点: ...
一目了然——堆的概念及结构
文章目录 1.堆的概念和结构 1.1堆的概念 1.2堆的性质 1.3小根堆与大根堆 1.4堆的意义 1.5堆的实现 1.5.1完整代码 1.6选择题 1.堆的概念和结构 1.1堆的概念如果有一个关键 ...
数据结构-二叉树和堆的实现
二叉树树的概念和结构概念结构树的其他概念名词树的孩子兄弟表示法树的实际应用二叉树的概念和结构概念特殊的二叉树二叉树的性质二叉树的存储结构二叉树的顺序结构-堆堆的实现堆的向下 ...
数据结构与算法 —— 二叉树
二叉树定义: 来自于百度百科. 在计算机科学中,二叉树是每个节点最多有两个子树的树结构.通常子树被称作"左子树"(left subtree)和"右子树"(ri ...
数据结构-二叉树面试常考
摘要]计算机科学中,二叉树是每个节点最多有两个子树的树结构.通常子树被称作"左子树"(left subtree)和"右子树"(right subtree).二叉 ...
数据结构与算法-二叉树（java描述）
一.概述 1.1.树的概念树状图是一种数据结构,它是由n(n>=1)个有限节点组成一个具有层次关系的集合.把它叫做"树"是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而 ...
树与二叉树的深度优先与广度优先算法（递归与非递归）
本博客前面文章已对树与二叉树有过简单的介绍,本文主要是重点介绍有关二叉树的一些具体操作与应用阅读本文前,可以先参考本博客各种基本算法实现小结(三)-- 树与二叉树和各种基本算法实现小结( ...
java 对称的二叉树
1. 对称的二叉树 1. 题目描述请实现一个函数,用来判断一颗二叉树是不是对称的.注意,如果一个二叉树同此二叉树的镜像是同样的,定义其为对称的. 2. 解题思路可以按照类似层次遍历,来判断是否是堆 ...

一目了然——堆与二叉树

文章目录

前言