【数据结构】树与二叉树&&图

二叉树

typedef struct TreeNode *BinTree;
struct TreeNode
{
    int Data;
    BinTree Left;
    BinTree Right;
};

// 增加父结点指针，变成三叉链表
// typedef struct BiTNode
// {
//     ElemType data;
//     struct BITNode *lchild, *rchild;
//     struct BiTNode *parent;
// } BITNode, *BiTree;

int treeDepth(BinTree T)
{
    it(T == NULL) return 0;
    else
    {
        int l = treeDepth(T->Left);
        int r = treeDepth(T->Right);
        return l > r l + 1 : r + 1;
    }
}

// 前序，非递归
void PreOrderTraversal(BinTree BT)
{
    BinTree T = BT;
    Stack S = CreateStack();
    wihle(T || !isEmpty(S))
    {
        while (T)
        {
            Push(S, T);
            printf("%d", T->Data);
            T = T->Left;
        }
        if (!isEmpty(S))
        {
            Pop(S);
            T = T->Right;
        }
    }
}

// 前序，递归
void PreOrderTraversal(BinTree BT)
{
    if (BT)
    {
        printf("%d", BT->Data);
        PreOrderTraversal(BT->Left);
        PreOrderTraversal(BT->Right);
    }
}

// 中序，非递归
void InOrderTraversal(BinTree BT)
{
    BinTree T = BT;
    Stack S = CreateStack();
    while (T || !isEmpty(S))
    {
        while (T)
        {
            Push(S, T);
            T = T->Left;
        }
        if (!isEmpty(S))
        {
            T = Pop(S);
            printf("%d", T->Data);
            T = T->Right;
        }
    }
}

// 中序，递归
void InOrderTraversal(BinTree BT)
{
    if (BT)
    {
        InOrderTraversal(BT->Left);
        printf("%d", BT->Data);
        InOrderTraversal(BT->Right);
    }
}

// 后序,非递归
void PostOrderTraversal(BinTree BT)
{
    BinTree T = BT;
    Stack S = CreateStack();
    vector<BinTree> v;
    Push(S, T);
    while (!isEmpty(S))
    {
        T = Pop(S);
        v.push_back(T);
        if (T->Left)
            Push(S, T->Left);
        if (T->Right)
            Push(S, T->Right);
    }
    reverse(v.begin(), v.end());
    for (int i = 0; i < v.size(); i++)
        printf("%d", v[i]->Data);
}

// 后序，递归
void PostOrderTraversal(BinTree BT)
{
    if (BT)
    {
        PostOrderTraversal(BT->Left);
        PostOrderTraversal(BT->Right);
        printf("%d", BT->Data);
    }
}

// 层次遍历
void LevelOrderTraversal(BinTree BT)
{
    queue<BinTree> q;
    BinTree T;
    if (!BT)
        return;
    q.push(BT);
    while (!q.empty())
    {
        T = q.front();
        q.pop();
        printf("%d", T->Data);
        if (T->Left)
            q.push(T->Left);
        if (T->Right)
            q.push(T->Right);
    }
}

线索化二叉树

中序

typedef struct ThreadNode
{
    int data;
    struct ThreadNode *lchild, *rchild;
    int ltag, rtag;
} ThreadNode, *ThreadTree;

// 通过中序遍历对二叉树线索化的递归算法
void InThread(ThreadTree &p, ThreadTree &pre)
{
    if (p != NULL)
    {
        InThread(p->lchild, p);
        if (p->lchild != NULL)
        {
            p->lchild = pre;
            p->ltag = 1;
        }
        if (pre != NULL && pre->rchild == NULL)
        {
            pre->rchild = p;
            pre->rtag = 1;
        }
        pre = p;
        InThread(p->rchild, pre);
    }
}

// 通过中序遍历建立中序线索二叉树的主过程算法
void CreateInThread(ThreadTree T)
{
    ThreadTree pre = NULL;
    if (T != NULL)
    {
        InThread(T, pre);
        pre->rchild = NULL;
        pre->rtag = 1;
    }
}

树的存储

// 树的表示法：双亲表示法，顺序存储
#define MAX_TREE_SIZE 100
typedef struct
{
    int data;
    int parent;
} PTNode;

typedef struct
{
    PTNode nodes[MAX_TREE_SIZE];
    int n; // 结点总数
} PTree;

// 树的表示法：孩子表示法，顺序存储+链式存储结合
struct CTNode
{
    int child;
    struct CTNode *next; // 下一个孩子
};

typedef struct
{
    int data;
    struct CTNode *firstChild; // 第一个孩子
} CTBox;

typedef struct
{
    CTBox nodes[MAX_TREE_SIZE];
    int n, r; // 结点数目和根的位置
} CTree;

// 树的表示法：孩子兄弟表示法
typedef struct CSNode
{
    int data;
    struct CSNode *firstchild, *nextsibling;
} CSNode, *CSTree;

并查集

#define SIZE 13
int UFSets[SIZE];

void Initial(int S[])
{
    for (int i = 0; i < SIZE; i++)
    {
        S[i] = -1;
    }
}

int Find(int S[], int x)
{
    while (S[x] >= 0)
        x = S[x];
    return x;
}

void Unions(int S[], int Root1, int Root2)
{
    if (Root1 == Root2)
        return;
    S[Root2] = Root1;
}

图

// 图的邻接矩阵
#define MaxVertexNum 100
typedef char VertexType;
typedef int EdgeType;
typedef struct
{
    VertexType vex[MaxVertexNum];
    EdgeType edge[MaxVertexNum][MaxVertexNum];
    int vexnum, arcnum;
} MGraph;

// 图的邻接表
#define MaxVertexNum 100
typedef struct ArcNode
{
    int adjvex;
    struct ArcNode *nextarc;
    // InfoType info; // 网的边权值
};

typedef struct VNode
{
    VertexType data;
    ArcNode *firstarc;
} VNode, AdjList[MaxVertexNum];

typedef struct
{
    AdjList vertices;
    int vexnum, arcnum;
} ALGraph;