C语言数据结构

最新推荐文章于 2021-05-24 18:11:18 发布

不敢递归的渣渣

最新推荐文章于 2021-05-24 18:11:18 发布

阅读量240

点赞数 1

分类专栏： C语言

本文链接：https://blog.csdn.net/qq_41767307/article/details/102959110

版权

C语言专栏收录该内容

1 篇文章 0 订阅

订阅专栏

本文详细介绍了链表的反转操作，链式存储结构的栈和队列的初始化、判断空、入栈、出栈、入队和出队等基本操作。接着讲解了二叉树的四种遍历方式：先序、中序、后序和层序，并给出了相应实现。此外，还涵盖了二叉搜索树的查找、插入和删除操作，以及平衡二叉树的调整策略。

摘要由CSDN通过智能技术生成

一、线性结构

1、链表的高端操作

void Reverse(struct Node *L)
{
        struct Node *p1 = L->next;
        struct Node *p2 = p1->next;
        struct Node *tailp = NULL;
        while (p2)
        {
               p1->next = tailp;
               tailp = p1;

               p1 = p2;
               p2 = p2->next;
        }
        p1->next = tailp;
        L->next = p1;
}//链表的反转

2、链式存储结构的栈（链栈）

struct SNode
{
        ElementType data;
        struct SNode *next;
};//栈的节点定义
struct Stack
{
        struct SNode *database;
        struct SNode *top;
};//栈的定义
struct Stack *InitStack()
{
        struct Stack *S = (struct Stack *)malloc(sizeof(struct Stack));
        S->database = NULL;
        S->top = S->database;
        return S;
}//栈的初始化
bool IsStackEmpty(struct Stack *S)
{
        if (S->top == NULL)
               return true;
        else
               return false;
}//判断是否栈空
void push(struct Stack *S, ElementType e)
{
        struct SNode *newp = (struct SNode *)malloc(sizeof(struct SNode));
        newp->data = e;
        newp->next = S->database;
        S->database = newp;
        S->top = S->database;
}//入栈
void pop(struct Stack *S, ElementType &e)
{
        e = S->database->data;
        S->database = S->database->next;
        free(S->top);
        S->top = S->database;
}//出栈

3、链式存储结构的队列（链队列）

struct QNode
{
        ElementType data;
        struct QNode *next;
};//队列的节点定义
struct Queue
{
        struct QNode *database;
        struct QNode *front;
        struct QNode *rear;
};//队列的定义


struct Queue *InitQueue()
{
        struct Queue *Q = (struct Queue *)malloc(sizeof(struct Queue));
        Q->database = (struct QNode *)malloc(sizeof(struct QNode));
        Q->front = Q->database->next;
        Q->rear = Q->database;
        return Q;
}//队列的初始化
bool IsQueueEmpty(struct Queue *Q)
{
        if (Q->front == NULL)
               return true;
        else
               return false;
}//判断队列是否为空
void EnQueue(struct Queue *Q, ElementType e)
{
        struct QNode *newp = (struct QNode *)malloc(sizeof(struct QNode));
        newp->data = e;
        newp->next = NULL;

        Q->rear->next = newp;
        Q->rear = Q->rear->next;

        Q->front = Q->database->next;
}//入队
void DeQueue(struct Queue *Q, ElementType &e)
{
        e = Q->front->data;
        Q->database->next = Q->database->next->next;
        free(Q->front);
        Q->front = Q->database->next;

        if (IsQueueEmpty(Q))
               Q->rear = Q->database;
}//出队

二、二叉树

1、遍历方式及其运用

void PreOrder(struct TNode *T)
{
        struct TNode *p = T;
        if(p)
        {
               printf("%d ", p->data);
               PreOrder(p->left);
               PreOrder(p->right);
        }
}//先序遍历递归实现

void PreOrder(struct TNode *T)
{
        struct TNode *p = T;
        struct Stack *S = InitStack();
        while (p || !IsStackEmpty(S))
        {
               while (p)
               {
                       printf("%d ", p->data);
                       push(S, p);
                       p = p->left;
               }
               if (!IsStackEmpty(S))
               {
                       pop(S, p);
                       p = p->right;
               }
        }
}//先序遍历堆栈实现

void InOrder(struct TNode *T)
{
        struct TNode *p = T;
        if(p)
        {
               InOrder(p->left);
               printf("%d ", p->data);
               InOrder(p->right);
        }
}//中序遍历递归实现

