【数据结构6】二叉树的基本操作

news2024/12/26 11:48:03

文章目录

  • ⭐️写在前面的话⭐️
  • 二叉树的一些基本操作
    • 1、结构定义
    • 2、先序创建这棵树
    • 3、按满二叉树方式创建
    • 4、三种递归遍历
    • 5、层次遍历
    • 6、求二叉树的深度
    • 7、求叶子结点数
    • 8、三种非递归遍历
    • 9、先序线索化二叉树
    • 10、先序线索化后遍历
    • 11、中序线索化二叉树
    • 12、中序线索化后遍历
    • 主函数
  • 程序源码
    • 运行截图

⭐️写在前面的话⭐️

📒博客主页： 程序员好冰
🎉欢迎 【点赞👍 关注🔎 收藏⭐️ 留言📝】
📌本文由 程序员好冰 原创，CSDN 首发！
📆入站时间： 🌴2022 年 07 月 13 日🌴
✉️ 是非不入松风耳，花落花开只读书。
💭推荐书籍：📚《Java编程思想》，📚《Java 核心技术卷》
💬参考在线编程网站：🌐牛客网🌐力扣
🍭 作者水平很有限，如果发现错误，一定要及时告知作者哦！感谢感谢！🍭

二叉树的一些基本操作

1、结构定义

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1

#define Nil '#'

#define MAX_SIZE 1024

typedef int Status;
typedef char ElemType;

typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *LChild,*RChild;
    /*
    左标志，0为指向左子节点，1为指向前驱(即线索)
    右标志，0为指向右子节点，1为指向后继(即线索)
    */
    int Ltag,Rtag;//供线索化二叉树使用
}BiTNode,*BiTree;

2、先序创建这棵树

void PreCreateBiTree(BiTree *T)
{
    ElemType ch;
    getchar();
    ch=getchar();
    if(ch==Nil){
        *T=NULL;//说明这棵子树为空
    }
    if(ch!=Nil){
        *T=(BiTree)malloc(sizeof(BiTNode));
        (*T)->data=ch;
        /*线索化线索化二叉树增加的*/(*T)->Ltag=(*T)->Rtag=0;
        PreCreateBiTree(&((*T)->LChild));
        PreCreateBiTree(&((*T)->RChild));
    }
}

3、按满二叉树方式创建

void FullCreateBiTree(BiTree *T)
{
    BiTNode *p;
    BiTNode *arr[MAX_SIZE];
    char ch;
    int i,j;
    while(1){
        scanf("%d",&i);
        getchar();
        if(i==0){
            break;
        }
        if(i!=0){
            ch=getchar();
            if(ch==Nil){
                continue;
            }
            p=(BiTNode*)malloc(sizeof(BiTNode));
            p->data=ch;
            p->Ltag=p->Rtag=0;
            p->LChild=NULL;
            p->RChild=NULL;
            arr[i]=p;
            if(i==1){
                *T=p;
            }
            if(i!=1){
                j=i/2;
                if(i%2==0){
                    arr[j]->LChild=p;
                }
                if(i%2!=0){
                    arr[j]->RChild=p;
                }
            }
        }
    }
}

4、三种递归遍历

//先序递归遍历
void PreOrderTraverse(BiTree T)
{
    if(T==NULL){
        return;
    }
    printf("%c ",T->data);
    PreOrderTraverse(T->LChild);
    PreOrderTraverse(T->RChild);
}


//中序递归遍历
void InOrderTraverse(BiTree T)
{
    if(T==NULL){
        return;
    }
    InOrderTraverse(T->LChild);
    printf("%c ",T->data);
    InOrderTraverse(T->RChild);
}

//后序递归遍历
void PostOrderTraverse(BiTree T)
{
    if(T==NULL){
        return;
    }
    PostOrderTraverse(T->LChild);
    PostOrderTraverse(T->RChild);
    printf("%c ",T->data);
}

5、层次遍历

