c语言回顾3

1.树

建树： 树的结构体和链表类似，有左右孩子。建树使用递归方式建树，注意刷入数字的顺序。

遍历：先序，中序，后序的递归形式相似。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild, *rchild; // 左右孩子
} BiTNode, *BiTree;
BiTree create_tree()
{ // 遍历建树，所以不是按照层次遍历，1，2，-1，-1，3，-1，-1
    //   1
    // 2     3
    int data;
    scanf("%d", &data);
    if (data == -1)
    {
        return NULL;
    }
    BiTree node = (BiTree)malloc(sizeof(BiTNode));
    node->data = data;
    node->lchild = create_tree();
    node->rchild = create_tree();
    return node;
}
void InOrder(BiTree T)
{ // 中序
    if (T != NULL)
    {
        InOrder(T->lchild);
        printf("%d", T->data);
        InOrder(T->rchild);
    }
}
int main()
{
    BiTree root = create_tree();
    InOrder(root);
    return 0;
}

层次遍历：使用队列进行层次遍历，注意队列结构体形式。先初始化队列，然后将根节点root入队。如果队列不为空，则出队返回出队的BiTNode节点，输出值，并将它的左孩子和右孩子加入队列。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild, *rchild; // 左右孩子
} BiTNode, *BiTree;
typedef struct Node
{ // 节点
    BiTree data;
    struct Node *next;
} Node, *LinkNode;
typedef struct Queue
{ // 链队
    LinkNode front, rear;
} Queue, *LinkQueue;

void InitQueue(LinkQueue q)
{ // 初始化
    q->front = q->rear = (LinkNode)malloc(sizeof(Node));
    q->front->next = NULL; // 带头节点的队列
}
bool isEmpty(LinkQueue q)
{ // 判断队空
    if (q->front == q->rear)
    {
        return true;
    }
    else
    {
        return false;
    }
}
bool EnQueue(LinkQueue q, BiTree t)
{ // 入队
    LinkNode node = (LinkNode)malloc(sizeof(Node));
    node->data = t;
    node->next = NULL;
    q->rear->next = node;
    q->rear = node;
    return true;
}

BiTree DeQueue(LinkQueue q)
{

    LinkNode p = (LinkNode)malloc(sizeof(Node));
    p = q->front->next;
    q->front->next = p->next;
    if (q->rear == p)
    { // 队空的时候
        q->rear = q->front;
    }
    return p->data;
}
void LevelOrder(BiTree T)
{
    LinkQueue q = (LinkQueue)malloc(sizeof(LinkNode));
    InitQueue(q);
    EnQueue(q, T);  //先入队根节点
    while (!isEmpty(q))  //若队不为空
    {
        BiTree p = DeQueue(q); //出队，返回出队元素
        if (p != NULL)
        {
            printf("%d",p->data);  //先输出出队元素
            if (p->lchild != NULL)
            {
                EnQueue(q, p->lchild); //将出队元素左孩子入队
            }
            if (p->rchild != NULL)
            {
                EnQueue(q, p->rchild); //将出队元素有孩子入队
            }
        }
    }
}

非递归中序遍历：利用栈，若读入元素不为空将元素压入栈并往左走，当元素为空时，弹出栈并往右走，直到栈为空。

typedef struct Stack
{
    BiTree data[50];
    int top;
} Stack, *SqStack;
void InitStack(SqStack s)
{ // 初始化
    s->top = -1;
}

bool push(SqStack s, BiTree x)
{ // 入栈
    if (s->top == 49)
    {
        return false;
    }
    s->top = s->top + 1;
    s->data[s->top] = x;
    return true;
}
BiTree pop(SqStack s)
{
    BiTree data = s->data[s->top];
    s->top = s->top - 1;
    return data;
}
void InOrder2(BiTree T)
{
    SqStack sq = (SqStack)malloc(sizeof(Stack));
    InitStack(sq);   //初始化栈
    BiTree p = T;
    while (p != NULL || sq->top != -1)  //如果栈不为空或者节点不是NULL
    {
        if (p != NULL)  //先一直往左走，如果节点不是NULL
        {
            push(sq, p);  //将节点入栈
            p = p->lchild;  //先往左
        }
        else{   //如果左孩子没有了，走右孩子
            p= pop(sq); //出栈
            printf("%d ",p->data);
            p=p->rchild; //走右孩子
        }
    }
}

2.图

邻接矩阵：用二维矩阵表示边的关系，用一维数组保存顶点。