队列和二叉树

最新推荐文章于 2024-05-26 11:40:25 发布
最新推荐文章于 2024-05-26 11:40:25 发布
阅读量164 收藏 2
点赞数 10
文章标签： 数据结构 c语言 算法 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tyro_wzp/article/details/138636769
版权

        本文主要探讨队列和二叉树的相关知识。

队列

        队列结构:队头指针指向队头元素,队尾指针指向队尾元素(链表形式或数组形式)
        队列特特点:先进先出,对头插入，队尾出队
        双端队列:对头队尾都可插入和出队

二叉树

        二叉树:包含根节点和子节点,一个三角组内只有一个根节点,最多有两个子节点,也可无子节点,子节点和根节点存在某种关系
        二叉树一般用链式存储包含两个子节点指针(左右),根结点指针和父节点指针
        完全二叉树:从根结点起从上往下、从左往右依次存储

demo:

     链式队列

pro.c

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

#include "queue.h"

#define QUEUE_LEN 5

int main()
{
        QUEUE *q  = (QUEUE *)malloc(sizeof(QUEUE));
        int i;
        init_queue(q,QUEUE_LEN);

        //测试队列添加
        for (i = 0;i < 7; i++)
        {
                push_queue(q,i);
                printf_queue(q);
                printf("head : %d, tail : %d,queue size : %d\n",get_head(q),get_tail(q),q->size);
        }

        //测试队列删除及删除后再添加
        for (i = 0;i < 7; i++)
        {
                pop_queue(q);
                printf_queue(q);
                if(q->size)
                        printf("head : %d, tail : %d,queue size : %d\n",get_head(q),get_tail(q),q->size);
        }

        for (i = 0;i < 7; i++)
                push_queue(q,i);

        printf_queue(q);
        printf("head : %d, tail : %d,queue size : %d\n",get_head(q),get_tail(q),q->size);


        //测试队列清空及清空后再添加
        clean_queue(q);
        if(q->size)
                printf("head : %d, tail : %d,queue size : %d\n",get_head(q),get_tail(q),q->size);
        printf_queue(q);

        for (i = 0;i < 7; i++)
                push_queue(q,i);

        printf_queue(q);
        printf("head : %d, tail : %d,queue size : %d\n",get_head(q),get_tail(q),q->size);

        return 0;
}

   queue.h

#include <stdbool.h>

typedef struct node
{
        int data;
        struct node *next;
} NODE;

typedef struct queue
{
        NODE *head;
        NODE *tail;
        int size;
        int capacity;    //队列容量
} QUEUE;

//初始化队列
void init_queue(QUEUE *q,int capacity);

//入队
void push_queue(QUEUE *q,int data);

//出队
void pop_queue(QUEUE *q);

//获取对头
int get_head(QUEUE *q);

//获取队尾
int get_tail(QUEUE *q);

//判断队满,队满为ture
bool queue_full(QUEUE *q);

//判断队空,队空为ture
bool queue_empty(QUEUE *q);

//打印队列
void printf_queue(QUEUE *q);

//清空队列
void clean_queue(QUEUE *q);

 queue.c

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

#include "queue.h"

void init_queue(QUEUE *q,int capacity)
{
        q->head = q->tail  = (NODE *)malloc(sizeof(NODE));
        assert(q->head != NULL);
        q->head->next = NULL;
        q->size = 0;
        q->capacity = capacity; 

        return;
}

void push_queue(QUEUE *q,int data)
{
        if(queue_full(q))
        {
                printf("queue full\n");
                return;
        }

        NODE *p = (NODE *)malloc(sizeof(NODE));
        assert(p != NULL);
        p->data = data;
        p->next = NULL;

        q->tail->next = p;
        q->tail = p;
        (q->size)++;

        return;
}

void pop_queue(QUEUE *q)
{
        if(queue_empty(q))
        {
                printf("queue empty\n");
                return;
        }

        NODE *p = q->head;
        q->head = p->next;
        free(p);
        (q->size)--;

        return;
}

int get_head(QUEUE *q)
{
        if(queue_empty(q))
        {
                printf("queue empty\n");
                return;
        }
        return q->head->next->data;
}

int get_tail(QUEUE *q)
{
        if(queue_empty(q))
        {
                printf("queue empty\n");
                return;
        }
        return q->tail->data;
}

bool queue_full(QUEUE *q)
{
        return (q->size == q->capacity);
}

bool queue_empty(QUEUE *q)
{
        return (q->size == 0);
}

