利用队列 找到二叉树的每一个节点

思路是 先把根节点放在队列的首元素位置，然后再把根节点的左子树 放在队列第二个元素的位置，根的右子树放在队列的第三个元素的位置。将根节点取出，然后将第二个元素的左子树放在第四个位置，第二个元素的右子树放在第五个位置，将第二个元素取出，然后将第三个元素的左右子树按照以上方法排列，等队列内 所有元素全部取出后，就可以取出二叉树的每一个节点了。

以下为代码

#include<stdio.h>
#define wanneng char//定义一个类型，这样以后更改类型时 只需修改这一个，万能类型。
#include<stdlib.h>

typedef struct erchashu //创建一个二叉树结构体
{
	erchashu* zuo;
	erchashu* you;
	wanneng data;

}erchashu;


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

typedef struct Linked_list//创建链表结构体
{
	erchashu* data;
	Linked_list *next;

}Linked_list;

Linked_list* Linked_list_initialization(int n, erchashu* A)//创建n个元素的链表并初始化
{
	if (n == 0)
		return 0;
	Linked_list* head = 0;
	Linked_list* middle;
	Linked_list* tail = NULL;
	for (int i = 0; i < n; i++)
	{
		middle = (Linked_list*)malloc(sizeof(Linked_list));
		if (i == 0)
			head = middle;
		middle->data = A;
		middle->next = NULL;

		if (0 < i)
			tail->next = middle;
		tail = middle;
	}
	return head;
}

void Print_the_linked_list(Linked_list* p)//打印n个链表的所有元素
{
	if (!p)
	{
		return;
	}

	while (p)
	{	
		printf("%c，", p->data->data);
		p = p->next;
	} 

}


void Head_plug(Linked_list** p, erchashu* A)//头插法
{
	Linked_list* b = *p;
	int a;
	Linked_list* head = 0;
	head = (Linked_list*)malloc(sizeof(Linked_list));
	printf("输入你要插入头结点里元素的数值->:");
	scanf_s("%d", &a);
	head->data = A;
	head->next = *p;

	while (!((*p)->next == b))
	{
		(*p) = (*p)->next;
	}
	(*p)->next = head;
	*p = head;
}

void Tail_plug(Linked_list* p, erchashu* A)//尾插法
{
	Linked_list* b = p;
	int a;
	Linked_list* tail = 0;
	tail = (Linked_list*)malloc(sizeof(Linked_list));//开一个新节点空间

	tail->data = A;
	tail->next = NULL;//将新节点 指向下一个节点的指针 置空

	while (!((p)->next == NULL))//找尾
	{
		(p) = (p)->next;
	}
	p->next = tail;//找到尾后 将新节点空间 交给这个指针
}



void DEL(Linked_list** p)//删除头节点
{
	Linked_list* tmp = *p;
	*p = (*p)->next;
	printf("此二叉树的节点为->:%c\n",tmp->data->data);
	free(tmp);
	//printf("删除完成。\n");
}



int main()
{
	erchashu* A = (erchashu*)malloc(sizeof(erchashu));//创建一个 静态临时的 二叉树
	A->data = 'a';
	A->zuo = NULL;
	A->you = NULL;

	erchashu* B = (erchashu*)malloc(sizeof(erchashu));
	B->data = 'b';
	B->zuo = NULL;
	B->you = NULL;

	erchashu* C = (erchashu*)malloc(sizeof(erchashu));
	C->data = 'c';
	C->zuo = NULL;
	C->you = NULL;

	erchashu* D = (erchashu*)malloc(sizeof(erchashu));
	D->data = 'd';
	D->zuo = NULL;
	D->you = NULL;

	erchashu* E = (erchashu*)malloc(sizeof(erchashu));
	E->data = 'e';
	E->zuo = NULL;
	E->you = NULL;

	erchashu* F = (erchashu*)malloc(sizeof(erchashu));
	F->data = 'f';
	F->zuo = NULL;
	F->you = NULL;

	A->zuo = B;
	A->you = C;

	B->zuo = D;

	C->zuo = E;
	C->you = F;

	Linked_list*  s1 = Linked_list_initialization(1,A);//初始化链表
	while (s1)//队列为空 退出循环
	{
		if (s1->data[0].zuo != NULL)//首元素的左子树如果 不为空，那么入队列
		{
			Tail_plug(s1, s1->data[0].zuo);
		}
		if (s1->data[0].you != NULL)//首元素的右子树如果 不为空，那么入队列
		{
			Tail_plug(s1, s1->data[0].you);
		}
		DEL(&s1);//删除首元素
	}
	return 0;

}