数据结构 队列、树

于 2024-09-17 21:41:58 发布
阅读量975 收藏 13
点赞数 25
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/T66656/article/details/142204170
版权

一、队列

1.1队列的概念及结构

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)的特性。

入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为队头

2、顺序队列

代码

#include "seqqueue.h"
#include <stdio.h>
#include <string.h>
SeqQueue *CreateSeqQueue(int len)
{
    SeqQueue* sq = malloc(sizeof(SeqQueue));
    if(NULL ==sq)
    {
        perror("createseq que malloc");
        return NULL;

    }
    sq->ptr= malloc(sizeof(DATATYPE)*len);
    if(NULL == sq->ptr)
    {
        perror("create seqque malloc2");
        return NULL;
    }
    sq->tlen = len;
    sq->head = 0 ;
    sq->tail = 0;
    return sq;

}
int DestroySeqQueue(SeqQueue *queue)
{
    free(queue->ptr);
    free(queue);
    return 0;
}
int QuitSeqQueue(SeqQueue *queue)
{
    if(IsEmptySeqQueue(queue))
    {
        return 1;
    }
    queue->head =  (queue->head+1)%queue->tlen;
    return 0;
}
int EnterSeqQueue(SeqQueue *queue, DATATYPE *data)
{
    if(IsFullSeqQueue(queue))
    {
        return 1;
    }
    memcpy(&queue->ptr[queue->tail],data,sizeof(DATATYPE));
    queue->tail = (queue->tail+1)%queue->tlen;
    return 0;
}
int IsEmptySeqQueue(SeqQueue *queue)
{
    return queue->head == queue->tail;
}
int IsFullSeqQueue(SeqQueue *queue)
{
     return queue->head == (queue->tail+1)%queue->tlen;
}
DATATYPE* GetHeadSeqQueue(SeqQueue*queue)
{
    if(IsEmptySeqQueue(queue))
    {

        return NULL;
    }
    
    return &queue->ptr[queue->head];
}

 头文件

#ifndef __HEAD_H__
#define __HEAD_H__

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <errno.h>

typedef int DATATYPE;
typedef struct queue {
	DATATYPE *ptr;
	int tlen;
	int head;
	int tail;
}SeqQueue;
SeqQueue *CreateSeqQueue(int len);
int DestroySeqQueue(SeqQueue *queue);
int QuitSeqQueue(SeqQueue *queue);
int EnterSeqQueue(SeqQueue *queue, DATATYPE *data);
int IsEmptySeqQueue(SeqQueue *queue);
int IsFullSeqQueue(SeqQueue *queue);
DATATYPE* GetHeadSeqQueue(SeqQueue*queue);



#endif

3、多线程模型及队列的链

练习：

 头文件：

#ifndef __HEAD_H__
#define __HEAD_H__
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <error.h>
#include <errno.h>
typedef struct 
{
    char path[512];
}
DATATYPE;
typedef struct node {
	DATATYPE data;
	struct node *next;
}QueueNode;

typedef struct queue {
	QueueNode *head;
	int clen;
	QueueNode *tail;
}LinkQueue;
LinkQueue *CreateLinkQueue();
int DestroyLinkQueue(LinkQueue *queue);
int QuitLinkQueue(LinkQueue *queue);
int EnterLinkQueue(LinkQueue *queue, DATATYPE *data);
int IsEmptyLinkQueue(LinkQueue *queue);
DATATYPE* GetHeadLinkQueue(LinkQueue* que);
int GetSizeLinkQueue(LinkQueue*que);
#endif

 队列的链

#include "linkque.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

