0
点赞
收藏
分享

微信扫一扫

【数学建模】美赛备战笔记 01 美赛指南与竞赛全流程

天天天蓝loveyou 2024-01-17 阅读 6
数据结构算法leetcode

目录

1.二叉树前序遍历，中序遍历和后序的实现

2.层序遍历

3.求二叉树中的节点个数

4.求二叉树中的叶子节点个数

5.求二叉树的高度

6.求二叉树第k层节点个数

7.二叉树查找值为x的节点

8.单值二叉树

9.二叉树最大深度

10.翻转二叉树

11. 检查两颗树是否相同

12. 对称二叉树

13. 另一颗树的子树

14.二叉树的前序遍历

15.通过前序遍历的数组构建二叉树 

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

17.判断二叉树是否是平衡二叉树 

18.二叉树销毁  

1.二叉树前序遍历，中序遍历和后序的实现

#include<stdio.h>
#include<stdlib.h>

//快速构建一棵二叉树
typedef int DataType;
typedef struct TreeNode
{
	struct TreeNode* left;
	struct TreeNode* right;
	DataType data;
}TreeNode;

//创建节点
TreeNode* BuyNode(DataType x)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

//快速构建一棵树
TreeNode* CreateBinaryTree()
{
	TreeNode* n1 = BuyNode(1);
	TreeNode* n2 = BuyNode(2);
	TreeNode* n3 = BuyNode(3);
	TreeNode* n4 = BuyNode(4);
	TreeNode* n5 = BuyNode(5);
	TreeNode* n6 = BuyNode(6);

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;

	return n1;
}

//二叉树的前序遍历
TreeNode* PreOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);

}

int main()
{
	TreeNode* root = CreateBinaryTree();
	PreOrder(root);

	return 0;
}

 输出结果如下：

//二叉树的中序遍历
TreeNode* InOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);

}

//二叉树的后序遍历
TreeNode* PostOrder(TreeNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);

}

2.层序遍历

// 队列的定义
typedef struct QueueNode
{
    TreeNode* data;
    struct QueueNode* next;
}QNode;

typedef struct Queue
{
    QNode* head;
    QNode* tail;
}Queue;
 

// 层序遍历
void BinaryTreeLevelOrder(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    //根节点入队
    if (root)
    {
        QueuePush(&q, root);
    }
    //队列不为空时
    while (!QueueEmpty(&q))
    {
        //访问队头元素并出队
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        printf("%d", front->val);

        //队头元素的孩子节点入队
        if (front->left)
        {
            QueuePush(&q, front->left);
        }
        if (front->right)
        {
            QueuePush(&q, front->right);
        }
    }
    printf("\n");
    QueueDestroy(&q);
}
//队列初始化
void QueueInit(Queue* pq)
{
    assert(pq);
    pq->head = pq->tail = NULL;
}
//判断队列是否为空
bool QueueEmpty(Queue* pq)
{
    assert(pq);
    return pq->head == NULL && pq->tail == NULL;
}
//队列销毁
void QueueDestroy(Queue* pq)
{
    assert(pq);
    QNode* cur = pq->head;
    while (cur)
    {
        QNode* del = cur;
        cur = cur->next;
        free(del);
    }
    pq->head = pq->tail = NULL;
}
//访问队头数据
TreeNode* QueueFront(Queue* pq)
{
    assert(pq);
    assert(!QueueEmpty(pq));

    return pq->head->data;

}
//数据入队
void QueuePush(Queue* pq, TreeNode* x)
{
    assert(pq);
    QNode* newnode = (QNode*)malloc(sizeof(QNode));
    if (newnode == NULL)
    {
        perror("malloc fail");
        exit(-1);
    }
    else
    {
        newnode->data = x;
        newnode->next = NULL;
    }
    //空队列时插入
    if (pq->tail == NULL)
    {
        pq->head = pq->tail = newnode;
    }
    //非空队列时插入
    else
    {
        pq->tail->next = newnode;//链接新元素
        pq->tail = newnode;//更新队尾
    }
}
//数据出队
void QueuePop(Queue* pq)
{
    assert(pq);
    //空队列不能进行出队操作
    assert(!QueueEmpty(pq));
    //队列中只有一个元素
    if (pq->head->next == NULL)
    {
        free(pq->head);
        pq->head = pq->tail = NULL;
    }
    else
    {
        QNode* del = pq->head;
        pq->head = pq->head->next;
        free(del);
        del = NULL;
    }
}

 

3.求二叉树中的节点个数

//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	int size = 0;
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	static int size = 0;
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

正确的定义与调用

#include<stdio.h>
#include<stdlib.h>
int size = 0;

//快速构建一棵二叉树
typedef int DataType;
typedef struct TreeNode
{
	struct TreeNode* left;
	struct TreeNode* right;
	DataType data;
}TreeNode;