/*构建队列*/
int front=0,rear=0;
void EnQueue(BiTree *t,BiTree node)
{//结点入队
    if(rear==MAX_SIZE){
        exit(0);
    }
    t[rear++]=node;
}
BiTNode* DeQueue(BiTree *t)
{//结点出队
    if(front==rear){
        exit(0);
    }
    return t[front++];
}
void LevelOrderTraverse(BiTree T)
{
    if(T){
        BiTree t[MAX_SIZE]={0};
        BiTNode *p=NULL;
        p=T;
        EnQueue(t,p);
        while(front<rear)
        {
            p=DeQueue(t);
            printf("%c ",p->data);
            if(p->LChild){
                EnQueue(t,p->LChild);
            }
            if(p->RChild){
                EnQueue(t,p->RChild);
            }
        }
    }
}

6、求二叉树的深度

int BiTreeDepth(BiTree T)
{
    int left=0,right=0;
    if(!T){
        return 0;
    }
    if(T->LChild){
        left=BiTreeDepth(T->LChild);
    }
    if(T->RChild){
        right=BiTreeDepth(T->RChild);
    }
    return left>right?left+1:right+1;
}

7、求叶子结点数

int Count_Leaves(BiTree T)
{
    if(!T){
        return 0;
    }
    if(!(T->LChild)&&!(T->RChild)){
        return 1;
    }
    return Count_Leaves(T->LChild)+Count_Leaves(T->RChild);
}

8、三种非递归遍历

//先序非递归遍历
void PreOrderTraverse2(BiTree T)
{
    if(!T)
    {
        return;
    }
    //创建一个数组来模拟栈
    BiTree stack[MAX_SIZE]={0};
    int top=-1;
    stack[++top]=T;
    while(top>-1){
       BiTree node=stack[top--];
        printf("%c ",node->data);
        if(node->RChild){stack[++top]=node->RChild;}
        if(node->LChild){stack[++top]=node->LChild;}
    }
}

//中序非递归遍历
void InOrderTraverse2(BiTree T)
{
    if(!T){
        return;
    }
    BiTree stack[MAX_SIZE]={0};
    int top=-1;
    BiTree node=T;
    while(top>-1||node!=NULL){
        while(node!=NULL){//一直深入左节点
            stack[++top]=node;
            node=node->LChild;
        }
        node=stack[top--];
        printf("%c ",node->data);
        node=node->RChild;
    }
}

//后序非递归遍历
void PostOrderTraverse2(BiTree T)
{
     if(!T){
        return;
     }
     BiTree stack1[MAX_SIZE]={0};
     BiTree stack2[MAX_SIZE]={0};
     int top1=-1;
     int top2=-1;
     BiTree node=T;
     stack1[++top1]=node;
     while(top1>-1){
        node=stack1[top1--];
        stack2[++top2]=node;
        if(node->LChild!=NULL){stack1[++top1]=node->LChild;}
        if(node->RChild!=NULL){stack1[++top1]=node->RChild;}
    }
    while(top2>-1){
        printf("%c ",stack2[top2--]->data);
    }
}

9、先序线索化二叉树

BiTree pre=NULL;// 全局变量，用于记录前驱节点
void PreOrder_Threading(BiTree T)
{
    if(T==NULL){return;}
    if(T->LChild ==NULL){
        T->Ltag=1;
        T->LChild=pre;//Ltag为1，指向前驱
    }
    if(pre!=NULL && pre->RChild==NULL){
        pre->Rtag=1;
        pre->RChild=T;//Rtag为1，指向后继
    }
    pre=T;
    if(T->Ltag==0){PreOrder_Threading(T->LChild);}
    if(T->Rtag==0){PreOrder_Threading(T->RChild);}
}

10、先序线索化后遍历

void PreOrder_Threading_Traverse(BiTree T)
{
    BiTree temp=T;
    while(temp!=NULL){
        printf("%c ",temp->data);
        if(temp->Ltag==0){
            temp=temp->LChild;
        }else
        {
            temp=temp->RChild;//寻找后继
        }
    }
}