void printf_queue(QUEUE *q)
{
        if(queue_empty(q))
        {
                printf("queue empty\n");
                return;
        }
        NODE *p = q->head;
        p = p->next;
        while(p != NULL)
        {
                printf("%d ",p->data);
                p = p->next;
        }

        printf("\n");

        return;
}

void clean_queue(QUEUE *q)
{
        if(queue_empty(q))
        {
                printf("queue empty\n");
                return;
        }
        NODE *p = q->head;
        NODE *tmp;
        p = p->next;
        while(p != NULL)
        {
                tmp = p;
                p = p->next;
                free(tmp);
        }
        free(q->head);
        q->size = 0;

        return;
}

 结果示例:

        二叉树 

pro.c

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

#include "tree.h"

#define TREE_SIZE 50

void insert(TREE *t)
{
        init_tree(t,TREE_SIZE);
        insert_tree(t,20);
        insert_tree(t,15);
        insert_tree(t,30);
        insert_tree(t,10);
        insert_tree(t,17);
        insert_tree(t,1);
        insert_tree(t,35);
        insert_tree(t,25);
}

int main()
{
        TREE *t = (TREE *)malloc(sizeof(TREE));
        assert(t != NULL);

        insert(t);
        printf_tree(t->root);
        printf("\n");

        NODE *p = NULL;
        p = find_tree_node(t,1);
        if(p != NULL)
                printf("find result: %d\n",p->data);

        clean_tree(t);
        printf_tree(t->root);
        printf("\n");

        insert(t);
        printf_tree(t->root);
        printf("\n");

        delete_tree_node(t,17);
        printf_tree(t->root);
        printf("\n");

        delete_tree_node(t,10);
        printf_tree(t->root);
        printf("\n");

        delete_tree_node(t,30);
        printf_tree(t->root);
        printf("\n");

        delete_tree_node(t,35);
        printf_tree(t->root);
        printf("\n");

        delete_tree_node(t,20);
        printf_tree(t->root);
        printf("\n");

        return 0;
}

tree.h

#include <stdbool.h>

typedef struct node
{
        int data;
        struct node *parent;    //父节点
        struct node *left;      //左子节点
        struct node *right;     //右子节点
} NODE;

typedef struct tree
{
        NODE *root;             //根节点
        int size;               //树节点个数
        int capacity;           //树节点数限制
} TREE;


//初始化树
void init_tree(TREE *t,int capacity);

//判断树为空
bool tree_emputy(TREE *t);

//判断树满
bool tree_full(TREE *t);

//获取树节点个数
int get_tree_size(TREE *t);

//插入节点
void insert_tree(TREE *t,int data);

//遍历树
void printf_tree(NODE *n);

//清空树
void clean_tree(TREE *t);

//查找树节点
NODE *find_tree_node(TREE *t,int data);

//删除树节点
void delete_tree_node(TREE *t,int data);

tree.c

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

#include "tree.h"

void init_tree(TREE *t,int capacity)
{
        t->root = NULL;
        t->size = 0;
        t->capacity = capacity;
        return;
}

bool tree_emputy(TREE *t)
{
        return (t->size == 0);
}

bool tree_full(TREE *t)
{
        return (t->size == t->capacity);
}

int get_tree_size(TREE *t)
{
        return t->size;
}

static NODE *create_node(int data)
{
        NODE *p = malloc(sizeof(NODE));
        assert(p != NULL);
        p->data = data;
        p->left = p->right = p->parent = NULL;
        return p;
}

static NODE *add_left(NODE *n,NODE *p)
{
        NODE *tmp = n;
        if(p->data < tmp->data)
        {
                if(tmp->left == NULL)
                {
                        tmp->left = p;
                        p->parent = tmp;
                        return NULL;
                }
        }

        return tmp->left;
}

static NODE *add_right(NODE *n,NODE *p)
{
        NODE *tmp = n;
        if(p->data > tmp->data)
        {
                if(tmp->right == NULL)
                {
                        tmp->right = p;
                        p->parent = tmp;
                        return NULL;
                }
        }

        return tmp->right;
}

static void add_tree(TREE *t,NODE *p)
{
        NODE *tmp = t->root;
        while(1)
        {
                if(p->data == tmp->data)
                {
                        printf("%d is excited\n",p->data);
                        return;
                }
                else if(p->data > tmp->data)
                {
                        if(!(tmp = add_right(tmp,p)))
                                break;
                }
                else
                {
                        if(!(tmp = add_left(tmp,p)))
                                break;
                }
        }
        t->size++;
        return;
}