LinkQueue *CreateLinkQueue()
{
    LinkQueue* lq = malloc(sizeof(LinkQueue));
    if(NULL == lq)
    {
        perror("createlinkque error");
        return NULL;
    }
    lq->head= NULL;
    lq->tail=NULL;
    lq->clen=0;
    return lq;
}
int DestroyLinkQueue(LinkQueue *queue)
{
    int len = GetSizeLinkQueue(queue);
    int i = 0 ;
    for(i = 0 ;i<len;i++)
    {
        QuitLinkQueue(queue);
    }
    free(queue);
    return 0;
}
int QuitLinkQueue(LinkQueue *queue)
{
    if(IsEmptyLinkQueue(queue))        
    {
        return 1;
    }
    QueueNode* tmp = queue->head;
    queue->head = queue->head->next;
    if(NULL ==queue->head)
    {
        queue->tail= NULL;
    }
    free(tmp);
    queue->clen--;
    return 0;

}
int EnterLinkQueue(LinkQueue *queue, DATATYPE *data)
{
    QueueNode* newnode = malloc(sizeof(QueueNode));
    if(NULL == newnode)
    {
        perror("enterqueue error");
        return 1;
    }
    memcpy(&newnode->data,data,sizeof(DATATYPE));
    newnode->next= NULL;
    if(IsEmptyLinkQueue(queue))
    {
        queue->head = newnode;
        queue->tail= newnode;

    }
    else 
    {
        queue->tail->next = newnode;
        queue->tail = newnode;        
    }
    queue->clen++;
    return 0;
}
int IsEmptyLinkQueue(LinkQueue *queue)
{
    return 0 == queue->clen;    
}
DATATYPE* GetHeadLinkQueue(LinkQueue* que)
{
    if(IsEmptyLinkQueue(que))
    {
        return NULL;
    }
    return &que->head->data;
}
int GetSizeLinkQueue(LinkQueue*que)
{

    return que->clen;    
}

 核心代码：

#include <stdio.h>
#include <stdlib.h>
#include "linkque.h"
#include <dirent.h>
#include <pthread.h>
#include <semaphore.h>
pthread_t main_th;
sem_t sem_task;
pthread_mutex_t mutex;
void do_ls(const char * path,LinkQueue*que,FILE* dstfp)
{
    DIR * dir = opendir(path);
    if(NULL == dir)
    {
        fprintf(stderr,"opendir errpr\n");
        return ;
    }
    DATATYPE data;
    while(1)
    {
        struct dirent * info = readdir(dir);
        if(NULL == info)
        {
            break;
        }
        bzero(&data,sizeof(data));
        char newpath[512]={0};
        sprintf(newpath,"%s/%s",path,info->d_name);
        printf("%s\n",newpath);
        if(DT_DIR == info->d_type)// /home/linun/1.h
        {

            if(info->d_name[0]=='.')
            {
                continue;
            }
            // do_ls(newpath,sl);
            // enterqueue():
            if(pthread_self() == main_th)
            {
                strcpy(data.path,newpath);
                pthread_mutex_lock(&mutex);
                EnterLinkQueue(que,&data);
                pthread_mutex_unlock(&mutex);
                
                sem_post(&sem_task);
            }
            else 
            {
                do_ls(newpath,que,dstfp);
            }
        }
        else 
        {
            if(strlen(newpath)<3 
               || 0!=strcmp(&newpath[strlen(newpath)-2],".h"))
            {
                continue;
            }
            FILE* fp = fopen(newpath,"r");
            if(NULL == fp)
            {
                perror("fopen");
                return ;
            }
            int  num =1;
            while(1)
            {
                char buf[512]={0};
                if(NULL == fgets(buf,sizeof(buf),fp))
                {
                    break;
                }
                if(strstr(buf,"struct"))
                {
                    fprintf(dstfp,"%d %s %s",num,newpath,buf);
                }
                num++;
            }
            fclose(fp);
        }
    }

    closedir(dir);
}
typedef struct 
{

    FILE* fp;
    LinkQueue*lq;
}TH_ARG;
void* th(void* arg)
{
    TH_ARG* tmp = (TH_ARG*)arg;
    DATATYPE* ret_head;
    DATATYPE data;
    while(1)
    {
        sem_wait(&sem_task);
        pthread_mutex_lock(&mutex);
        ret_head = GetHeadLinkQueue(tmp->lq);
        memcpy(&data,ret_head,sizeof(DATATYPE));
        QuitLinkQueue(tmp->lq);
        pthread_mutex_unlock(&mutex);
        if(0 == strcmp(data.path,"over"))
        {
            break;
        }
        do_ls(data.path , tmp->lq,tmp->fp);
    }
    return NULL;
}
int	main(int argc, char **argv)
{

     main_th = pthread_self();
    LinkQueue* lq = CreateLinkQueue();
    FILE* fp =fopen("log","w");
    TH_ARG arg ;
    arg.fp = fp;
    arg.lq = lq;
    pthread_t tid1,tid2,tid3;
    sem_init(&sem_task,0,0);
    pthread_mutex_init(&mutex,NULL);
    pthread_create(&tid1,NULL,th,&arg);
    pthread_create(&tid2,NULL,th,&arg);
    pthread_create(&tid3,NULL,th,&arg);

    do_ls("/home/linux/linux-4.15",lq,fp);
    int i = 0 ;
    for(i=0;i<3;i++)
    {
        DATATYPE data;
        strcpy(data.path,"over");
        pthread_mutex_lock(&mutex);
        EnterLinkQueue(lq,&data);
        pthread_mutex_unlock(&mutex);
        sem_post(&sem_task);
    }
    pthread_join(tid1,NULL);
    pthread_join(tid2,NULL);
    pthread_join(tid3,NULL);


    
    pthread_mutex_destroy(&mutex);
    sem_destroy(&sem_task);
    fclose(fp);
    DestroyLinkQueue(lq);
    printf("hello\n");
    return 0;
}