11、中序线索化二叉树

BiTree pre2=NULL;// 全局变量，用于记录前驱节点
void InOrder_Threading(BiTree T)
{
    if(T==NULL){return;}

    if(T->Ltag==0){InOrder_Threading(T->LChild);}//深入到树的最左边的结点
    if(T->LChild ==NULL){
        T->Ltag=1;
        T->LChild=pre2;//Ltag为1，指向前驱
    }
    if(pre2!=NULL && pre2->RChild==NULL){
        pre2->Rtag=1;
        pre2->RChild=T;//Rtag为1，指向后继
    }
    pre2=T;
    if(T->Rtag==0){InOrder_Threading(T->RChild);}
}

12、中序线索化后遍历

void InOrder_Threading_Traverse(BiTree T)
{
    BiTree p=T;
    while(p){
        while(p->Ltag==0){
            p=p->LChild;
        }//深入到最左边的结点
        printf("%c ",p->data);
        while(p->Rtag==1&&p->RChild!=NULL){
            //p->RChild!=NULL说明不是最后一个结点，这个接地那没有后继，指向NULL
            p=p->RChild;//找到后继节点
            printf("%c ",p->data);
        }
        p=p->RChild;
    }
}

主函数

int main()
{
    BiTree T;
    int flag;
    printf("请输入需要的创建方式(1为先序，2为满二叉):");
    scanf("%d",&flag);
    switch(flag)
    {
    case 1://先序创建这棵树
        printf("按先序方式创建这棵树pre_T('#'表示空):\n");
        PreCreateBiTree(&T);
        printf("成功.\n");
        break;
    case 2://按满二叉树方式创建
        printf("按满二叉树方式创建这棵树full_T(以 1 A 为输入0结束例):\n");
        FullCreateBiTree(&T);
        printf("成功.\n");
        break;
    default:
        printf("你输入的序号有误.\n");
        break;
    }

    //递归遍历(三种:前中后)
    printf("先序递归的结果:");
    PreOrderTraverse(T);
    printf("\n");
    printf("成功.\n");
    printf("中序递归的结果:");
    InOrderTraverse(T);
    printf("\n");
    printf("成功.\n");
    printf("后序递归的结果:");
    PostOrderTraverse(T);
    printf("\n");
    printf("成功.\n");

    //非递归遍历(三种:前中后)
    printf("先序非递归的结果:");
    PreOrderTraverse2(T);
    printf("\n");
    printf("成功.\n");
    printf("中序非递归的结果:");
    InOrderTraverse2(T);
    printf("\n");
    printf("成功.\n");
    printf("后序非递归的结果:");
    PostOrderTraverse2(T);
    printf("\n");
    printf("成功.\n");


    //层次遍历
    printf("层序遍历的结果:");
    LevelOrderTraverse(T);
    printf("\n");
    printf("成功.\n");


    //求叶子结点数
    printf("这棵树的叶子结点数为:%d.\n",Count_Leaves(T));
    //求二叉树的深度
    printf("这棵树的深度为:%d.\n",BiTreeDepth(T));

    printf("================\n");
    printf("1、先序线索化.\n");
    printf("2、中序线索化.\n");
    printf("请输入需要线索化的形式:");
    int flag2;
    scanf("%d",&flag2);
    switch(flag2)
    {
        case 1:
            //先序线索化二叉树并遍历
            PreOrder_Threading(T);
            printf("先序线索化二叉树并遍历,结果为:");
            PreOrder_Threading_Traverse(T);
            break;
        case 2:
            //中序线索化二叉树并遍历
            InOrder_Threading(T);
            printf("中序线索化二叉树并遍历,结果为:");
            InOrder_Threading_Traverse(T);
            break;
        default:
            printf("你输入的序号有误.\n");
            break;
    }
    return 0;
}

程序源码

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

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1

#define Nil '#'

#define MAX_SIZE 1024

typedef int Status;
typedef char ElemType;

