数据结构--树（c 代码部分）（王道书、考研适用）

已于 2023-08-02 16:57:51 修改
阅读量217 收藏 3
点赞数 1
文章标签： 数据结构 算法
于 2023-08-02 16:56:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73918713/article/details/132065972
版权

一、结构体声明

1.二叉树的结构体定义

//树结构体定义
typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

2.栈，循环队列，链式队列

// 辅助队列结构体定义
typedef struct tag{
    BiTree p;
    struct tag *pnext;
}tag_t,*ptag_t;

//  栈结构体定义
#define MaxSize 100
typedef BiTree elemtype; //栈队列数组指针
typedef struct{
    elemtype data[MaxSize];
    int top;   //指向栈顶元素
 }SqStack;//sequence 顺序
//abcdefghigk
//循环队列结构体定义
#define Maxsize 10
typedef struct {
	elemtype data[Maxsize];
	int front, rear;
	int tag;  
}SqQueue;

3、循环队列代码

//循环队列
void InitQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;
}
bool QueueEmpty(SqQueue Q) {  //队列判空
	if (Q.rear == Q.front)  return true;
	else return  false;
}
bool EnQueue(SqQueue& Q, elemtype x) {
	if ((Q.rear+1)%Maxsize == Q.front)  return false;
	Q.data[Q.rear] = x;
	//循环队列
	Q.rear = (Q.rear + 1) % Maxsize;
	return true;
}
bool DeQueue(SqQueue& Q, elemtype &x) {
	if (Q.rear == Q.front) return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % Maxsize; return true;
}
bool GetHead(SqQueue& Q, elemtype &x) {
	if (Q.rear == Q.front) return false;
	x = Q.data[Q.front];
	return  true;
}

4.栈代码

//s.top == -1 栈
void InitStack(SqStack &S){
    S.top = -1;
}
bool StackEmpty(SqStack S){
   if(S.top==-1)  return true; //栈空
   else  return false; //不空 
}
bool Push(SqStack &S,elemtype x){
   if(S.top==MaxSize-1)  return false;
   S.data[++S.top] = x;
   return true;
}
bool Pop(SqStack &S,elemtype &x){
   if(S.top==-1) return false;
   x = S.data[S.top--];  return true;
}
bool GetTop(SqStack S,elemtype &x){
   if(S.top==-1) return false;
   x = S.data[S.top]; return true;
}

二、二叉树的遍历

1.先序遍历

void PreOrder(BiTree p){     //深度优先遍历
    if(p!=NULL){
        cout<<p->c<<" ";
        PreOrder(p->lchild); //打印左子树
        PreOrder(p->rchild); //打印右子树
    } 
}

2.中序遍历

void InOrder(BiTree p){    
    if(p!=NULL){
        InOrder(p->lchild);
        cout<<p->c<<" ";
        InOrder(p->rchild);
    }  
}

3.后序遍历

void PostOrder(BiTree p){
    if(p!=NULL){
       PostOrder(p->lchild);
       PostOrder(p->rchild);
       cout<<p->c<<" ";  
    }
}

4.非递归先序遍历 

void PreOrder2(BiTree p,SqStack &S){
    InitStack(S); BiTree r = p;
    while(r || !StackEmpty(S) ){
        if(r){
            cout << r->c<< " ";
            Push(S,r);
            r = r->lchild;
        }else {
            Pop(S,r);
            r = r->rchild;
        }
    }
}

5.非递归中序遍历

void InOrder2(BiTree p , SqStack &S){
    InitStack(S); BiTree r = p;  // 初始化栈 ， 指向根节点
    while(r || !StackEmpty(S)){ // 树空结点  或者栈空
        if(r){                  //压栈  直到左子树为空
            Push(S,r);          
            r = r->lchild ;
        }else {
            Pop(S,r);
            cout << r->c << " ";
            r = r->rchild ; 
        }
    }
}

6.非递归后序遍历

void PostOrder2(BiTree Tr,SqStack &S){
    InitStack(S);
    BiTNode* p = Tr; BiTNode *r = NULL;
    while(p || !StackEmpty(S)){
        if(p){
          Push(S, p);
          p = p -> lchild;
        }else{
            GetTop(S , p);
            if(p->rchild && p->rchild != r){
                p = p->rchild;
            }else{
                Pop(S , p);
                cout<< p->c << " ";
                r = p;
                p = NULL;
            }//else
        }//while
    }
}

