生成二叉树和红黑树的helloworld（4）

最新推荐文章于 2022-12-27 18:34:25 发布
最新推荐文章于 2022-12-27 18:34:25 发布
阅读量83 收藏
点赞数
分类专栏： 我的数据结构 文章标签： 树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/leafrenchleaf/article/details/84427874
版权
红黑树的打印 

#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
#define Pstart 62
#define N 10
//typedef struct node *link;
typedef struct node 
{
    int    key;
    int    item;
    struct node *l,
                *r;
}BTNode;
typedef struct pnode        
{
    int key;                   
    int item;                  
   // struct pnode *left,      
//               *right,     // this no need to use left ,right 
//               *parent;      
    struct pnode *parent;     
    int lrflag,                //left 0,right 1
        space,                 //print point
        level;                 //the node level
}PBTNode;
BTNode* null;//null node
BTNode* CreateBTNode(char *s)
{
    char ch;
    BTNode *p=null,
           *b=null,
           *ps[MaxSize];
    int top=-1,
        tag=-1;
    ch=*s;
    while(ch)
    {
        switch(ch)
        {
            case '(':ps[++top]=p;tag=1;break;
            case ',':tag=2;break;
            case ')':top--;break;
            default:
                     p=(BTNode*)malloc(sizeof(BTNode));
                     p->item=ch;
                     p->l=p->r=null;
                     if(b==null)
                         b=p;
                     else
                     {
                         switch(tag)
                         {
                             case 1:ps[top]->l=p;break;
                             case 2:ps[top]->r=p;break;
                         }
                     }
        }
        ch=*(++s);
    }
    return b;
}

//print ()()
void DispBTNode(BTNode *b)
{
    if(b!=null)
    {
        printf("%d",b->item);
        if(b->l!=null||b->r!=null)
        {
            printf("(");
            DispBTNode(b->l);
            if(b->r!=null)printf(",");
            DispBTNode(b->r);
            printf(")");
        }
    }
}
int BTNodeHeight(BTNode *b)
{
    int lh,rh;
    if(b==null)return 0;
    else
    {
        lh=BTNodeHeight(b->l);
        rh=BTNodeHeight(b->r);
        return (lh>rh)?(lh+1):(rh+1);
    }
}

void SetPBTNodeInfo(BTNode *b,PBTNode *parent,PBTNode *pb,int level,int lrflag)
{
    int f=3;
    pb->item=b->item;
    pb->key =b->key;
    pb->parent=parent;
    pb->level=level;
    pb->lrflag=lrflag;
    pb->space=-3;
}

/*Level Order BTNode----->PBTNode*/
int CreatePBTNode(BTNode *b,PBTNode *pqu[])
{
    BTNode *p;
    BTNode *qu[MaxSize];
    int front=-1,
        rear=-1;
    rear++;
    qu[rear]=b;
    pqu[rear]=(PBTNode*)malloc(sizeof(PBTNode));
    SetPBTNodeInfo(b,NULL,pqu[rear],1,-1);
    while(rear!=front)
    {
        front++;
        p=qu[front];
        if(p->l!=null)
        {
            rear++;
            qu[rear]=p->l;
                printf("btnode:begin %d\n",rear);
            pqu[rear]=(PBTNode*)malloc(sizeof(PBTNode));
                printf("btnode:end\n");
            SetPBTNodeInfo(p->l,pqu[front],pqu[rear],pqu[front]->level+1,0);
        }
        if(p->r!=null)
        {
            rear++;
            qu[rear]=p->r;
            pqu[rear]=(PBTNode*)malloc(sizeof(PBTNode));
            SetPBTNodeInfo(p->r,pqu[front],pqu[rear],pqu[front]->level+1,1);
        }
    }
    return rear;
}
//打印一层结点，及该层结点与父结点的连线路径。
void PBTNodePrint(PBTNode *pb[],int n,int h)
{
    int l=-1,
        r=0,
        i,j,k,
        end;
    char c;
    PBTNode *p;
    if(n<=0||h<=0)
    {
        return;
    }
    else if(n==1)
    {
        for(i=0;i<pb[0]->space;i++)
            printf(" ");
                printf("%d%c",pb[0]->item,pb[0]->key?'+':' ');
        printf("\n");
        return;
    }
    h=h-pb[0]->level+2;
    for(k=0;k<h;k++)
    {
        j=0;
        l--;
        r++;

        for(i=0;i<n;i++)//print line
        {
            p=pb[i];
            end=(p->lrflag==0)?l:r;
            end+=p->parent->space;
            for(;j<end;j++)
                printf(" ");
            c=(p->lrflag==0)?'/':'\\';
            printf("%c",c);
        }
        printf("\n");
    }
    for(i=0;i<n;i++)//this level ,the node should point
    {
        p=pb[i];
        if(p->lrflag==0)
            p->space=p->parent->space+l;
        else
            p->space=p->parent->space+r;
    }
    for(i=0,j=0;i<n;i++)//data
    {
        p=pb[i];
        for(;j<p->space;j++)
            printf(" ");
                printf("%d%c",p->item,p->key?'+':' ');
    }
    printf("\n");
}
void DispBTree(BTNode *b)
{
    int n,i,j,high,
        level;
    PBTNode *p;
    PBTNode *pqu[MaxSize];
    PBTNode *levelpqu[MaxSize];
        printf("DispBtree\n");
    n=CreatePBTNode(b,pqu);
    high=BTNodeHeight(b);
    j=0;
    level=1;
    pqu[0]->space=Pstart;
    for(i=0;i<=n;i++)
    {
        p=pqu[i];
        if(p->level==level)
        {
            levelpqu[j]=p;
            j++;
        }
        else
        {
            PBTNodePrint(levelpqu,j,high);
            level=p->level;
            j=0;
            levelpqu[j]=p;
            j++;
        }
    }
    PBTNodePrint(levelpqu,j,high);

}