typedef struct BiTNode
{
    ElemType data;
    struct BiTNode *LChild,*RChild;
    /*
    左标志，0为指向左子节点，1为指向前驱(即线索)
    右标志，0为指向右子节点，1为指向后继(即线索)
    */
    int Ltag,Rtag;//供线索化二叉树使用
}BiTNode,*BiTree;


//先序创建这棵树
void PreCreateBiTree(BiTree *T)
{
    ElemType ch;
    getchar();
    ch=getchar();
    if(ch==Nil){
        *T=NULL;//说明这棵子树为空
    }
    if(ch!=Nil){
        *T=(BiTree)malloc(sizeof(BiTNode));
        (*T)->data=ch;
        /*线索化线索化二叉树增加的*/(*T)->Ltag=(*T)->Rtag=0;
        PreCreateBiTree(&((*T)->LChild));
        PreCreateBiTree(&((*T)->RChild));
    }
}

//按满二叉树方式创建
void FullCreateBiTree(BiTree *T)
{
    BiTNode *p;
    BiTNode *arr[MAX_SIZE];
    char ch;
    int i,j;
    while(1){
        scanf("%d",&i);
        getchar();
        if(i==0){
            break;
        }
        if(i!=0){
            ch=getchar();
            if(ch==Nil){
                continue;
            }
            p=(BiTNode*)malloc(sizeof(BiTNode));
            p->data=ch;
            p->Ltag=p->Rtag=0;
            p->LChild=NULL;
            p->RChild=NULL;
            arr[i]=p;
            if(i==1){
                *T=p;
            }
            if(i!=1){
                j=i/2;
                if(i%2==0){
                    arr[j]->LChild=p;
                }
                if(i%2!=0){
                    arr[j]->RChild=p;
                }
            }
        }
    }
}

//先序递归遍历
void PreOrderTraverse(BiTree T)
{
    if(T==NULL){
        return;
    }
    printf("%c ",T->data);
    PreOrderTraverse(T->LChild);
    PreOrderTraverse(T->RChild);
}


//中序递归遍历
void InOrderTraverse(BiTree T)
{
    if(T==NULL){
        return;
    }
    InOrderTraverse(T->LChild);
    printf("%c ",T->data);
    InOrderTraverse(T->RChild);
}

//后序递归遍历
void PostOrderTraverse(BiTree T)
{
    if(T==NULL){
        return;
    }
    PostOrderTraverse(T->LChild);
    PostOrderTraverse(T->RChild);
    printf("%c ",T->data);
}

//层次遍历
/*构建队列*/
int front=0,rear=0;
void EnQueue(BiTree *t,BiTree node)
{//结点入队
    if(rear==MAX_SIZE){
        exit(0);
    }
    t[rear++]=node;
}
BiTNode* DeQueue(BiTree *t)
{//结点出队
    if(front==rear){
        exit(0);
    }
    return t[front++];
}
void LevelOrderTraverse(BiTree T)
{
    if(T){
        BiTree t[MAX_SIZE]={0};
        BiTNode *p=NULL;
        p=T;
        EnQueue(t,p);
        while(front<rear)
        {
            p=DeQueue(t);
            printf("%c ",p->data);
            if(p->LChild){
                EnQueue(t,p->LChild);
            }
            if(p->RChild){
                EnQueue(t,p->RChild);
            }
        }
    }
}

//求二叉树的深度
int BiTreeDepth(BiTree T)
{
    int left=0,right=0;
    if(!T){
        return 0;
    }
    if(T->LChild){
        left=BiTreeDepth(T->LChild);
    }
    if(T->RChild){
        right=BiTreeDepth(T->RChild);
    }
    return left>right?left+1:right+1;
}

//求叶子结点数
int Count_Leaves(BiTree T)
{
    if(!T){
        return 0;
    }
    if(!(T->LChild)&&!(T->RChild)){
        return 1;
    }
    return Count_Leaves(T->LChild)+Count_Leaves(T->RChild);
}


