8.10链式队列二叉树

通过顺序队列实现杨辉三角

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

void Traverse(Queue q)
{
    int i;
    for(i = q.front; i != q.rear; i++)
    {
        if (q.data[i] != 0)
        {
            printf("%d ", q.data[i]);
        }
    }
    printf("\n");
}

int main()
{    
    int ret, num, i, top;
    Queue q1, q2;

    if (InitQueue(&q1) != SUCCESS || InitQueue(&q2) != SUCCESS)
    {
        printf("Init Failure!\n");
        exit(1);
    }

    printf("Plesae input line:\n");
    scanf("%d", &num);

    for (i = 0; i < num; i++)
    {
        if (i == 0)
        {
            EnterQueue(&q1, 0);
            EnterQueue(&q1, 1);
            EnterQueue(&q1, 0);
        }
        else
        {
            while (LengthQueue(q1) != 1)
            {
                top = DeleteQueue(&q1);
                EnterQueue(&q2, top + GetFront(q1));
            }
            while (LengthQueue(q2) != 0)
            {
                EnterQueue(&q1, DeleteQueue(&q2));
            }
            EnterQueue(&q1, 0);
        }
        Traverse(q1);    
    }
    return 0;
}

*************************************************************************
链式队列定义
struct node //表示结点信息
{
int data; //数据域
struct node *next; //指针域
};
typedef struct node Node;

struct queue
{
Node *front; //队头指针
Node *rear; //队尾指针
};
typedef struct queue Q;

初始化先定义一个空结点，作为头节点。再定义一个空结构体存放队列信息
int queueinit(Q **q)
{
(*q) = (Q *)malloc(sizeof(Q));

Node *p=(Node *)malloc(sizeof(Node));

   p->next = NULL;
   (*q)->front = (*q)->rear = p;
}
从队头出信息
int DeleteQueue(Q *q)
{
   if (q == NULL || q->rear == q->front)
   {
       return FAILURE;
   }

   int e;
   Node *p = q->front->next;
   e = p->data;
   q->front->next = p->next;
   if (!p->next)
   {
       q->rear = q->front;
   }
   free(p);

   return e;
}
清空队列元素，从对头开始清空
int ClearQueue(Q *q)
{
   if(NULL == q)
   {
       return FAILURE;
   }

   Node *p = q->front->next;
   while(p)
   {
       q->front->next = p->next;
       free(p);
       p = q->front->next;
   }

q->rear = q->front;
return SUCCESS;
}
**************************************************************************************
二叉树的性质
性质1
在二叉树的第i层上至多有个结点
性质2
深度为k的二叉树至多有 -1个结点
性质3
对任何一棵二叉树T，如果其终端结点数为n，度为2的结点数为m，则n=m+1
性质4
具有n个结点的完全二叉树的深度为
性质5
如果对1棵有n个结点的二叉树的结点按层序编号，对任一结点i：
如果i=1，则结点i是二叉树的根，无双亲，如果i>1，则其双亲是结点【i/2】
如果2i>n，则结点i无左孩子，否则，其左孩子是2i
如果2i+1>n，则结点i无右孩子；否则其右孩子是结点2i+1。************************************************************************************

//二叉树的定义
struct node
{
    int data;
    struct node *right, *left;
};
typedef struct node TreeNode;
//创建一个二叉树
TreeNode *CreateTree(int *a)
{
    int i;
    TreeNode *node[11] = {0};

    for (i = 0; i < 10; i++)
    {
        node[i] = (TreeNode *)malloc(sizeof(TreeNode));
        if (NULL == node[i])
        {
            printf("malloc error!\n");
        }

        node[i]->data = a[i];
        node[i]->right = NULL;
        node[i]->left = NULL;
    }

    for (i = 0; i < 10 / 2; i++)
    {
        node[i]->left = node[2 * i + 1];
        node[i]->right = node[2 * i + 2];
    }

    return node[0];
}
//先序遍历
int PreOrder(TreeNode *T)
{
    if(T == NULL)
    {
        return 1;
    }

    printf("%d ", T->data);
    PreOrder(T->left);
    PreOrder(T->right);

    return 0;
}
//中序遍历
int InOrder(TreeNode *T)
{
    if(T == NULL)
    {
        return 1;
    }

    InOrder(T->left);
    printf("%d ", T->data);
    InOrder(T->right);

    return 0;
}
//后序遍历
int PostOrder(TreeNode *T)
{
    if(T == NULL)
    {
        return 1;
    }

    PostOrder(T->left);
    PostOrder(T->right);
    printf("%d ", T->data);

    return 0;
}


int main()
{
    int a[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};
    TreeNode *root;

    root = CreateTree(a);
    PreOrder(root);
    printf("\n");
    InOrder(root);
    printf("\n");
    PostOrder(root);
    return 0;
}

8.10链式队列 二叉树

猜你喜欢

8.10链式队列二叉树