二、树

 1、定义

​树是n(n>=0)个结点的有限集
当n=0时称为空树
 
树 其实也是一种递归的实现，即树的定义之中还用到了树的概念

2、特点

（1）且仅有一个特定的结点：根结点（Root）
（2）当  n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、T3......Tm
 
其中每一个集合本身又是一棵树，并且称为根的 子树（SubTree）

结点拥有子树的个数称谓结点的度。度为0的结点称谓叶结点。度不为0，称谓分支结点。

树的度数是指，这棵树中，最大的结点的度数，称谓树的度数。
树的深度或高度，从根开始，根为第一层，根的孩子为第二层。
 

 

下图所示的结构就不符合树的定义，因为它们都有相交的子树：

 

3、二叉树

二叉树，binary tree
n个结点的有限集合，集合要么为空树，要么由一个根结点和两棵互不相交，分别称谓根结点的左子树和右子树的二叉树组成。。

特点，
1，每个结点最多两个子树。
2，左子树和右子树是有顺序的，次序不能颠倒。
3，如果某个结点只有一个子树，也要区分左，右子树。

 

4、特殊的二叉树

特殊的二叉树
1，斜树，所有的结点都只有左子树，左斜树，所有结点都只有右子树，右树。
2，满二叉树，所有的分支结点都存在左右子树，并且叶子都在同一层上。
3，完全二叉树，对于一颗有n个结点的二叉树按层序编号，如果编号i（1<=i<=n）的结点于同样深度的满二叉树中编号为i的结点在二叉树中位置完全相同，则这可树为完全二叉树。

特性
1，在二叉树的第i层上最多有2^(i-1)个结点 i>=1
2,深度为k的二叉树至多有2^k  -1 个结点 k>=1
3,任意一个二叉树T，如果其叶子结点的个数是n0,度数为2的结点数为n2， n0 = n2 +1;
4,有n个结点的完全二叉树深度为(logn/log 2) +1;
 

5、二叉树的四种遍历方式 

1. 前序遍历

规则是先访问根结点

然后前序遍历左子树

再前序遍历右子树

（总结：根结点 -> 左子树 -> 右子树） 

如下图所示，遍历的顺序为：ABDGHCEIF 

 

2. 中序遍历

从根结点开始（注意并不是先访问根结点）

中序遍历根结点的左子树

然后再访问根结点

最后中序遍历右子树

（总结：左子树 -> 根结点 -> 右子树）

如下图所示，遍历的顺序为：GDHBAEICF 

 

3.后序遍历

从左到右先叶子

后结点的方式遍历访问左右子树

最后访问根结点

（总结：**从左到右访问叶子结点 -> 根结点） 

如下图所示，遍历的顺序为：GHDBIEFCA

 

4.层序遍历

从树的第一层，即根结点开始访问

从上而下逐层遍历

在同一层中按从左到右的顺序对结点逐个访问

（总结：第一层 -> 第二层（从左到右访问结点）-> ··· -> 最后一层（从左到右访问结点） 

如下图所示，遍历的顺序为：ABCDEFGHI

6、代码实现 

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

typedef char DATATYPE;
typedef struct BiTNode  /* 结点结构 */
{
   DATATYPE data;		/* 结点数据 */
   struct BiTNode *lchild,*rchild; /* 左右孩子指针 */
}BiTNode;



char data[]="abd##eg###cf#h###";
int inx;
void CreateBiTree(BiTNode** root)
{
    char c = data[inx++];
    if('#'==c)
    {
        *root= NULL;
        return ;
    }
    else 
    {
        *root =(BiTNode*)malloc(sizeof(BiTNode));
        if(NULL == *root)
        {
            return ;
        }
        (*root)->data = c;
        CreateBiTree(&(*root)->lchild);
        CreateBiTree(&(*root)->rchild);
    }
    return ;
}
void DestroyBiTree(BiTNode* root)
{
    if(NULL == root)
    {
        return ;
    }
    DestroyBiTree(root->lchild);
    DestroyBiTree(root->rchild);
    free(root);
    return ;
}