//先序非递归遍历
void PreOrderTraverse2(BiTree T)
{
    if(!T)
    {
        return;
    }
    //创建一个数组来模拟栈
    BiTree stack[MAX_SIZE]={0};
    int top=-1;
    stack[++top]=T;
    while(top>-1){
       BiTree node=stack[top--];
        printf("%c ",node->data);
        if(node->RChild){stack[++top]=node->RChild;}
        if(node->LChild){stack[++top]=node->LChild;}
    }
}

//中序非递归遍历
void InOrderTraverse2(BiTree T)
{
    if(!T){
        return;
    }
    BiTree stack[MAX_SIZE]={0};
    int top=-1;
    BiTree node=T;
    while(top>-1||node!=NULL){
        while(node!=NULL){//一直深入左节点
            stack[++top]=node;
            node=node->LChild;
        }
        node=stack[top--];
        printf("%c ",node->data);
        node=node->RChild;
    }
}

//后序非递归遍历
void PostOrderTraverse2(BiTree T)
{
     if(!T){
        return;
     }
     BiTree stack1[MAX_SIZE]={0};
     BiTree stack2[MAX_SIZE]={0};
     int top1=-1;
     int top2=-1;
     BiTree node=T;
     stack1[++top1]=node;
     while(top1>-1){
        node=stack1[top1--];
        stack2[++top2]=node;
        if(node->LChild!=NULL){stack1[++top1]=node->LChild;}
        if(node->RChild!=NULL){stack1[++top1]=node->RChild;}
    }
    while(top2>-1){
        printf("%c ",stack2[top2--]->data);
    }
}

/*=======================================================================*/


//先序线索化二叉树
BiTree pre=NULL;// 全局变量，用于记录前驱节点
void PreOrder_Threading(BiTree T)
{
    if(T==NULL){return;}
    if(T->LChild ==NULL){
        T->Ltag=1;
        T->LChild=pre;//Ltag为1，指向前驱
    }
    if(pre!=NULL && pre->RChild==NULL){
        pre->Rtag=1;
        pre->RChild=T;//Rtag为1，指向后继
    }
    pre=T;
    if(T->Ltag==0){PreOrder_Threading(T->LChild);}
    if(T->Rtag==0){PreOrder_Threading(T->RChild);}
}

//先序线索化后遍历
void PreOrder_Threading_Traverse(BiTree T)
{
    BiTree temp=T;
    while(temp!=NULL){
        printf("%c ",temp->data);
        if(temp->Ltag==0){
            temp=temp->LChild;
        }else
        {
            temp=temp->RChild;//寻找后继
        }
    }
}

/*=======================================================================*/

//中序线索化二叉树
BiTree pre2=NULL;// 全局变量，用于记录前驱节点
void InOrder_Threading(BiTree T)
{
    if(T==NULL){return;}

    if(T->Ltag==0){InOrder_Threading(T->LChild);}//深入到树的最左边的结点
    if(T->LChild ==NULL){
        T->Ltag=1;
        T->LChild=pre2;//Ltag为1，指向前驱
    }
    if(pre2!=NULL && pre2->RChild==NULL){
        pre2->Rtag=1;
        pre2->RChild=T;//Rtag为1，指向后继
    }
    pre2=T;
    if(T->Rtag==0){InOrder_Threading(T->RChild);}
}

//中序线索化后遍历
void InOrder_Threading_Traverse(BiTree T)
{
    BiTree p=T;
    while(p){
        while(p->Ltag==0){
            p=p->LChild;
        }//深入到最左边的结点
        printf("%c ",p->data);
        while(p->Rtag==1&&p->RChild!=NULL){
            //p->RChild!=NULL说明不是最后一个结点，这个接地那没有后继，指向NULL
            p=p->RChild;//找到后继节点
            printf("%c ",p->data);
        }
        p=p->RChild;
    }
}

/*=======================================================================*/