7.层次遍历

void Levelorder(BiTree T , SqQueue &Q){
    InitQueue(Q); BiTree p; EnQueue(Q , T);
    while(!QueueEmpty(Q)){
       DeQueue(Q , p); cout<< p->c << " " ;
       if(p->lchild != NULL) EnQueue(Q , p->lchild) ;
       if(p->rchild != NULL) EnQueue(Q , p->rchild);
    }
}

三、二叉树的常用算法

1.自下而上，从右到左的层次遍历

void deLevelOrder(BiTree T , SqQueue &Q , SqStack &S){
    InitQueue(Q); InitStack(S);
    BiTree p; EnQueue(Q , T);
    while(!QueueEmpty(Q)){
        DeQueue(Q , p); Push(S , p);
        if(p->lchild != NULL) EnQueue(Q , p->lchild);
        if(p->rchild != NULL) EnQueue(Q , p->rchild); 
    }
    while(!StackEmpty(S)) {
        Pop(S , p);
        cout<< p->c <<" "; 
    }
    cout<<endl<<endl;
}

2.计算一棵给定二叉树的所有双分支结点数个数

void DoubleNode(BiTree p , int &count){
   if(p != NULL){
        if(p->lchild != NULL && p->rchild != NULL){
           count ++ ; 
        } 
        DoubleNode(p->lchild , count); //打印左子树
        DoubleNode(p->rchild , count); //打印右子树
    } 
}

3.判定给定二叉树是否为完全二叉树

bool IsComplete(BiTree T , SqQueue &Q){
    InitQueue(Q); BiTree p;
    if(!T)  return 1;
    EnQueue(Q , T);
    while(!QueueEmpty(Q)){
        DeQueue(Q , p);
        if(p){
            EnQueue(Q , p->lchild);
            EnQueue(Q , p->rchild); 
        }else {
            while(!QueueEmpty(Q)){
              DeQueue(Q , p);
              if(p) return 0 ;
            }//while
        }
    }
    return 1;
}

4.树b 交换左右子树

void SwapLRChild(BiTree p){
    if(p != NULL){
        BiTree temp = p->lchild;
        p->lchild = p->rchild;
        p->rchild = temp;
        SwapLRChild(p->lchild);
        SwapLRChild(p->rchild);
    }
}

5.先序遍历中第k个结点的值

void KpreOreder(BiTree p , int k){
    if(p!=NULL){
        num++;
        if (num == k) cout<< p->c <<endl;   
        KpreOreder(p->lchild , k); //打印左子树
        KpreOreder(p->rchild , k); //打印右子树
    } 
}

四、汇总

       把所有的代码汇总到一起供参考。还有一部分没写完，这是王道书上的课后题，然后写完了会及时更新。