//----------------------rbtree2.c
BTNode* NODE(int item,BTNode* l,BTNode* r,int key){
        BTNode* t=malloc(sizeof *t);
        t->item=item;t->l=l;t->r=r;t->key=key;
        return t;
}
BTNode* rotR(BTNode* t){
        BTNode* x=t->l;t->l=x->r;x->r=t;return x;
}
BTNode* rotL(BTNode* t){
        BTNode* x=t->r;t->r=x->l;x->l=t;return x;
}
void pprint(BTNode* t){
        printf("(");
        if(t!=null){ 
                printf("%d%c",t->item,t->key?'+':' ');
                pprint(t->l);
                pprint(t->r);
        }
        printf(")");
}
BTNode* RBinit(){
        null=NODE(0,null,null,0);
        null->l=null;null->r=null;
        return null;
}
BTNode* insert_node(BTNode* t ,int item, int sw){
        if(t==null) return NODE(item,null,null,1);
        if(t->l->key && t->r->key){
                t->key=1;t->l->key=0;t->r->key=0;
        }
        if(item<t->item){
                t->l=insert_node(t->l,item,0);
                if(t->key && t->l->key && sw) t=rotR(t);
                if(t->l->key && t->l->l->key)
                { t=rotR(t); t->key=0; t->r->key=1; }
        }else{
                t->r=insert_node(t->r,item,1);
                if(t->key && t->r->key && !sw) t=rotL(t);
                if(t->r->key && t->r->r->key)
                { t=rotL(t); t->key=0; t->l->key=1; }
        }
        return t;
}
BTNode* RBinsert(BTNode* root,int item){
        root=insert_node(root,item,0);
        root->key=0;
        return root;
}
int main(){
        int i=0;
        srand(time(NULL));
        BTNode* root=RBinit();
        for(i=0;i<N;i++)
                root=RBinsert(root,rand()%100);
        printf("pprint:\n");
        printf("\t\\tree");
        pprint(root);
        printf("\n");

        printf("DispBtnode:\n");
        DispBTNode(root);printf("\n");
        printf("DispBTree:\n");
        DispBTree(root);
        return 0;
}
root@raspberrypi:~/hellogit/hello/tree/tree#