int main()
{
    BiTree T;
    int flag;
    printf("请输入需要的创建方式(1为先序，2为满二叉):");
    scanf("%d",&flag);
    switch(flag)
    {
    case 1://先序创建这棵树
        printf("按先序方式创建这棵树pre_T('#'表示空):\n");
        PreCreateBiTree(&T);
        printf("成功.\n");
        break;
    case 2://按满二叉树方式创建
        printf("按满二叉树方式创建这棵树full_T(以 1 A 为输入0结束例):\n");
        FullCreateBiTree(&T);
        printf("成功.\n");
        break;
    default:
        printf("你输入的序号有误.\n");
        break;
    }

    //递归遍历(三种:前中后)
    printf("先序递归的结果:");
    PreOrderTraverse(T);
    printf("\n");
    printf("成功.\n");
    printf("中序递归的结果:");
    InOrderTraverse(T);
    printf("\n");
    printf("成功.\n");
    printf("后序递归的结果:");
    PostOrderTraverse(T);
    printf("\n");
    printf("成功.\n");

    //非递归遍历(三种:前中后)
    printf("先序非递归的结果:");
    PreOrderTraverse2(T);
    printf("\n");
    printf("成功.\n");
    printf("中序非递归的结果:");
    InOrderTraverse2(T);
    printf("\n");
    printf("成功.\n");
    printf("后序非递归的结果:");
    PostOrderTraverse2(T);
    printf("\n");
    printf("成功.\n");


    //层次遍历
    printf("层序遍历的结果:");
    LevelOrderTraverse(T);
    printf("\n");
    printf("成功.\n");


    //求叶子结点数
    printf("这棵树的叶子结点数为:%d.\n",Count_Leaves(T));
    //求二叉树的深度
    printf("这棵树的深度为:%d.\n",BiTreeDepth(T));

    printf("================\n");
    printf("1、先序线索化.\n");
    printf("2、中序线索化.\n");
    printf("请输入需要线索化的形式:");
    int flag2;
    scanf("%d",&flag2);
    switch(flag2)
    {
        case 1:
            //先序线索化二叉树并遍历
            PreOrder_Threading(T);
            printf("先序线索化二叉树并遍历,结果为:");
            PreOrder_Threading_Traverse(T);
            break;
        case 2:
            //中序线索化二叉树并遍历
            InOrder_Threading(T);
            printf("中序线索化二叉树并遍历,结果为:");
            InOrder_Threading_Traverse(T);
            break;
        default:
            printf("你输入的序号有误.\n");
            break;
    }
    return 0;
}

运行截图

image-20230530141756319

🚀先看后赞，养成习惯！🚀

🚀 先看后赞，养成习惯！🚀

🎈觉得文章写得不错的老铁们，点赞评论关注走一波！谢谢啦！🎈

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/591520.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MySQL进阶- SQL优化和视图

MySQL进阶- SQL优化和视图

目录 SQL优化插入数据时的SQL优化&#xff08;insert优化&#xff0c;和大批量数据插入&#xff09;主键优化order by优化&#xff08;排序操作的优化&#xff09;group by优化&#xff08;分组优化&#xff09;limit优化&#xff08;分页查询优化&#xff09; SQL优化 插入数…
阅读更多...
[RUST/腐蚀]Windows-开服服务端下载以及配置

[RUST/腐蚀]Windows-开服服务端下载以及配置

一、前置要求 1.SteamCMD&#xff1a;SteamCMD - Valve Developer Communityhttps://developer.valvesoftware.com/wiki/SteamCMD 2.通过SteamCMD下载RUST/腐蚀服务端。 二、SteamCMD 注意&#xff1a;所有目录均应避免出现中文。 1.建立SteamCMD文件夹&#xff0c;如 D:\st…
阅读更多...
准备入门python的一些建议

准备入门python的一些建议

提醒&#xff1a;一下内容只代表个人观点 从18年左右开始&#xff0c;python的广告就被打得满天飞&#xff0c;网上各种吹嘘python这门语言的广告五花八门&#xff0c;当然也有一些人看完这些广告后感觉python非常的高大上&#xff0c;然后就入门学习了python&#xff0c;我就…
阅读更多...
【测试基础02】

