【算法题day3】二叉树

1. 统计二叉树中度为1的结点个数

int SingleNodes(BiTree bt)
{
	if (bt != NULL)
	{
		if ((bt->lChild !=NULL && bt->rChild == NULL) || 
			(bt->rChild !=NULL && bt->lChild == NULL))
			return SingleNodes(bt->lChild) + SingleNodes(bt->rChild) + 1;
		else
			return SingleNodes(bt->lChild) + SingleNodes(bt->rChild);
	}
	else
		return 0;
}

2. 统计二叉树中度为2的结点个数

int DoubleNodes(BiTree bt)
{
	if (bt == NULL)
		return 0;
	else if (bt->lChild != NULL && bt->rChild != NULL)
		return DsonNodes(bt->lChild) + DsonNodes(bt->rChild) + 1;
	else
		return DsonNodes(bt->lChild) + DsonNodes(bt->rChild);
}

3. 统计二叉树中度为0的结点个数

int ZeroNodes(BiTree bt)
{
	if (bt != NULL)
	{
		if (bt->lChild == NULL && bt->rChild == NULL)
			return 1;
		else
			return ZeroNodes(bt->lChild) + ZeroNodes(bt->rChild);
	}
	else
		return 0;
}

4. 统计二叉树的高度（递归&非递归）

int GetDepth(BiTNode* bt)
{
	if (bt == NULL) //树空，高度为0
		return 0;
	int front=-1, rear=-1;
	int last = 0, depth = 0; //last指向每一层的最后一个结点，也就是每层最右的结点
	BiTNode* que[maxSize];
	BiTNode* p;
	rear = (rear + 1) % maxSize;
	que[rear] = bt;
	while (front != rear)
	{
		front = (front + 1) % maxSize;
		p = que[front];
		if (p->lChild != NULL)
		{
			rear = (rear + 1) % maxSize;
			que[rear] = p->lChild;
		}
		if (p->rChild != NULL)
		{
			rear = (rear + 1) % maxSize;
			que[rear] = p->rChild;
		}
		if (front == last) //处理改层的最右结点
		{
			depth++;
			last = rear;
		}
	}
	return depth;
}
int GetDepth(BiTNode* bt)
{
	if (bt == NULL) //空树，高度为0
		return 0;
	int ldep, rdep;
	ldep = Btdepth(bt->lChild); //左子树高度
	rdep = Btdepth(bt->rChild); //右子树高度
	if (ldep > rdep)                     //树的高度为子树最大高度加根节点
		return ldep + 1;
	else
		return rdep + 1;
}

5. 统计二叉树的宽度（非递归）

typedef struct
{
	BiTNode* p; //结点指针
	int levelNum; //结点所在层次号
}St;
int maxNode(BiTNode *bt)
{
	St que[maxSize];
	int front, rear;  //定义顺序非循环队列
	int LevelNum, i, j, n, max;
	front = rear = -1; //将队列置为空
	BiTNode* q;
	if (bt != NULL)
	{
		++rear;
		que[rear].p = bt; //树根入队
		que[rear].levelNum = 1; //树根所在层次号设置为1
		while (front != rear)
		{
			++front;
			q = que[front].p;
			LevelNum = que[front].levelNum; //LevelNum用来存取当前结点的层次号
			if (q->lChild != NULL)
			{
				++rear;
				que[rear].p = q->lChild;
				que[rear].levelNum = LevelNum + 1; //根据当前结点的层次号推知其孩子结点的层次号
			}
			if (q->rChild != NULL)
			{
				++rear;
				que[rear].p = q->rChild;
				que[rear].levelNum = LevelNum + 1;
			}
		}
		max = 0;
		for (i = 1; i <= LevelNum; ++i) //i从1开始，因为是从第一层开始
		{
			n = 0; //循环累计结点个数
			for (j = 0; j <= rear; ++j) //j从0开始，因为第一个元素在队列的第[0]个位置上
			{
				if (que[j].levelNum == i)
					++n;
				if (max < n) //如果此时的max小于累计得出的n,则更新max的值
					max = n;
			}
		}
		return max;
	}
	else
		return 0;
}

6. 计算指定结点p所在的层次号

int L = 1;
void leno(BiTNode* p, int x)
{
	if (p != NULL)
	{
		if (p->data == x)
		{
			printf("结点%d所在的层次号为%d\n", x, L);
		}
		++L; //当p由上层走向下层，++L
		leno(p->lChild, x);
		leno(p->rChild, x);
		--L; //当p由下层返回上一层，L-1
	}
}

7. 交换二叉树中每个结点的两个子女(后序遍历)

void swap(BiTree bt)
{
	BiTNode* temp = (BiTNode*)malloc(sizeof(BiTNode));
	if (bt != NULL)
	{
		swap(bt->lChild);
		swap(bt->rChild);
		temp = bt->lChild;
		bt->lChild = bt->rChild;
		bt->rChild = temp;
	}
}

8.计算二叉树中各结点中最大元素的值

int max = -1;
int Max(BiTree bt)
{
	if (bt == NULL)
		return 0;
	if (bt->data > max)
		max = bt->data;
	Max(bt->lChild);
	Max(bt->rChild);
}