void PreOrderTraverse(BiTNode * root)
{
    if(NULL == root)
    {
        return ;
    }
    printf("%c",root->data);
    PreOrderTraverse(root->lchild);
    PreOrderTraverse(root->rchild);
}
void InOrderTraverse(BiTNode* root)
{ 
    if(NULL == root)
    {
        return ;
    }
    InOrderTraverse(root->lchild);
    printf("%c",root->data);
    InOrderTraverse(root->rchild);

    
}
void PostOrderTraverse(BiTNode*root)
{ 
    if(NULL == root)
    {
        return ;
    }
    PostOrderTraverse(root->lchild);
    PostOrderTraverse(root->rchild);
    printf("%c",root->data);
}


int main(int argc, char *argv[])
{
    BiTNode* root=NULL;
    CreateBiTree(&root);
    PreOrderTraverse(root);
    printf("\n");
    InOrderTraverse(root);
    printf("\n");
    PostOrderTraverse(root);
    printf("\n");
    DestroyBiTree(root);

    return 0;
}

三、哈夫曼编码

四、哈希表

h海棠溪
关注
二叉树的遍历
qq_50167577的博客
04-14 150
二叉树的遍历: 二叉树的遍历是指按某条搜索路径访问树中每个结点,使得每个结点均被访问一次,而且仅被访问一次. 先序遍历: 若二叉树为空,则什么也不做,否则 访问跟结点 先序遍历左子树 先序遍历右子树 void PreOrder(BiTree T){ if(T!=NULL){ visit(T);//访问根结点 PreOrder(T->lchild);//递归遍历左子树 PreOrder(T->rchild);//递归遍历右子树
数据结构——二叉树的四种遍历方式【前序遍历-中序遍历-后序遍历-层序遍历】
刘鑫磊
02-10 1万+
目录： 一：定义 二：二叉树的遍历方式【左-右】 1.前序遍历 图形化介绍： 2.中序遍历 图形化介绍： 3.后序遍历 图形化介绍： 4.层序遍历 图形化介绍： 一：定义 是指从根结点出发，按照某种次序依次访问二叉树中所有结点，使得每个结点被访问一次且仅被访问一次 二：二叉树的遍历方式【左-右】 二叉树的遍历方式有很多，如果我们限制了从左到右的习惯方式，那么主...
二叉树的非递归遍历
weixin_30518397的博客
08-25 367
二叉树的非递归遍历 二叉树是一种非常重要的数据结构，很多其它数据结构都是基于二叉树的基础演变而来的。对于二叉树，有前序、中序以及后序三种遍历方法。因为树的定义本身就是递归定义，因此采用递归的方法去实现树的三种遍历不仅容易理解而且代码很简洁。而对于树的遍历若采用...
二叉树的遍历【 详细讲解 】
热门推荐
有梦的博客
10-18 1万+
二叉树的遍历 一共有4种遍历 先看图，对于这个图进行4种遍历的讲解                                                         1、         先序遍历 定义：若二叉树为空，则空操作；否则 （1）访问根节点（2）先序遍历左子树（3）先序遍历右子树 根据定义我需要解释一下，定义很简单，其实定义是对
Java数据结构之链表、栈、队列、树的实现方法示例
08-26
"Java数据结构之链表、栈、队列、树的实现方法示例" 在计算机科学中，数据结构是一种组织和存储数据的方式，以便实现高效的数据存取和处理。Java数据结构中常用的数据结构有链表、栈、队列、树等，本文将详细介绍...
数据结构-使用javascript讲解数据结构之队列.zip
02-12
理解队列以及其他数据结构如栈、树、图等，能够帮助开发者设计出更高效、更优雅的解决方案。在实际编码中，还可以利用JavaScript的ES6新特性，如类（class）来封装队列操作，使其更具面向对象的特性，便于代码的管理...
数据结构中队列的应用研究.pdf
08-07
总的来说，队列作为一种数据结构在计算机科学中扮演着重要角色，尤其是在需要顺序管理和处理数据的场景中，它提供了有效的数据组织方式。通过对停车场管理系统的分析，我们可以看到队列的先进先出特性是如何在实际...
合工大数据结构实验 队列.zip
04-14
此外，队列也是许多高级数据结构如广义表、树和图的基础组件。 总的来说，合工大的这次数据结构实验将带你深入理解队列的原理和实现，通过实践加深对这一基础数据结构的认识，从而更好地应对复杂计算问题的挑战。在...
Go数据结构-集合、列表、堆栈、地图、树、队列等等
最新发布
02-22
本篇文章将深入探讨Go语言中的集合、列表、堆栈、地图、树和队列等数据结构，以及它们的实现和应用场景。 首先，集合（Set）是一种不包含重复元素的数据结构，通常用于成员测试和去重。在Go中，由于没有内置的集合...
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出结点的遍历序列；（3）求二叉树的深度、结点数目、叶结点数目；（选做）（4）将二叉树每个结点的左右子树交换位置。（选做）【基本要求】从键盘接受输入（先序），以二叉链表作为存储结构，建立二叉树（以先序来建立）【测试数据】如输入：ABC##DE#G##F###（其中#表示空格字符）则输出结果为 先序：ABCDEGF中序：CBEGDFA后序：CGEFDBA层序：ABCDEFG【选做内容】采用非递归算法实现二叉树遍历。
数据结构中的遍历类型
一只小绵羊
04-25 3059
数据结构中的遍历类型
常用数据结构：树的几种遍历方式整理
noob_Cliam的博客
09-21 5739
一、定义： 1，树型结构是一类重要的非线性数据结构，其中以树和二叉树最为常用，直观看来，树是以分支关系定义的层次结构。 2，树（Tree） 是 n （n &gt;= 0）个 结点的有限集。在任意一棵非空树中。 （1）有且仅有一个特定的称为根（root）的结点； （2）当（n &gt; 1）的时候，其余结点可分为m个互不相交的有限集，而且每个集合本身又是一棵树，称为根的子树。 3，二叉树（...
二叉树的四种遍历方式——前序、中序、后序、层序遍历（递归+非递归实现）
weixin_43298704的博客
09-10 1261
如果N代表根节点，L代表根节点的左子树，R代表根节点的右子树，则根据遍历根节点的先后次序有以下遍历方式： 1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点--->根的左子树--->根的右子树。（简记为：根左右） 2. LNR：中序遍历(Inorder Traversal)——根的左子树--->根节点--->根的右子树。（简记为：左根右） 3. LRN：后序遍历(Postorder Traversal)——根的左子树--->根的右子树-
二叉树的四种遍历方法(前序遍历、中序遍历、后序遍历、层序遍历)有图有真相！！！
Lotus_dong的博客
06-29 5737
文章目录二叉树的四种遍历方式前序遍历（Preorder Traversal）中序遍历（Inorder Traversal）后序遍历（Postorder Traversal）层序遍历（Level Order Traversal） 二叉树的四种遍历方式 相信大家能够看到二叉树的遍历就已经对二叉树本身有了足够的了解，这里就不进行过多的赘述了，我们直接进入正题。我们知道线性数据结构的遍历一般就是前序遍历和后序遍历，而二叉树的遍历常见的有三种：前序遍历、中序遍历、后序遍历（注意：前中后是针对根节点而言的），有时候也会
二叉树的四种遍历方式（前序遍历、中序遍历、后序遍历、测层序遍历）
派拉斯兔子的博客
12-02 7860
二叉树的遍历 遍历是数据结构中的常见的操作，把所有元素都访问一遍。 线性数据结构的遍历比较简单 ①、正序遍历 ②、逆序遍历 根据节点访问顺序的不同，二叉树的常见遍历方式用四种 ①、前序遍历（Preorder Traversal） ②、中序遍历（Inorder Traversal） ③、后序遍历（Postorder Traversal） ④、层序遍历（Level Order Traversal） 前序遍历（Preorder Traversal） 访问顺序 根节点、前序遍历左子树、前序遍历右子
数据结构之树的多种遍历方式（前序遍历，后序遍历，中序遍历）
冷萃美式的博客
07-24 1956
主要是记录一下书的多种遍历方式： 第一种： 前序遍历 第二种： 后序遍历 第三种： 中序遍历 第四种： 广度优先搜索 - 所谓的广度优先搜索，指的是 第五种： 深度优先搜索
二叉树遍历
qq_38440882的博客
04-13 4149
删除二叉搜索树中的节点 1、删除的结点无左右子节点，那么直接将其父节点指向NULL； 2、删除的结点只有1个子节点，分左右两种情况，直接将其父节点指向删除节点的子节点； 3、删除节点有2个子节点，这是最麻烦的情况了，最好是画个图理解，具体而言： TreeNode* deleteNode(TreeNode* root, int key) { if(root==NULL) ...
遍历二叉树
weixin_52555350的博客
03-25 5248
二叉树遍历
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值