【测试基础02】

测试基础02 一、HTML基础二、Python导入三方模块三、安装webgrock驱动四、元素定位(1)、元素定位工具(2)、元素定位方式(3)、XPATH路径(3)、CSS选择器 五、Selenium WebDriver初步应用(1)、基本方法(2)、测试案例1(3)、测试案例2(3)、测试案例3 六、获取元素信息的方法七、fram…
阅读更多...
价值5000元以上的某马大数据全套视频【强烈推荐】

价值5000元以上的某马大数据全套视频【强烈推荐】

某马大数据 01、阶段一 Python大数据开发基础 01、第一章大数据介绍及开发环境 02、第二章 linux命令 03、第三章 MySQL数据库 04、第四章 excel的使用 05、第五章 kettle的使用 06、第六章 数据分析及可视化 07、第七章 大数据框架与数仓基础 08、第八章 数仓实战项目 …
阅读更多...
3-网络初识——协议

3-网络初识——协议

目录 1.概念 ①语法&#xff1a;即数据与控制信息的结构或格式。 ②语义&#xff1a;即需要发出何种控制信息&#xff0c;完成何种动作以及做出何种响应。 ③时序&#xff1a;即事件实现顺序的详细说明。 2.作用 3.知名协议的默认端口 4.协议分层 4.1.什么是协议分层 …
阅读更多...
chatgpt赋能python：Python中的转置操作：理解与实践

chatgpt赋能python：Python中的转置操作：理解与实践

Python中的转置操作&#xff1a;理解与实践 在Python中&#xff0c;可以使用转置操作来将矩阵或数组的行和列交换位置。转置操作不仅在数学和统计学上有广泛应用&#xff0c;也在机器学习和数据分析领域中非常重要。在本文中&#xff0c;我们将深入探讨Python中的转置操作的基…
阅读更多...
C# | 使用Memory＜T＞高效地读写内存数据

C# | 使用Memory＜T＞高效地读写内存数据

C# | 使用Memory高效地读写内存数据 文章目录 C# | 使用Memory<T>高效地读写内存数据前言Memory<T>介绍示例结束语 前言 Memory<T>是C# 7.2版本中引入的一种新类型&#xff0c;可以更加高效地读写内存数据。本文将介绍它的用途以及如何使用它来优化代码。 P…
阅读更多...
机器视觉康耐视智能相机Insight-手眼标定详细步骤

机器视觉康耐视智能相机Insight-手眼标定详细步骤

(Q有答疑)康耐视VisionPro工具与脚本入门级系列教程2023 In-Sight 智能相机包含标定手眼的工具 CalibrateGrid，用手动的标定方式，即将康耐视标定片固定在运动平台上，然后手动输入电机位置坐标，要保证电机在 X 方向移动一次，Y 方向移动一次，旋转两次角度，切旋转角度差不能…
阅读更多...
chatgpt赋能python：Python中的绝对值函数

chatgpt赋能python：Python中的绝对值函数

Python中的绝对值函数 在Python编程语言中&#xff0c;绝对值函数是一个非常重要和常用的函数。它可以帮助我们快速地计算一个数的绝对值&#xff0c;而不需要手动使用if语句来处理。在本文中&#xff0c;我们将介绍Python中的绝对值函数&#xff0c;并且讨论它的一些应用。 …
阅读更多...
Linux 上安装 PostgreSQL——Ubuntu

Linux 上安装 PostgreSQL——Ubuntu

打开 PostgreSQL 官网 PostgreSQL: The worlds most advanced open source database&#xff0c;点击菜单栏上的 Download &#xff0c;可以看到这里包含了很多平台的安装包&#xff0c;包括 Linux、Windows、Mac OS等 。 Linux 我们可以看到支持 Ubuntu 和 Red Hat 等各个平台…
阅读更多...
ARC学习（1）基本编程模型认识