void InOrder(struct TNode *T)
{
        struct TNode *p = T;
        struct Stack *S = InitStack();
        while (p || !IsStackEmpty(S))
        {
               while (p)
               {
                       push(S, p);
                       p = p->left;
               }
               if (!IsStackEmpty(S))
               {
                       pop(S, p);
                       printf("%d ", p->data);
                       p = p->right;
               }
        }
}//中序遍历堆栈实现

void PostOrder(struct TNode *T)
{
        struct TNode *p = T;
        if(p)
        {
               PostOrder(p->left);
               PostOrder(p->right);
               printf("%d ", p->data);
        }
}//后序遍历递归实现

void LevelOrder(struct TNode *T)
{
        struct TNode *p = T;
        struct Queue *Q = InitQueue();
        EnQueue(Q, T);
        while (!IsQueueEmpty(Q))
        {
               DeQueue(Q, p);
               printf("%d ",p->data);
               if (p->left)
                       EnQueue(Q, p->left);
               if (p->right)
                       EnQueue(Q, p->right);
        }
}//层序遍历队列实现

void PreOrder(struct TNode *T)
{
        struct TNode *p = T;
        if(p)
        {
               if(!p->left&&!p->right)
                       printf("%d ", p->data);
               PreOrder(p->left);
               PreOrder(p->right);
        }
}//更改先序遍历实现输出叶子节点

int PostOrder(struct TNode *T)
{
        struct TNode *p = T;
        int HL, HR, MaxH;
        if (p)
        {
               HL = PostOrder(p->left);
               HR = PostOrder(p->right);
               MaxH = HL > HR ? HL : HR;
               return (MaxH + 1);
        }
        else
               return 0;
}//更改后序遍历实现输出树高

2、二叉搜索树操作合集

struct TNode *Find(struct TNode *BST, ElementType X)
{
    struct TNode *p = BST;
    while (p)
    {
        if (X<p->Data)
            p = p->Left;
        else if (X>p->Data)
            p = p->Right;
        else
            return p;
    }
    return NULL;
}//查找二叉搜索树指定元素

struct TNode *FindMin(struct TNode *BST)
{
    if (BST)
        while (BST->Left)
            BST = BST->Left;
    return BST;
}//迭代查找二叉搜索树的最小值
struct TNode *FindMax(struct TNode *BST)
{
    if (BST)
        while (BST->Right)
            BST = BST->Right;
    return BST;
}//迭代查找二叉搜索树的最大值

struct TNode *Insert(struct TNode *BST,ElementType X)
{
    if(BST==NULL)
    {
        struct TNode *newp=(struct TNode *)malloc(sizeof(struct TNode));
        newp->Data=X;
        newp->Left=newp->Right=NULL;
        BST=newp;
    }
    else
    {
        if(X<BST->Data)
            BST->Left=Insert(BST->Left,X);
        else if(X>BST->Data)
            BST->Right=Insert(BST->Right,X);
    }
    return BST;
}//递归插入二叉搜索树

struct TNode *Delete(struct TNode *BST, ElementType X)
{
    if(BST==NULL)
        printf("Not Found\n");//当前节点为空，找不到
    else if(X<BST->Data)
        BST->Left=Delete(BST->Left,X);//在左子树，递归进入
    else if(X>BST->Data)
        BST->Right=Delete(BST->Right,X);//在右子树，递归进入
    else//找到该元素
    {
        struct TNode *temp;
        if(BST->Left&&BST->Right)
        {
            temp=FindMin(BST->Right);
            BST->Data=temp->Data;
            BST->Right=Delete(BST->Right,BST->Data);
        }//左右子树均存在，则在右子树找到最小值替换，然后递归删除右子树的该元素
        else
        {
            temp=BST;
            if(BST->Left==NULL)
                BST=BST->Right;
            else if(BST->Right==NULL)
                BST=BST->Left;
            free(temp);
        }//左右子树只存在一棵，则直接接上去
    }
    return BST;
}//递归删除二叉搜索树

3、平衡二叉树调整方案

在这里插入图片描述 1、在二叉搜索树中插入新节点
2、更新树高，同时算出每个节点左右子树的高度差
3、找到问题节点（左右子树树高差大于1的节点）
4、确定新插入的节点在问题节点的什么位置（左左，左右，右左，右右）
5、根据位置进行平衡二叉树的调整

不敢递归的渣渣

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
C语言数据结构

C语言数据结构#一线性结构|–|--|| | |欢迎使用Markdown编辑器你好！这是你第一次使用 Markdown编辑器所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章，了解一下Markdown的基本语法知识。新的改变我们对Markdown编辑器进行了一些功能拓展与语法支持，除了标准的Markdown编辑器功能，我们增加了如下几点新功能...
复制链接

扫一扫

专栏目录