void insert_tree(TREE *t,int data)
{
        TREE *tmp = t;
        if(tree_full(tmp))
        {
                printf("tree full\n");
                return;
        }

        NODE *p = create_node(data);

        if(tmp->root == NULL)
        {
                tmp->root = p;
                tmp->size++;
                return;
        }

        add_tree(tmp,p);
        return;
}

void printf_tree(NODE *n)
{
        //中序:左根右
        if(n == NULL)
                return;
        printf_tree(n->left);
        printf("%d ",n->data);
        printf_tree(n->right);
/*
        //左序:根左右
        if(n == NULL)
                return;
        printf("%d ",n->data);
        printf_tree(n->left);
        printf_tree(n->right);

        //右序:左右根
        if(n == NULL)
                return;
        printf_tree(n->left);
        printf_tree(n->right);
        printf("%d ",n->data);
*/
}

static clean_node(NODE *n)
{
        if(n != NULL)
        {
                clean_node(n->left);
                clean_node(n->right);
                free(n);
        }
}

void clean_tree(TREE *t)
{
        clean_node(t->root);
        t->root = NULL;
        t->size = 0;
}

static NODE *find_node(NODE *p,int data)
{
        while(1)
        {
                if(p->data == data)
                        return p;
                if(p->data > data)
                        p = p->left;
                if(p->data < data)
                        p = p->right;
        }
}

NODE *find_tree_node(TREE *t,int data)
{
        if(tree_emputy(t))
        {
                printf("tree emputy\n");
                return NULL;
        }

        NODE *tmp = NULL;
        tmp = find_node(t->root,data);
        return tmp;
}

int get_node_size(TREE *t)
{
        return t->size;
}

static delete_leaf(NODE *p)
{
        if(p->parent->right == p)
        {
                p->parent->right = NULL;
        }
        else
        {
                p->parent->left = NULL;
        }
        free(p);
}

static void delete_single(NODE *p)
{
        if(p->parent->left == p)
        {
                if(p->left != NULL)
                {
                        p->parent->left = p->left;
                        p->left->parent = p->parent;
                }
                else
                {
                        p->parent->left = p->right;
                        p->right->parent = p->parent;
                }
        }
        else
        {
                if(p->left != NULL)
                {
                        p->parent->right = p->left;
                        p->left->parent = p->parent;
                }
                else
                {
                        p->parent->right = p->right;
                        p->right->parent = p->parent;
                }
        }
        free(p);
        return;
}

static NODE *find_pos(NODE *p)
{
        while(1)
        {
                if(p->right != NULL)
                {
                        p = p->right;
                }
                else
                {
                        return p;
                }
        }
}

static void delete_both(TREE *t,NODE *p)
{
        NODE *left_pos;
        left_pos = find_pos(p->left);
        left_pos->right = p->right;
        p->right->parent = left_pos;
        if(p == t->root)
        {
                t->root = t->root->left;
        }
        else
        {
                if(p->parent->left == p)
                {
                        p->parent->left = p->left;
                        p->left->parent = p->parent; 
                }
                else
                {
                        p->parent->right = p->left;
                        p->left->parent = p->parent;
                }
        }
        free(p);
        return;
}

static void delete_node(TREE *t,NODE *p)
{
        if(p->right == NULL && p->left == NULL)
        {
                delete_leaf(p);
        }
        else if(p->right != NULL && p->left != NULL)
        {
                delete_both(t,p);
        }
        else
        {
                delete_single(p);
        }
}

void delete_tree_node(TREE *t,int data)
{
        if(tree_emputy(t))
        {
                printf("tree emputy\n");
                return;
        }

        NODE *tmp = find_tree_node(t,data);
        if(!tmp)
        {
                printf("tree emputy or data is not excited\n");
        }

        delete_node(t,tmp);
        t->size--;
        return;
}

 结果示例：