ARC学习（1）基本编程模型认识

笔者有幸接触了arc处理器&#xff0c;今天就来简单了解一下arc的编程模型 1、ARC基本认识 ARC IP是synopsys 新思公司开发的一个系列ARC IP核&#xff0c;其是一家电子设计自动化&#xff08;EDA&#xff09;解决方案提供商。其主页地址在这里&#xff01;业务主要如下&#x…
阅读更多...
chatgpt赋能python：Python中的按位取反

chatgpt赋能python：Python中的按位取反

Python中的按位取反 Python中的按位取反是一种常见的操作&#xff0c;它可以让我们快速地对二进制的数字进行取反操作。在本文中&#xff0c;我们将介绍Python中的按位取反操作&#xff0c;并探讨它的用途和示例。 什么是按位取反 按位取反是一种将二进制数中的每一位进行反…
阅读更多...
Vue之前后端交互模式

Vue之前后端交互模式

1. fetch-API的使用 1.1 init <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta http-equiv"X-UA-Compatible" content"IEedge"><meta name"viewport" content"…
阅读更多...
手机常识汇总

手机常识汇总

目录 一、手机历史介绍 第一代模拟制式手机(1G) 什么是模拟网? 模拟网络与数字网络的区别 数字通信与模拟通信相比具有明显的优点: 第二代数字手机(2G) 什么是“GSM” 什么是 “CDMA”? GSM 数字机和模拟手机话音相比 什么是“GSM/CDMA 双模机”? 什么是“TDMA”…
阅读更多...
FinChat.io，金融领域的chatgpt

FinChat.io，金融领域的chatgpt

投资股票是一个充满挑战的过程,随着市场的起起伏伏,要抓住每一个机会,同时规避各种风险,这需要投资者具有敏锐的洞察力和快速的决策能力。不过现在有好消息,一款人工智能聊天机器人 FinChat.io 诞生了!它能帮助投资者分析市场,挖掘有潜力的股票,并提供买卖的实时建议 --------…
阅读更多...
Java与数据库：JDBC和ORM框架的使用和效率优化

Java与数据库：JDBC和ORM框架的使用和效率优化

第一章&#xff1a;引言 随着互联网的快速发展和大数据时代的到来&#xff0c;数据库在软件开发中起到了至关重要的作用。Java作为一门强大而广泛应用的编程语言&#xff0c;提供了多种与数据库交互的方式。其中&#xff0c;JDBC和ORM框架是最常用的两种方式。本文将深入探讨J…
阅读更多...
OpenWRT 实现Exsi8单个公网ip管理与访问

OpenWRT 实现Exsi8单个公网ip管理与访问

一台Dell R720机器 内存256G(64G*4)硬盘SSD 8T(1T*8)搭建了一个裸金属k8s集群(对比阿里云单台4核8G的费用不相上下) 机房上架提供了一个公网ip 需要一个公网ip能实现exsi虚拟机管理 又可以让虚拟机实现web访问 是终通过OpenWRT实现 OpenWRT实现步骤 1、官网访问并下载img镜…
阅读更多...
Kotlin笔记（零）简介

Kotlin笔记（零）简介

百度百科简介 2017年&#xff0c;google公司在官网上宣布Kotlin成为Android的开发语言&#xff0c;使编码效率大增。Kotlin 语言由 JetBrains 公司推出&#xff0c;这是一个面向JVM的新语言 参考资料 官网&#xff1a;https://kotlinlang.org/中文官网&#xff1a;https://w…
阅读更多...
C++ 遍历算法

C++ 遍历算法

&#x1f914;遍历算法&#xff1a; &#x1f642;1.for_each 遍历容器 &#x1f50d;介绍&#xff1a; 在C中&#xff0c;for_each是一个用于遍历容器元素并对它们进行操作的算法。它通常有三个参数&#xff1a; &#x1f4d6;1. 容器的起始位置&#xff08;iterator&am…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023