[img]http://dl.iteye.com/upload/attachment/0084/1365/e58d74cf-c81c-3031-a088-08c6f53d2abe.jpg[/img]
linux内核控
关注
专栏目录
打印二叉树的图　打印二叉树形状　打印二叉树路径　控制台打印二叉树　字符环境打印二叉树
09-29
/* 这是一个在字符环境中，用ASCII码打印二叉树形状的算法。 在Linux控制台下写的例题，在DOS中稍有点乱。 采用层次遍法。 算法拙劣，仅供初学者做练习，（本人也是初学者，自学数据结构，刚好学到这二叉树这一章， 半路出家，基础差有点吃力头大，搞几个二叉的例题，却不知道其构造形状， 想调用图形ＡＰＩ做个美观点的，却有点偏离本章的学习目的，只好用字符打印， linux环境中打印的还可以，ＤＯＳ中有点不稳定，如果您有更好的算法一定不吝赐教。 我的ＱＱ：137241638 mail：hnflcp@139.com */ #include <stdio.h> #include <stdlib.h> #define MaxSize 100 //Pstart是二叉树根结点在一行中的位置，一行最能打印124个字符，取其1/2。 //如果你的屏不够宽的话，可以输出文本文件里， aa.exe>>aa.txt #define Pstart 40 typedef struct bstnode { int key, data, bf; struct bstnode *lchild, *rchild; }BSTNode; typedef struct pnode //为打印二叉树建了一个结构。 { int key; //关键字数据１ int data; //关键字数据２ struct pnode *lchild, //左孩子 *rchlid, //右孩子 *parent; //父节点 int lrflag, //标记本节点是左孩子（等于０时），还是右孩子（等于１时） space, //存储本节点打印位置 level; //存储本节点所在层次。 }PBSTNode; /*建立二叉树。 用括号表示法表示二叉树字符串，创建二叉树。 */ BSTNode* CreateBSTNode(char *s) { char ch; BSTNode *p=NULL, *b=NULL, *ps[MaxSize]; int top=-1, tag=-1; ch=*s; while(ch) { switch(ch) { case '(':ps[++top]=p;tag=1;break; case ',':tag=2;break; case ')':top--;break; default: p=(BSTNode*)malloc(sizeof(BSTNode)); p->data=ch; p->lchild=p->rchild=NULL; if(b==NULL) b=p; else { switch(tag) { case 1:ps[top]->lchild=p;break; case 2:ps[top]->rchild=p;break; } } } ch=*(++s); } return b; } //用适号表示法打印二叉树。 void DispBSTNode(BSTNode *b) { if(b!=NULL) { printf("%d",b->key); if(b->lchild!=NULL||b->rchild!=NULL) { printf("("); DispBSTNode(b->lchild); if(b->rchild!=NULL)printf(","); DispBSTNode(b->rchild); printf(")"); } } } int BSTNodeHeight(BSTNode *b) { int lchildh,rchildh; if(b==NULL)return 0; else { lchildh=BSTNodeHeight(b->lchild); rchildh=BSTNodeHeight(b->rchild); return (lchildh>rchildh)?(lchildh+1):(rchildh+1); } } /*建立一个二叉树打印结点的信息， 只被int CreatePBSTNode(BSTNode *b,PBSTNode *pqu[])调用*/ void SetPBSTNodeInfo(BSTNode *b,PBSTNode *parent,PBSTNode *pb,int level,int lrflag) { int f=3; pb->data=b->data; pb->key =b->key; pb->parent=parent; pb->level=level; pb->lrflag=lrflag; pb->space=-1; } /*用层次遍历法，BSTNode结构存储的二叉树转换为，PBSTNode结构的二叉树*/ int CreatePBSTNode(BSTNode *b,PBSTNode *pqu[]) { BSTNode *p; BSTNode *qu[MaxSize]; int front=-1, rear=-1; rear++; qu[rear]=b; pqu[rear]=(PBSTNode*)malloc(sizeof(PBSTNode)); SetPBSTNodeInfo(b,NULL,pqu[rear],1,-1); while(rear!=front) { front++; p=qu[front]; if(p->lchild!=NULL) { rear++; qu[rear]=p->lchild; pqu[rear]=(PBSTNode*)malloc(sizeof(PBSTNode)); SetPBSTNodeInfo(p->lchild,pqu[front],pqu[rear],pqu[front]->level+1,0); } if(p->rchild!=NULL) { rear++; qu[rear]=p->rchild; pqu[rear]=(PBSTNode*)malloc(sizeof(PBSTNode)); SetPBSTNodeInfo(p->rchild,pqu[front],pqu[rear],pqu[front]->level+1,1); } } return rear; } //打印一层结点，及该层结点与父结点的连线路径。 void PBSTNodePrint_char(PBSTNode *pb[],int n,int h) { int l=-1, r=0, i,j,k, end; char c; PBSTNode *p; if(n<=0||h<=0) { return; } else if(pb[0]->level==1) { for(i=0;i<pb[0]->space;i++) printf(" "); printf("%c",pb[0]->data); printf("\n"); return; } h=h-pb[0]->level+2; for(k=0;k<h;k++) { j=0; l--; r++; for(i=0;i<n;i++)//打印线条 { p=pb[i]; end=(p->lrflag==0)?l:r; end+=p->parent->space; for(;j<end;j++) printf(" "); c=(p->lrflag==0)?'/':'\\'; printf("%c",c); } printf("\n"); } for(i=0;i<n;i++)//计算本层结点打印位置 { p=pb[i]; if(p->lrflag==0) p->space=p->parent->space+l; else p->space=p->parent->space+r; } for(i=0,j=0;i<n;i++)//打印关键字数据 { p=pb[i]; for(;j<p->space;j++) printf(" "); printf("%c",p->data); } printf("\n"); } //循环打印所有层的数据 void DispBTree(BSTNode *b) { int n,i,j,high, level; PBSTNode *p; PBSTNode *pqu[MaxSize]; PBSTNode *levelpqu[MaxSize]; n=CreatePBSTNode(b,pqu); high=BSTNodeHeight(b); j=0; level=1; pqu[0]->space=Pstart; for(i=0;i<=n;i++) { p=pqu[i]; if(p->level==level) { levelpqu[j]=p; j++; } else { PBSTNodePrint_char(levelpqu,j,high); level=p->level; j=0; levelpqu[j]=p; j++; } } PBSTNodePrint_char(levelpqu,j,high); } void main() { int iDepth=0, iWidth=0, iCount=0; char *str1="A(B(D,E(H,X(J,K(L,M(T,Y))))),C(F,G(X,I)))"; char *str2="A(B(D(,G)),C(E,F))"; BSTNode *b=CreateBSTNode(str1); DispBSTNode(b);printf("\n"); iDepth=BSTNodeHeight(b); printf("Depth:%d\n",iDepth); DispBTree(b); }
高效实现红黑树的插入--c实现
hiluo302的博客
08-30 689
高效实现红黑树的插入引言： 红黑树是一种特殊的二叉排序树，像java，c++的关联数组，如map都是用红黑树实现。 为什么红黑树应用比原生的二叉排序树（BST）和高度平衡二叉树（AVL）要更为广泛？ 答：BST的深度不可控性，比如数据有序插入。不同形态的二叉排序树有不同的性能。 图中a蜕化为线性链表，查找复杂度O（n），b图查找复杂度lg（n）。
数据结构——二叉树的遍历
qq_39637327的博客
01-05 979
二叉树的先序遍历、中序遍历和后序遍历的递归算法，二叉树的非递归算法。 1、括号表示法创建二叉树 2、实现二叉树的递归遍历算法和非递归遍历算法(非递归算法选做)，依次输出二叉树的先序、中序和后序遍历序列 3、二叉树的遍历遍历二叉树，输出结点值大于C的结点，而小于等于C的结点用*替代 4、遍历二叉树，输出结点值小于D的结点，而大于等于D的结点用*替代 main.cpp #include &lt...
生成二叉树和红黑树的helloworld（1）
走在左边
04-14 123
参考的这个视频 视频讲得有点烂，代码错误很多，诶，不过ptree似乎挺好，挺直观的 递归都能变成栈？ 中序遍历，先序遍历，后续遍历都是栈，层序遍历用的队列 bst数的，增删 [code="java"] [root@VM_253_237_tlinux ~/tree]# cat bst.c #include #include #include #define N 1...
生成二叉树和红黑树的helloworld（2）
走在左边
04-18 88
[code="java"] [root@VM_253_237_tlinux ~/tree/print]# cat ctree.h typedef struct node *link; struct node{ int item;link l,r; }; void print_tree(struct node * root); [/code] [code="ja...
生成二叉树和红黑树的helloworld（3）
走在左边
04-20 114
http://bbs.csdn.net/topics/340042324 搜遍了google搜索的所有文章 第14页终于让哥找到了这个方法： [code="java"] /* 这是一个在字符环境中，用ASCII码打印二叉树形状的算法。 在Linux控制台下写的例题，在DOS中稍有点乱。 采用层次遍法。 算法拙劣，仅供初学者做练习，（本人也是初学者，自学数...
生成二叉树和红黑树的helloworld（5） (转)
走在左边
05-08 96
参考http://blog.csdn.net/manuscola/article/details/8635525 https://github.com/killinux/rbtree https://github.com/manuscola/rbtree [code="java"] #include "rbtree.h" #include #include #include ...
使用红黑树实现定时器
G_Super_Mouse的博客
01-25 903
使用红黑树实现定时器 使用的是nginx中使用的红黑树结构,直接从中迁移出来并修改。 通过红黑树实现的时间轮，查询与插入的时间复杂度是O(Logn)。查询第一个节点只需要找树的最左边一个节点即可。 定时器本身就是从头部开始取数据，红黑树就不比跳表这一数据结构匹配定时器实现的更好。 文件rbtree.h #ifndef _NGX_RBTREE_H_INCLUDED_ #define _NGX_RBTREE_H_INCLUDED_ typedef unsigned int ngx_rbtree_ke
排序二叉树, 数据结构中的hello world
03-22
为了解决排序二叉树可能倾斜的问题，引入了平衡二叉树的概念，如AVL树和红黑树。这些平衡二叉树通过旋转等操作保持树的平衡，确保最坏情况下的操作效率也能保持在O(log n)。 **五、总结** 排序二叉树是数据结构中...
红黑树的实现原理和场景
荣山的博客
12-14 356
红黑树的实现原理和场景
七、二叉树、红黑树、HashSet集合、Map集合
电脑高级开关机工程师的博客
12-27 187
JavaSE进阶七，讲述了二叉树、红黑树、HashSet集合、Map集合
二叉树、红黑树、B树、B+树、图、Trie树合集-----妈妈再也不用担心我的“树”拉！
06-13 697
这里把各种树做个总结，分别介绍各个树是什么，什么原理，什么特点，什么情况下使用，另外很多时候它们很多地方是相似的，还要加以区别，之前我身边一个很多年开发的经验的老开发还以为B树、B-树、B+树是三种树，实际没有B-树，它实际就是B树，要是不区分清楚闹出这样的笑话就尴尬了。或者别人说“平衡树”、“满二叉树”、“3阶树”等概念时你一脸懵逼，想吹牛逼但是没词儿，那也挺尴尬，怎么办，一点一点学吧，下面一 一介绍。 一、树的基本术语 若一个结点有子树，那么该结点称为子树根的"双亲"，子树的根是该结点的"孩子"
红黑树
07-18 96
https://blog.csdn.net/q3244676719/article/details/81540830 一...
17.集合Set,HashSet,TreeSet及其底层实现HashMap和红黑树;Collection总结
kazei2073的博客
03-30 4515
ONE.Set集合 one.Set集合的特点 无序,唯一 TWO.HashSet集合 1.底层数据结构是哈希表(是一个元素为链表的数组) 2.那么HashSet如何来实现元素的唯一性的呢？ 通过一HashSet添加字符串的案例查看HashSet中add()的源码，看为什么相同的字符串没有被加入HashSet中 interface Collection { ... } int...
算法设计与分析——并查集（Union-find Disjoint Sets）
热门推荐
冯·诺依曼
02-25 1万+
一些应用涉及将nnn个不同的元素分成一组不相交的集合。这些应用经常需要进行两种特别的操作： 寻找包含给定元素的唯一集合 合并两个集合 一个不相交集合数据结构维护了一个不相交动态集的集合S={S1,S2,⋯ ,Sk}\mathbb{S}=\{S_1, S_2, \cdots, S_k\}S={S1​,S2​,⋯,Sk​}。我们用一个代表来标识每个集合，它是这个集合的某个成员。在一些应用中，我们不关心哪个成员被用来作为代表，仅仅关心的是2次查询动态集合的代表中，如果这些查询没有修改动态集合，则这两次查询应该
十分钟轻松掌握索引的数据结构
haust_允谦的博客
02-23 1286
快速掌握索引的数据结构
磁盘存储链式的 B 树与 B+树
qq_46118239的博客
02-25 1130
推荐一个零声学院免费公开课程，个人觉得老师讲得不错，分享给大家：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习 磁盘存储链式的 B 树与 B+树B树的介绍B树的组成B树的实现 B树的介绍 在讲B树之前我们先讨论一下内存与磁盘有什么区别? 对于这个问题很多朋友或多或少可以说点出来 可能很多朋友答的第一点就是 1.内存快磁盘慢 2.断电以后数据消失,磁盘持久存储
二叉树和红黑树的区别
最新发布
07-28
二叉树和红黑树是两种不同的数据结构，它们有以下区别： 1. 结构特点： - 二叉树是一种每个节点最多有两个子节点的树结构。 - 红黑树是一种自平衡的二叉搜索树，具有一些特定的规则和性质。 2. 平衡性： - ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值