//创建节点
TreeNode* BuyNode(DataType x)
{
	TreeNode* newnode = (TreeNode*)malloc(sizeof(TreeNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	newnode->data = x;
	newnode->left = NULL;
	newnode->right = NULL;

	return newnode;
}

//快速构建一棵树
TreeNode* CreateBinaryTree()
{
	TreeNode* n1 = BuyNode(1);
	TreeNode* n2 = BuyNode(2);
	TreeNode* n3 = BuyNode(3);
	TreeNode* n4 = BuyNode(4);
	TreeNode* n5 = BuyNode(5);
	TreeNode* n6 = BuyNode(6);

	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n2->right = NULL;
	n3->left = NULL;
	n3->right = NULL;
	n4->left = n5;
	n4->right = n6;
	n5->left = NULL;
	n5->right = NULL;
	n6->left = NULL;
	n6->right = NULL;

	return n1;
}
//求二叉树节点个数
int TreeSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	size++;
	TreeSize(root->left);
	TreeSize(root->right);
	return size;

}

int main()
{
	TreeNode* root = CreateBinaryTree();
	printf("%d\n", TreeSize(root));
	size = 0;//初始化size
	printf("%d\n", TreeSize(root));

	return 0;
}

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

4.求二叉树中的叶子节点个数

//二叉树叶子节点的个数
int TreeLeafSize(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

5.求二叉树的高度

//二叉树的高度
int TreeHeight(TreeNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

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

}

6.求二叉树第k层节点个数

//二叉树第k层节点的个数
int TreeKLevel(TreeNode* root, int k)
{
	assert(k > 0);
	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}

	k = k - 1;
	return TreeKLevel(root->left, k) + TreeKLevel(root->right, k);
	
}

7.二叉树查找值为x的节点

//二叉树查找值为x的节点
TreeNode* TreeFind(TreeNode* root, int x)
{
	if(root == NULL)
	{
		return NULL;
	}
	if (root->data == x)
	{
		return root;
	}

	//在左子树查找
	TreeNode* ret = TreeFind(root->left, x);
	if (ret)
	{
		return ret;
	}
	//左子树没找到，再在右子树查找
	ret = TreeFind(root->right, x);
	if (ret)
	{
		return ret;
	}

	//整棵树都没找到
	return NULL;
}

 8.单值二叉树

单值二叉树题目链接：. - 力扣（LeetCode）

bool isUnivalTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    //有左右孩子
    if (root->left && root->left->val != root->val)
    {
        return false;
    }
    if (root->right && root->right->val != root->val)
    {
        return false;
    }

    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

9.二叉树最大深度

二叉树最大深度：. - 力扣（LeetCode）

int maxDepth(struct TreeNode* root) {
    if(root == NULL)
    {
        return 0;
    }
    int leftmax = maxDepth(root->left);
    int rightmax = maxDepth(root->right);
    return  leftmax > rightmax ? leftmax + 1 : rightmax + 1;
}

10.翻转二叉树

翻转二叉树题目链接：226. 翻转二叉树 - 力扣（LeetCode）

11. 检查两颗树是否相同

检查两颗树是否相同题目链接：. - 力扣（LeetCode）

bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //都为空树
    if (p == NULL && q == NULL)
    {
        return true;
    }
    //一个空树一个非空树
    if (p == NULL || q == NULL)
    {
        return false;
    }
    //两个非空树
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);
}

12. 对称二叉树

对称二叉树题目链接：. - 力扣（LeetCode）

 //相同的二叉树
bool isSameTree(struct TreeNode* p, struct TreeNode* q) {
    //都为空树
    if (p == NULL && q == NULL)
    {
        return true;
    }
    //一个空树一个非空树
    if (p == NULL || q == NULL)
    {
        return false;
    }
    //两个非空树
    if (p->val != q->val)
    {
        return false;
    }
    return isSameTree(p->left, q->left) && isSameTree(p->right, q->right);

}
//翻转二叉树
struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL)
    {
        return root;
    }
    //交换左右子树
    struct TreeNode* tmp = root->left;
    root->left = root->right;
    root->right = tmp;

    invertTree(root->left);
    invertTree(root->right);

    return root;
}
//对称二叉树
bool isSymmetric(struct TreeNode* root) {
    //空树
    if (root == NULL)
    {
        return true;
    }
    //只有一个节点的树
    if (root->left == NULL && root->right == NULL)
    {
        return true;
    }
    //有左右孩子,且左右孩子为相同的树
    invertTree(root->right);
    return isSameTree(root->left,root->right);
}

13. 另一颗树的子树

另一颗树的子树题目链接：572. 另一棵树的子树 - 力扣（LeetCode）

 

//另一棵树的子树
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot){
    if (root == NULL)
    {
        return false;
    }
    if (isSameTree(root,subRoot))
    {
        return true;
    }
    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}