菜_小_白
关注
  • 10
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
二级公共基础 - 栈、循环队列、二叉树计算题
howard2005的专栏
05-26 967
栈、循环队列、二叉树计算题
数据结构之栈，队列和二叉树
qq_44929652的博客
09-16 1532
1栈 1） 概念：一种特殊的线性表，只允许在固定的一端进行插入和删除操作（后进先出）、 2） 压栈：站的插入操作，入数据在栈顶 3） 出栈：站的删除操作。出数据在栈顶 4） 实现：顺序表和链表 利用顺序表实现，即使用尾插加尾删的方式实现 利用链表实现，则头尾皆可 2.队列 1)概念：只允许在一端进行插入数据操作，在另一端进行删除数据操作的线性表（先进先出） 2)实现：数组和链表相结合 用栈实现队...
利用辅助队列建立二叉树
weixin_43574252的博客
09-29 554
二叉树头文件建树遍历二叉树主函数 头文件 头文件里包含结构体信息以及相关函数的声明 #include <stdio.h> #include <stdlib.h> typedef char ElemType; //二叉树节点 typedef struct node_t { ElemType c; struct node_t *pleft; struct node_t *pright; }Node_t, *pNode_t; //队列节点信息 typedef struct queu
栈和队列：二叉树的前序遍历
sessos的博客
09-14 697
二叉树的前序遍历 题目：用两种方式实现二叉树的前序遍历 方法1：递归 void preOrder(TreeNode *root) { if(root == NULL) return; visit(root); preOrder(root->left); preOrder(root->right); } 方法2：用栈实现前序遍历 vector<int> preOrder(TreeNode *root) { vecto
c语言之循环队列实现二叉树的层次遍历
qq_41277195的博客
08-09 2007
二叉树的层次遍历思想就是从根结点开始，从左至右从上层往下层挨个遍历。用一个数组实现的循环队列来实现就比较简单。根结点进入队列，然后出队，根节的左孩子不为空的话左孩子进队，后孩子不为空的话右孩子进队。然后循环如此直到循环队列空为止。 代码如下： #include<stdio.h> #include<stdlib.h> #define tree_size 6//定义二叉树的结点...
用队列实现二叉树层次遍历
weixin_66959071的博客
11-11 1802
在二叉树的基础上，层次遍历时采用队列读取
用队列实现二叉树层序遍历
李洙赫的博客
06-05 1060
超简单二叉树的层序遍历
用队列实现二叉树的层序遍历
qq_45324301的博客
03-20 2557
二叉树的层序遍历： 设二叉树的根节点所在层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。 层序遍历结果：ABCDEFGHI 实现思路：借助队列实现 将根节点入队列； 进行出队列操作，同时访问此节点； 分别将左右子树入队列； 回到步骤2，循环继续执行。（队列为空时循环结束） 代码实现： import java.util.LinkedList; import jav
用队列建立二叉树，层次遍历建二叉树
weixin_62248351的博客
10-23 910
用队列建立二叉树，层次遍历建二叉树
利用队列进行二叉树的层序遍历
Lc_summer的博客
03-02 666
leetcode 102. 二叉树的层序遍历 给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。 示例： 二叉树：[3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回其层序遍历结果： [ [3], [9,20], [15,7] ] 思路 利用一个队列每次保存一层的节点，然后再遍历该层节点的时候将其非空的左右孩子加入队列，最后队列为空则层序遍历完成 struct TreeNode { int val;
栈队列和二叉树（实践作业）1
08-03
上机完成实验内容(3 选 1)，提交实验报告(小组人数,一人提交即可)实验报告包含 7 部分：实验目的，实验内容，实验输入和输出说明，解题思路,实验代码及
队列实现二叉树遍历.rar
07-16
队列实现二叉树遍历.rar
Python数据结构之栈、队列及二叉树定义与用法浅析
09-19
主要介绍了Python数据结构之栈、队列及二叉树定义与用法,结合具体实例形式分析了Python数据结构中栈、队列及二叉树的定义与使用相关操作技巧,需要的朋友可以参考下
链表，队列，二叉树的应用实现
07-01
此例子是初学者理解并运用链表于、队列与二叉树以及工程开发的雏形，熟练运用与理解对于后续的开发学习都有很好的帮助，可以直接编译运行测试具体细节也可参考C primer plus (第六版)
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
qq_50891451的博客
05-22 532
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
数据结构（一）顺序表
weixin_44254079的博客
05-22 1256
数据结构 C语言
数据结构--二叉搜索树
weixin_66905164的博客
05-22 1284
二叉搜索树的概念；二叉树的实现；结点类；函数接口总览；实现二叉树；二叉搜索树的应用；K模型；KV模型；二叉搜索树的性能分析
数据结构（三）栈 队列 数组
最新发布
宝藏Coder的空间
05-26 344
chao
数据结构和算法｜堆排序系列问题（一）｜堆、建堆和Top-K问题
糖炒栗子
05-23 953
在这里不再描述大顶堆和小顶堆的含义，只剖析原理层面。
队列实现二叉树层序遍历
10-16
好的，这个问题可以用队列来实现二叉树的层序遍历。具体实现步骤如下： 1. 首先将根节点入队。 2. 然后进入循环，每次从队列中取出一个节点，访问该节点，并将其左右子节点（如果有）入队。 3. 直到队列为空，遍历...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值