#include<iostream>
#include<cstring>
using namespace std;
int count = 0; int num = 0;
//树结构体定义
typedef char BiElemType;
typedef struct BiTNode{
    BiElemType c;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;

// 辅助队列结构体定义
typedef struct tag{
    BiTree p;
    struct tag *pnext;
}tag_t,*ptag_t;

//  栈结构体定义
#define MaxSize 100
typedef BiTree elemtype; //栈队列数组指针
typedef struct{
    elemtype data[MaxSize];
    int top;   //指向栈顶元素
 }SqStack;//sequence 顺序
//abcdefghigk
//循环队列结构体定义
#define Maxsize 10
typedef struct {
	elemtype data[Maxsize];
	int front, rear;
	int tag;  
}SqQueue;

//  辅助队列
/**************************************************/

void testQueue();
void InitQueue(SqQueue &Q);
bool QueueEmpty(SqQueue Q);
bool EnQueue(SqQueue &Q, elemtype x);
bool DeQueue(SqQueue &Q, elemtype &x);

/**************************************************/
//    辅助栈
/**************************************************/

void InitStack(SqStack &S);//创建
bool Push(SqStack &S,elemtype x);//压栈
bool Pop(SqStack &S,elemtype &x);//弹出
bool GetTop(SqStack S,elemtype &x);//读栈顶元素
bool StackEmpty(SqStack S);
bool brackCheck(char str[], int length);

/**************************************************/
//树函数区
void PreOrder(BiTree p); //先序遍历
void InOrder(BiTree p);  //中序遍历
void PostOrder(BiTree p);//后序遍历
void PreOrder2(BiTree p, SqStack &S); //非递归中序遍历
void InOrder2(BiTree p, SqStack &S); //非递归先序遍历
void PostOrder2(BiTree p, SqStack &S ); //非递归先序遍历
void Levelorder(BiTree T , SqQueue &Q); //层序遍历

void deLevelOrder(BiTree T , SqQueue &Q , SqStack &S);//逆向输出层序遍历
void DoubleNode(BiTree p , int &count);
bool IsComplete(BiTree T , SqQueue &Q);
void SwapLRChild(BiTree p);/*树b 交换左右子树*/
void KpreOreder(BiTree p , int k);/*先序遍历中第k个结点的值*/
/**************************************************/

int main(){
    SqStack S;SqQueue Q; 
    int k ;
    BiTree pnew;
    BiTree tree = NULL; //tree是指向树根的，代表树
    char c;
    ptag_t phead = NULL,ptail = NULL,listpnew = NULL,pcur=NULL;
    while(scanf("%c",&c)){
         if( c =='\n')   break;
            pnew = (BiTree)calloc(1,sizeof(BiTNode));
            pnew->c = c;
            listpnew = (ptag_t)calloc(1,sizeof(tag_t));
            listpnew->p = pnew;
    
        if(NULL == tree){
            tree = pnew ; //tree 指向树的根节点
            phead = listpnew;//第一个结点即是队列头，也是队列尾。
            ptail = listpnew;
            pcur = listpnew;
            continue;
        }else {
            ptail->pnext = listpnew;
            ptail = listpnew;
            //接下来把b结点放入树中
        
        } 
        if(pcur->p->lchild == NULL) {
            pcur->p->lchild = pnew;//左孩子为空，就放入左孩子
        }
        else if(pcur->p->rchild == NULL){
            pcur->p->rchild = pnew;//右孩子为空，就放入右孩子
            pcur = pcur->pnext; //当前结点左右孩子都有了，pcur就指向下一个结点
        }  
    } 

    /*先序遍历*/
    cout<<"preorder" << "先序遍历" <<endl;
    PreOrder(tree);      cout<<endl;
    /*非递归先序遍历*/
    cout<<"preorder2"<< "非递归先序遍历" <<endl;
    PreOrder2(tree , S);  cout<<endl; cout<<endl;
    
    /*中序遍历*/
    cout<<"inorder" << "中序遍历" <<endl;
    InOrder(tree);       cout<<endl;
    /*非递归中序遍历*/
    cout<<"inorder2"<< "非递归中序遍历" <<endl;
    InOrder2(tree , S);   cout<<endl; cout<<"\n";

    /*后序遍历*/
    cout<<"postorder" << "后序遍历" <<endl;
    PostOrder(tree); cout<<endl;
    /*非递归后序遍历*/
    cout<<"postorder2" << "非递归后序遍历" <<endl;
    PostOrder2(tree , S); cout<<endl; cout<<endl;
    
    /*层序遍历*/
    cout<<"leverorder" << "层序遍历" <<endl;
    Levelorder(tree , Q);cout<<endl; cout<<endl;
    /*逆向输出层序遍历*/
    cout<<"逆向输出层序遍历"<<endl;
    deLevelOrder(tree , Q , S);
   
    /*二叉树双分支结点数*/
    cout<<"二叉树双分支结点数"<<endl;
    DoubleNode(tree , count); cout<< count <<endl;

    /*给定二叉树是否为完全二叉树*/
    cout<<"给定二叉树是否为完全二叉树"<<endl;
    cout<<IsComplete(tree , Q)<<endl;

    /*树b 交换左右子树*/
    // cout<<"交换树b的左右子树"<<endl;
    // SwapLRChild(tree);
    // Levelorder(tree , Q);cout<<endl; cout<<endl;

    /*先序遍历中第k个结点的值*/
    cout<<"第k个结点的值"<<endl;
    KpreOreder(tree , 5); cout<<endl;
    return 0;
}

void PreOrder(BiTree p){     //深度优先遍历
    if(p!=NULL){
        cout<<p->c<<" ";
        PreOrder(p->lchild); //打印左子树
        PreOrder(p->rchild); //打印右子树
    } 
} 
void InOrder(BiTree p){    
    if(p!=NULL){
        InOrder(p->lchild);
        cout<<p->c<<" ";
        InOrder(p->rchild);
    }  
}
void PostOrder(BiTree p){
    if(p!=NULL){
       PostOrder(p->lchild);
       PostOrder(p->rchild);
       cout<<p->c<<" ";  
    }
}
void InOrder2(BiTree p , SqStack &S){
    InitStack(S); BiTree r = p;  // 初始化栈 ， 指向根节点
    while(r || !StackEmpty(S)){ // 树空结点  或者栈空
        if(r){                  //压栈  直到左子树为空
            Push(S,r);          
            r = r->lchild ;
        }else {
            Pop(S,r);
            cout << r->c << " ";
            r = r->rchild ; 
        }
    }
}
void PreOrder2(BiTree p,SqStack &S){
    InitStack(S); BiTree r = p;
    while(r || !StackEmpty(S) ){
        if(r){
            cout << r->c<< " ";
            Push(S,r);
            r = r->lchild;
        }else {
            Pop(S,r);
            r = r->rchild;
        }
    }
}
void PostOrder2(BiTree Tr,SqStack &S){
    InitStack(S);
    BiTNode* p = Tr; BiTNode *r = NULL;
    while(p || !StackEmpty(S)){
        if(p){
          Push(S, p);
          p = p -> lchild;
        }else{
            GetTop(S , p);
            if(p->rchild && p->rchild != r){
                p = p->rchild;
            }else{
                Pop(S , p);
                cout<< p->c << " ";
                r = p;
                p = NULL;
            }//else
        }//while
    }
}
void Levelorder(BiTree T , SqQueue &Q){
    InitQueue(Q); BiTree p; EnQueue(Q , T);
    while(!QueueEmpty(Q)){
       DeQueue(Q , p); cout<< p->c << " " ;
       if(p->lchild != NULL) EnQueue(Q , p->lchild) ;
       if(p->rchild != NULL) EnQueue(Q , p->rchild);
    }
}

//自下而上，从右到左的层次遍历算法
void deLevelOrder(BiTree T , SqQueue &Q , SqStack &S){
    InitQueue(Q); InitStack(S);
    BiTree p; EnQueue(Q , T);
    while(!QueueEmpty(Q)){
        DeQueue(Q , p); Push(S , p);
        if(p->lchild != NULL) EnQueue(Q , p->lchild);
        if(p->rchild != NULL) EnQueue(Q , p->rchild); 
    }
    while(!StackEmpty(S)) {
        Pop(S , p);
        cout<< p->c <<" "; 
    }
    cout<<endl<<endl;
}
//非递归算法求二叉树高度
void BTreeHigh(BiTree T );
//计算一棵给定二叉树的所有双分支结点数个数
void DoubleNode(BiTree p , int &count){
   if(p != NULL){
        if(p->lchild != NULL && p->rchild != NULL){
           count ++ ; 
        } 
        DoubleNode(p->lchild , count); //打印左子树
        DoubleNode(p->rchild , count); //打印右子树
    } 
}
//判定给定二叉树是否为完全二叉树
bool IsComplete(BiTree T , SqQueue &Q){
    InitQueue(Q); BiTree p;
    if(!T)  return 1;
    EnQueue(Q , T);
    while(!QueueEmpty(Q)){
        DeQueue(Q , p);
        if(p){
            EnQueue(Q , p->lchild);
            EnQueue(Q , p->rchild); 
        }else {
            while(!QueueEmpty(Q)){
              DeQueue(Q , p);
              if(p) return 0 ;
            }//while
        }
    }
    return 1;
}
/*树b 交换左右子树*/
void SwapLRChild(BiTree p){
    if(p != NULL){
        BiTree temp = p->lchild;
        p->lchild = p->rchild;
        p->rchild = temp;
        SwapLRChild(p->lchild);
        SwapLRChild(p->rchild);
    }
}
/*先序遍历中第k个结点的值*/
void KpreOreder(BiTree p , int k){
    if(p!=NULL){
        num++;
        if (num == k) cout<< p->c <<endl;   
        KpreOreder(p->lchild , k); //打印左子树
        KpreOreder(p->rchild , k); //打印右子树
    } 
}

/*2017统考真题*/
void InOrder(BiTree p){
    
}





//s.top == -1 栈
void InitStack(SqStack &S){
    S.top = -1;
}
bool StackEmpty(SqStack S){
   if(S.top==-1)  return true; //栈空
   else  return false; //不空 
}
bool Push(SqStack &S,elemtype x){
   if(S.top==MaxSize-1)  return false;
   S.data[++S.top] = x;
   return true;
}
bool Pop(SqStack &S,elemtype &x){
   if(S.top==-1) return false;
   x = S.data[S.top--];  return true;
}
bool GetTop(SqStack S,elemtype &x){
   if(S.top==-1) return false;
   x = S.data[S.top]; return true;
}

//循环队列
void InitQueue(SqQueue &Q) {
	Q.rear = Q.front = 0;
}
bool QueueEmpty(SqQueue Q) {  //队列判空
	if (Q.rear == Q.front)  return true;
	else return  false;
}
bool EnQueue(SqQueue& Q, elemtype x) {
	if ((Q.rear+1)%Maxsize == Q.front)  return false;
	Q.data[Q.rear] = x;
	//循环队列
	Q.rear = (Q.rear + 1) % Maxsize;
	return true;
}
bool DeQueue(SqQueue& Q, elemtype &x) {
	if (Q.rear == Q.front) return false;
	x = Q.data[Q.front];
	Q.front = (Q.front + 1) % Maxsize; return true;
}
bool GetHead(SqQueue& Q, elemtype &x) {
	if (Q.rear == Q.front) return false;
	x = Q.data[Q.front];
	return  true;
}

Data_Dtructure
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
2009-2021计算机考研统考408真题卷（附2022大纲）免费下载.zip
11-25
不要积分！计算机考研统考408真题卷的小伙伴欢迎下载！
2022王道数据结构考研复习指导习题代码（树与二叉树）
qq_18431031的博客
05-16 1721
5.2二叉树的概念 1.已知一棵二叉树按顺序存储结构进行存储，设计一个算法，求编号分别i和j的两个结点的最近公共祖先结点的值。
数据结构 6.x章：非递归遍历二叉树（自己建栈）（c语言）
qq_73054673的博客
06-12 114
在空间复杂度方面，使用了一个栈S作为辅助空间，它的最大容量取决于二叉树的深度，所以空间复杂度为O(h)，其中h为二叉树的高度。在空间复杂度方面，使用了一个栈S作为辅助空间，它的最大容量取决于二叉树的深度，所以空间复杂度为O(h)，其中h为二叉树的高度。当p为空时，表示当前节点的左子树已经遍历完成，从栈中弹出该节点，访问该节点，并将指针p指向其右子树。在最坏情况下，即二叉树为满二叉树时，该算法遍历所有节点，时间复杂度为O(n)，其中n为节点数。遍历过程中，只要栈不为空或p不为空，就需要继续进行循环。
二叉树建立、遍历（递归非递归），求结点等
Venidi
10-25 810
/*(1）输入完全二叉树的先序序列，用#代表虚结点（空指针），如ABD###CE##F##，建立二叉树的二叉链表。 （2）写出对用二叉链表存储的二叉树进行先序、中序和后序遍历的递归和非递归算法。 （3）写出对用二叉链表存储的二叉树进行层次遍历算法。 （4）求二叉树的所有叶子及结点总数。 */ #include"stdio.h" #include"stdlib.h" #define STACK_IN
栈实现先序遍历算法【非递归】
深度Face的博客
10-22 2198
void InOrder2(BiTree T){ InitStack(S); BiTree p=T; //初始化栈S；P为遍历指针 while (p||!IsEmpty(S)){ //栈不空或p不空时循环 if(p){ //一路向左 visit(p); Push(S,p); //当前节点入栈，栈顶元素出栈， p=p->lchild; //左孩子不空，一直像左走 }else{.
二叉树的三种非递归遍历（转载）
yangguanglukou1的博客
04-06 161
下文转载地址：https://blog.csdn.net/lihongzhihhh/article/details/80034254#commentBox 觉得写得很清晰，特此备份！ 二叉树的非递归遍历采用栈实现，首先给出二叉树和栈的定义 #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 typedef char lElemType...
二叉树层次建树，前序（递归与非递归）遍历--中序遍历（递归与非递归）-后序遍历-层次遍历
m0_54765221的博客
04-22 1334
二叉树层次建树，前序遍历（递归与非递归） 中序遍历（递归与非递归） 后序遍历 层次遍历
数据结构代码--树
m0_67403773的博客
07-17 558
右孩子编号为 [(i+1)*2+1] - 1 = 2*i + 2。左孩子编号为 [(i+1)*2] - 1 = 2*i + 1。实现函数，找到结点 i 的父结点、左孩子、右孩子。定义顺序存储的二叉树（从数组下标1开始存储）父结点编号为 [(i+1)/2] - 1。“孩子表示法”，定义链式存储的树。右孩子编号为 i*2+1。双亲表示法 定义顺序树。从数组下标1开始存储。父结点编号为 i/2。左孩子编号为 i*2。从数组下标0开始存储。从数组下标1开始存储。从数组下标0开始存储。实现先/中/后序遍历。
王道数据结构代码题（C语言）二叉树
Cerulea_n的博客
06-29 118
数据结构1800关于树的代码精选（一）
qq_48443025的博客
10-30 712
数据结构
王道数据结构代码---第五章：二叉树（重要）
jinzhi66的博客
07-17 1049
二叉树
数据结构——栈（顺序栈，链栈）
weixin_45691686的博客
03-11 657
文章目录栈的定义栈的顺序存储结构栈的链式存储结构 栈的定义 栈是一种只能在一端进行插入或删除操作的线性表。 表中允许进行插入、删除作的一端称为栈顶.栈顶的当前位置是动态的，栈顶的当前位置由一个称为栈顶指针的位置指示器指示。表的另一端称为栈底。当栈中没有数据元素时，称为空栈。栈的插入操作通常称为进栈或入栈，栈的删除操作通 常称为退栈或出栈。 特点：是“后进先出”，即后进栈的元素先出栈。 栈的顺序...
[考研数据结构]第3章之栈的基本知识与操作
轻舟终过万重山
04-09 1054
栈的基本概念与实现，包括顺序栈、共享栈、链栈
王道数据结构代码——二叉树
qq_53381910的博客
08-05 976
王道数据结构代码——二叉树
王道数据结构笔记05—树（c语言）
qq_28356977的博客
02-14 1394
本笔记仅供本人与大家学习使用，笔记内容全部来自于b站王道考研的白嫖课程。
王道数据结构代码题--第二章树
李昂的博客
10-19 527
第二章 二叉树 顺序存储结构的二叉树，设计一个算法求，编号为i和j的两个结点的最近公共祖先结点的值 1、二叉树顺序顺序存储 2、最近公共祖先结点， 1、双亲编号问题，i的祖先结点为i/2，j的祖先结点为j/2 2、取多少次 3、将较大的不断取一半，比较i和j的大小，不断将大的取一半 二叉树： 1、顺序存储： 适用范围：完全二叉树、满二叉树 2、链式存储 对于普通的二叉树如何使用顺序存储？ 在存储的过程中将逻辑关系表达出来，将普通二叉树转换为完全二叉树，用数组按照层次一层一层保留，在存储过程中下标从1开始。
最小生成树
山鬼谣弋痕夕的博客
05-11 3348
https://blog.csdn.net/luoshixian099/article/details/51908175     关于图的几个概念定义： 连通图：在无向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该无向图为连通图。 强连通图：在有向图中，若任意两个顶点vivi与vjvj都有路径相通，则称该有向图为强连通图。 连通网：在连通图中，若图的边具有一定的意义，每一条边都...
数据结构 | 详解栈实现队列&队列实现栈
最新发布
mooridy的博客
05-17 327
step2：此时非空队列中剩下的唯一一个数就是“栈顶”元素，使用QueueFront进行·取值后，直接进行QueuePop删除。step0.先利用假设法假定非空队列notempty和空队列empty，再利用MyStackEmpty函数对进行修正。step1:将notempty队列中的前size-1个元素依次push到empty队列中，再进行删除，实现移动操作。
USB3.0接口——（2）数据结构
dkmknjk的博客
05-14 1064
在 USB 3.0 及更高版本的 xHCI 协议中，"Rings"、"Transfer Request Block (TRB)" 和 "Transfer Descriptor (TD)" 是用于管理 USB 数据传输和事件的重要概念。
王道408数据结构应用题
08-17
- *2* *3* [【23考研】计算机408数据结构代码题强化阶段划重点（王道书）](https://blog.csdn.net/qq_50710984/article/details/125583743)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值