14.二叉树的前序遍历

二叉树的前序遍历题目链接：144. 二叉树的前序遍历 - 力扣（LeetCode）

​

//求二叉树节点个数
int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}
//二叉树的前序遍历
void PreOrder(struct TreeNode* root, int* a, int* pi)
{
    if (root == NULL)
    {
        return;
    }
    //static int i = 0;
    a[*pi] = root->val;
    printf("a[%d] = %d\n", pi, a[*pi]);
    ++(*pi);

    PreOrder(root->left, a, pi);
    PreOrder(root->right, a, pi);
}

//二叉树的前序遍历，返回序列数组
int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    //开辟数组空间
    int n = TreeSize(root);
    //printf("%d\n",n);
    int* a = (int*)malloc(sizeof(int) * n);

    int i = 0;
    PreOrder(root, a, &i);

    *returnSize = n;
    return a;
}

15.通过前序遍历的数组构建二叉树 

 题目链接：二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

#include <stdio.h>
#include<stdlib.h>

typedef char BTDataType;
typedef struct BinaryTreeNode
{
    BTDataType data;
    struct BinaryTreeNode* left;
    struct BinaryTreeNode* right;
}BTNode;
//由前序序列构造二叉树
BTNode* BinaryTreeCreate(BTDataType* a,int* pi)
{
    if(a[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }
    BTNode* root = (BTNode*)malloc(sizeof(BTNode));
    if(root == NULL)
    {
        perror("malloc fail\n");
        return NULL;
    }
    root->data = a[*pi];
    (*pi)++;
    root->left = BinaryTreeCreate(a, pi);
    root->right = BinaryTreeCreate(a, pi);
    return root;
}
//中序遍历
void InOrder(BTNode* root)
{
    if(root == NULL)
    {
        return;
    }
    InOrder(root->left);
    printf("%c ",root->data);
    InOrder(root->right);
}

int main() {
    char str[100];
    scanf("%s", str);
    int i = 0;
    BTNode* root = BinaryTreeCreate(str, &i);
    InOrder(root);

    return 0;
}

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

//判断一棵树是否为完全二叉树
int BinaryTreeComplete(TreeNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q,root);
    }
    //节点入队
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front == NULL)
        {
            break;
        }
        QueuePush(&q, root->left);
        QueuePush(&q, root->right);

    }
    //判断后续队列中是否有非空节点，有则不是完全二叉树
    while (!QueueEmpty(&q))
    {
        TreeNode* front = QueueFront(&q);
        QueuePop(&q);
        //存在非空元素
        if (front != NULL)
        {
            QueueDestroy(&q);
            return false;
        }
    }
    QueueDestroy(&q);
    return true;
}

17.判断二叉树是否是平衡二叉树 

平衡二叉树题目链接：110. 平衡二叉树 - 力扣（LeetCode）

 

//二叉树的最大高度
int maxDepth(struct TreeNode* root) {
    if (root == NULL)
    {
        return 0;
    }
    int leftmax = maxDepth(root->left);
    int rightmax = maxDepth(root->right);
    return  leftmax > rightmax ? leftmax + 1 : rightmax + 1;
}

//平衡二叉树
bool isBalanced(struct TreeNode* root) {
    if (root == NULL)
    {
        return true;
    }
    if (root->left == NULL && root->right == NULL)
    {
        return true;
    }
    int left_heigh = maxDepth(root->left);
    int right_heigh = maxDepth(root->right);
    if (left_heigh - right_heigh == -1 || left_heigh - right_heigh == 0 
         || left_heigh - right_heigh == 1)
    {
        if(isBalanced(root->left) && isBalanced(root->right))
            return true;
    }
    return false;
}

18.二叉树销毁  

//二叉树的额销毁
void BinaryTreeDestroy(TreeNode* root)
{
    if (root == NULL)
    {
        return;
    }
    
    BinaryTreeDestroy(root->left);
    BinaryTreeDestroy(root->right);
    free(root);
}
举报

相关推荐

2022美赛美国大学生数学建模竞赛浅析

数学建模数据库

数学建模学习笔记（一）美赛的基本认知

建模发送邮件大数据系统/运维

【备战美赛】遗传算法

算法

2024美赛数学建模D题思路+代码

asp.net后端

2024美赛数学建模C题思路+代码

学习笔记c#

【美赛】美赛论文参考模板

深度学习计算机视觉人工智能美国大学生数学建模竞赛2022年美赛

数学建模经验分享：国赛美赛对比/选题参考/常用技巧

数学建模ide经验分享OpenStack云计算

2024年美赛数学建模思路 - 案例：退火算法

材质arcgis数据可视化前端

2024年美赛数学建模A题思路模型代码

c语言c++开发语言

【数学建模美赛M奖速成系列】报名流程与论文的基本格式

机器学习分类
0 条评论