树的基本内容

最新推荐文章于 2023-08-10 17:00:17 发布
最新推荐文章于 2023-08-10 17:00:17 发布
阅读量329 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1598622578/article/details/99108844
版权
二叉树的存储结构 ：

  1. 顺序存储结构 :

    完全二叉树：按从上至下、从左到右顺序存储

    n个结点的完全二叉树的结点父子关系：

    1. 非根结点（序号 i > 1）的父结点的序号是 i / 2;

    2. 结点（序号为 i ）的左孩子结点的序号是 2i，（若2 i <= n，否则没有左孩子）;

    3. 结点（序号为 i ）的右孩子结点的序号是 2i+1，（若2 i +1<= n，否则没有右孩子）;

      但是一般不用该方式，空间浪费严重

2.链表存储 ：(儿子-兄弟表示法 )

typedef struct tree_node* tree;
struct tree_node{
  	elementtype data;
    tree left;
    tree right;
};
二叉树的遍历 ：

1. 递归遍历：

  • 先序遍历：(遍历过程为： ① 访问根结点； ② 先序遍历其左子树； ③ 先序遍历其右子树)
   void preorder_traversal(tree bt){
       if (bt){
           cout << bt->data ;	//无非是该语句位置不同
           preorder_traversal(bt->left);
           preorder_traversal(bt->right);
       }
   }
   //如果想仅输出叶子节点，则仅需对cout语句添加判断if ( !bt->left && !bt->right).
   
   //求二叉树的高度://
   int binary_height(tree bt){
       int hl,hr,maxh;
       if (bt){
           hl=binary_height(bt->left);		//左子树深度
           hr=binary_height(bt->right);		//右子树深度
           maxh=(hl>hr)?hl:hr;		//取左右子树最大深度
           return (maxh+1);	//树高为左右子树最大深度+1
       }
       else return 0;	//空树深度为0
   }
  • 后序遍历：(遍历过程为： ① 后序遍历其左子树； ② 后序遍历其右子树； ③ 访问根结点)
   void postorder_traversal(tree bt){
       if (bt){
           postorder_traversal(bt->left);
           postorder_traversal(bt->right);
           cout << bt->data ;	//^_~
       }
   }
  • 中序遍历 ：(遍历过程为： ① 中序遍历其左子树； ② 访问根结点； ③ 中序遍历其右子树)
   void inorder_traversal(tree bt){
       if (bt){
           inorder_traversal(bt->left);
           cout << bt-<data ;	//^_~
           inorder_traversal(bt->right);
       }
   }

2. 非递归遍历：

  • 先序遍历：
   void preorder_traversal(tree bt){
       stack s=create_stack(maxsize);	//创建，初始化堆栈s
       while(bt || !is_empty(s)){
           while(bt){
               cout << bt->data;	//打印结点^_~
               push(s,bt);	//一直向左并将沿途结点压入堆栈
               bt=bt->left;
           }
           if (!is_empty){
               bt=pop(s);	//结点弹出堆栈
               bt=bt->right;	//转向右子树
           }
       }
   }
  • 后序遍历：
   /*由于后续遍历比较特殊，需要更换思路，如下:
   先把根节点压栈两次，然后出栈，判断是否是第一次出栈，
   若是，存入儿子节点，每个节点压栈两次，每次出栈的时候，进行判断*/
   void postorder_traversal(tree bt){
       stack s=create_stack(maxsize);	//创建，初始化堆栈s
       if (bt){
           push(s,bt);	//根节点压栈两次
           push(s,bt);
           tree temp=top(s);	//top(s)为获取栈顶元素，不出栈
       }
       while (!is_empty(s)){	//根节点第二次出栈后，跳出循环
           temp=pop(s);
           if ( !is_empty(s) && temp==top(s) ){	//栈不空，第一次出栈
               if (temp->right){
                   push(s,temp->right);	//右儿子压栈两次
                   push(s,temp->right);
               }
               if (temp->left){
                   push(s,temp->left);		//左儿子压栈两次
                   push(s,temp->left);
               }
           }
           else cout << temp->data ;	//第二次出栈，输出
       }
   }
  • 中序遍历：
   void inorder_traversal(tree bt){
       stack s=create_stack(maxsize);	//创建，初始化堆栈s
    while(bt || !is_empty(s)){
           while(bt){
               push(s,bt);	//一直向左并将沿途结点压入堆栈
               bt=bt->left;
           }
           if (!is_empty){
               bt=pop(s);	//结点弹出堆栈
               cout << bt->data;	//打印结点^_~
               bt=bt->right;	//转向右子树
           }
       }
   }

3. 层序遍历 ：

基本过程：先根结点入队，然后从队列中取出一个元素； 访问该元素所指结点；

若该元素所指结点的左、右孩子结点非空，则将其左、右孩子的指针顺序入队。

     void levelorder_traversal(tree bt){
         queue q=create_queue();
      if (bt) add(q,bt);
         while(!is_empty(q)){
          bt=delete(q);
             cout << bt->data ;
             if (bt->left) add(q,bt->left);
             if (bt->right) add(q,bt->right);
         }
     }
二叉树同构判别：
int isomorphism(tree a,tree b){
    if ( !a && !b ) return 1;	//两个都空
    if ( (!a&&b) || (a&&!b) ) return 0;	//	一个空，一个不空
    if (a->data!=b->data) return 0;	//都不空，但数据不同
    if ( !a->left && !b->left ) return(a->right,b->right);	//左子树都空，判断右子树
    
    //左子树数据相同，判断右子树
    if ( (a->left&&b->left) && (a->left->data==b->left->data) )	
        return ( isomorphism(a->left,b->left) && isomorphism(a->right,b->right) );
    //左子树一个空，一个不空；或者左子树数据不同；交换左右子树，进行判断
    else
        return ( isomorphism(a->left,b->right) && isomorphism(a->rght,b->left) );
}
数据查找：

1. 静态查找：集合是固定的 ，没有插入和删除操作，只有查找

  • 顺序查找：
struct table{
    int length;
    elementtype element[length+1];
};
int sequential_find(elementtype x,struct table* tb){
     /*在表tb[1]~tb[n]中查找关键字为x的数据元素*/ 
    int i;
    tb->element[0]=x;//建立哨兵
    for (i=tb->length;tb->element[i]!=x;i--);
    return i;
}
//顺序查找算法的时间复杂度为O(n)
  • 二分查找：(数据必须有序存放，比如从小到大)
struct table{
    int length;
    elementtype element[length+1];
};
int binary_find(elementtype x,struct table* tb){
    int left=0,mid,right=tb->length;//初始化左右边界
    while(left<=right){
        mid=(left+right)/2;//计算中间元素坐标
        if (tb->element[mid]<x) left=mid+1;//调整左边界
        else if (tb->element[mid]>x) right=mid-1;//调整右边界
        else return mid;//找到，返回x的坐标位置
    }
    return -1;//未找到
}
//注意在调整边界时，不能left=mid或者right=mid，这样做在某些情况下会让while成为死循环
//二分查找算法具有对数的时间复杂度O(logN)

2. 动态查找：集合是动态变化的 ，除查找，还可能发生插入和删除

以二叉搜索树为例：

//结构如下:
typedef struct binary_tree* tree;
struct binary_tree{
    elementtype data;
    tree left;
    tree right;
};

二叉搜索树：一棵二叉树，可以为空；如果不为空，满足以下性质：

  1. 非空左子树的所有键值小于其根结点的键值。
  2. 非空右子树的所有键值大于其根结点的键值。
  3. 左、右子树都是二叉搜索树。

  • 查找：(返回x节点，失败返回NULL)

    ------------------查找元素X的位置----------------
//尾递归:
tree find(elementtype x,tree bt) 
{ 
if( !bt ) return NULL; /*查找失败*/ 
if( x > bt->data )  
    return find(x,bt->right); /*在右子树中继续查找*/ 
else if( x < bt->data )  
    return find(x,bt->left); /*在左子树中继续查找*/ 
else 
    return bt; /*查找成功，返回结点的地址*/ 
} 

//由于非递归函数的执行效率高，下面将尾递归改为迭代:
tree find(elementtype x,tree bt){
    while(bt){
        if (x>bt->data) bt=bt->right;	/*向右子树中移动，继续查找*/
        else if (x<bt->data) bt=bt->left;	/*向左子树中移动，继续查找*/
        else return bt;	/*查找成功，返回找到结点的地址*/
    }
    return NULL;	/*查找失败*/
}

------------------查找最小元素的位置----------------
tree find_min(tree bt){
    if (bt)
        while (bt->left) bt=bt->left;
    return bt;
}

------------------查找最大元素的位置----------------
tree find_max(tree bt){
    if (bt)
        while (bt->right) bt=bt->right;	//沿右分支继续查找，直到最右叶结点
    return bt;
}

  • 插入:(返回结果树根节点)

    tree insert(elementtype x,tree bt){
    if (!bt){	/*若原树为空，生成并返回一个结点的二叉搜索树*/
        bt=(tree)malloc(sizeof(struct binary_tree));
        bt->data=x;
        bt->left=bt->right=NULL;
        return bt;
    }
    else{	/*开始找要插入元素的位置*/
        tree top=bt;
        int flag=0;	//判断在left插入还是right插入
        tree temp=NULL;	//记录父节点
        while (bt){
            temp=bt;
            if (x>bt->data){	//右子树寻找插入位置
                bt=bt->right;
                flag=1;
            }
            else if (x<bt->data){	//左子树寻找插入位置
                bt=bt->left;
                flag=0;
            }
            else return true;	//x已存在，直接返回插入成功
        }
        if (flag){	//flag==1，在temp的right下新建节点
            temp->right=(tree)malloc(sizeof(struct binary_tree));
            temp->right->data=x;
            temp->rigth->left=temp->right->right=NULL;
        }
        else{	//flag==0，在temp的left下新建节点
            temp->left=(tree)malloc(sizeof(struct binary_tree));
            temp->left->data=x;
            temp->left->left=temp->left->right=NULL;
        }
        return top;
    }
}

  • 删除:(返回结果树根节点)

    //递归:
tree delete(elementtype x,tree bt){
    if (!bt) reeturn NULL;	//空树
    else if (x<bt->data) bt->left=delete(x,bt->left);//左子树递归删除
    else if (x>bt->data) bt->right=delete(x,bt->right);//右子树递归删除 
    else{	//找到要删除的结点
        tree temp=NULL;
        if (bt->left && bt->right){	//待删除节点有左，右子树
            //在右子树中找最小的元素填充删除结点
            temp=find_min(bt->right);
            bt->data=temp->data;
            bt->right=delete(bt->data,bt->right);
        }
        else{	//待删除节点仅有左子树，或仅有右子树，或无子节点
            temp=bt;
            if (bt->left)	//有左节点
                bt=bt->left;
            else	//有右节点，或无子节点
                bt=bt->right;
            free(temp);
        }
    }
    return bt;
}
//非递归:(稍微复杂一些)
tree delete(elementtype x,tree bt){
  if (!bt) reeturn NULL;	//空树
    
    tree top=bt;	//记录根节点
    tree parent=bt;	//记录父节点
    while(bt){	//寻找x位置
        if (x>bt->data){
            parent=bt;
            bt=bt->right;
        }
        else if (x<bt->data){
            parent=bt;
            bt=bt->left;
        }
        else break;	//找到，退出循环
    }
    if (!bt) return top;	//未找到
    
    if (bt->left && bt->right){	//待删除节点有左，右子树
        tree temp=bt->right;	//在右子树中找最小的元素填充删除结点
        while(temp->left){
            parent=temp;
            temp=temp->left;
        }
        bt->data=temp->data;
        if (temp==parent->right)//说明待删除节点的右子树为斜右二叉树(包括一个节点情况)
            parent->right=temp->right;
        else
            parent->left=temp->right;//待删除节点的右子节点有左子树
        free(temp);
        return top;
    }
    else{	//待删除节点仅有左子树，或仅有右子树，或无子节点
        tree temp=bt;
        if (parent==bt){	//删除根节点(包括最后一个节点情况)
            if (bt->left) bt=bt->left;
            else bt=bt->right;
            free(temp);
            return bt;
        }
        else{	//根节点不变
            if (bt==parent->left){
                if (bt->left) parent->left=bt->left;
        		else parent-left=bt->right;
            }
            else{
                if (bt->left) parent->right=bt->left;
        		else parent->right=bt->right;
            }
        	free(temp);
            return top;
        }
    }
}
平衡二叉树：

平衡二叉树 (Balanced Binary Tree) (AVL树) :
空树，或者任一结点左、右子树高度差的绝对值不超过1

设 n h 高 度 为 h 的 平 衡 二 叉 树 的 最 少 结 点 数 。 结 点 数 最 少 时 ： n h = n h − 1 + n h − 2 + 1 设n_h高度为h的平衡二叉树的最少结点数。结点数最少时： n_h = n_{h-1} + n_{h-2} + 1 设nh​高度为h的平衡二叉树的最少结点数。结点数最少时：nh​=nh−1​+nh−2​+1

typedef struct avl_tree* tree;
struct avl_tree{
    tree left;	//指向左子树
    tree right;	//指向右子树
    elementtype data;	//结点数据
    int height;	//树高
};

int max(int a, int b)
{
	return a > b ? a : b;
}

tree left_rotation(tree a){	//左单旋
/* 注意：a必须有一个左子结点b */
/* 将a与b做左单旋，更新a与b的高度，返回新的根结点b */
    tree b=a->left;
    a->left=b->right;
    b->right=a;
    a->height=max(a->left->height,a->right->height)+1;
    b->height=max(b->left->height,b->right->height)+1;
    return b;
}

tree right_rotation(tree a){	//右单旋
    /* 把left，right对换即可 */
    tree b=a->right;
    a->right=b->left;
    b->left=a;
    a->height=max(a->left->height,a->right->height)+1;
    b->height=max(b->left->height,b->right->height)+1;
    return b;
}

tree left_right_rotation(tree a){	//左-右双旋
/* 注意：a必须有一个左子结点b，且b必须有一个右子结点c */
/* 将a、b与c做两次单旋，返回新的根结点c */
    
    a->left=right_rotation(a->left);	//将B与C做右单旋，C被返回
    return left_rotation(a);	//将A与C做左单旋，C被返回
}

tree right_left_rotation(tree a){	//右-左双旋
    /* 同理，把left，right对换即可 */
    a->right=left_rotation(a->right);
    return right_rotation(a);
}

/* 如果不使用递归，将会使程序变得非常复杂，比如:
插入时需要判断在left还是right，插入后还需要判断是否仍是平衡二叉树，
而判断又需求树高，除此之外，还需要记录“麻烦节点”和“发现者”，因此下面采用递归实现:*/
tree insert(elementtype x,tree bt){
    if (!bt){	//若插入空树，则新建包含一个结点的树
        bt=(tree)malloc(sizeof(struct avl_tree));
        bt->height=0;
        bt->left=bt->right=NULL;
        bt->data=x;
        return bt;	//插入空树结束
    }
    else if (x < bt->data){
        bt->left=insert(x,bt->left);	//插入bt的左子树
        if (bt->left->height - bt->right->height == 2){	//如果需要左旋
            if (x < bt->left->data) bt=left_rotation(bt);	//左单旋
            else bt=bt->left_right_rotation(bt);	//左-右双旋
        }
    }
    else if (x > bt->data){	//插入bt的右子树
		bt->right=insert(bt->right);
		if (bt->right->height - bt->left->height == 2){	//如果需要右旋
            if (x > bt->right->data) bt=right_rotation(bt);	//右单旋
			else bt=right_left_rotation(T);	//右-左双旋
        }
	}
	//else x==bt->data，无须操作
    
	bt->height=max(bt->left,bt->right)+1;	//更新树高

	return bt;
    }
}
堆：

优先队列（Priority Queue）：特殊的“队列”，取出元素的顺序是 依照元素的优先权（关键字）大小，而不是元素进入队列的先后顺序。

堆的两个特性 ：

结构性：用数组表示的完全二叉树；

有序性：任一结点的关键字是其子树所有结点的最大值(或最小值)

“最大堆(MaxHeap)”,也称“大顶堆”：最大值

“最小堆(MinHeap)”,也称“小顶堆” ：最小值

下面以最大堆(数组实现)为例，实现基本操作：

typedef struct priority_queue* heap;
struct priority_queue(int max){
    elementtype* data;
    int size;
    int capacity;
};

  • 创建：

    heap create_maxheap(int max){
    heap h=(heap)malloc(sizeof(struct priority_queue));
    h->data=(elementtype*)malloc(sizeof(elementtype)*(max+1));
    h->size=0;
    h->capacity=max;
}

  • 插入：

    int is_full(heap h){	//判断堆是否满
    return (h->size==h->capacity);
}
bool insert(elementtype x,heap h){
    if (is_full(h)) return false;	//最大堆已满
    int i=++(h->size);	//取插入位置，当前容量+1
    while (i>1 && x>h->data[i/2]){	//未到达堆顶，且大于i的父亲节点
        h->data[i]=h->data[i/2];	//相当于给x腾出空间
        i/=2;
    }
    h->data[i]=x;	//插入x
    return true;
}

  • 删除：

    int is_empty(heap h){	//判断堆是否空
    return (h->size==0);
}
elementtype delete_max(heap h){	//删除堆顶元素并返回
    if (is_empty(h)) return false;	//堆空
    elementtype top=h->data[0];	//记录堆顶元素，待return
    elementtype temp=h->data[(h->size)--];	//记录最后一个元素，当前容量-1
    int parent=1,child;
    for (; parent*2<=h->size; parent=child){
        child=2*parent;
        if ( (child!=h->size) && (h->data[child]<h->data[child+1]) )
            child++;	//找到最大子节点(其中第一个条件判断是否有右儿子)
        if (temp>=h->data[child]) break;	//让temp补位
        else h->data[parent]=h->data[child];	//给temp腾出位置
    }
    h->data[parent]=temp;	//temp插入
    return top;
}
哈夫曼树与哈夫曼编码：

哈夫曼树的定义：​
带权路径长度 ( W P L ) (WPL) (WPL)：设二叉树有n个叶子结点，每个叶子结点带有权值 w k w_k wk​，从根结点到每个叶子结点的长度为 l k l_k lk​，则每个叶子结点的带权路径长度之和就是： W P L = ∑ k = 1 n w k l k WPL=\sum_{k=1}^n w_kl_k WPL=∑k=1n​wk​lk​
最优二叉树或哈夫曼树: W P L WPL WPL最小的二叉树​

哈夫曼树的构造 :
每次把权值最小的两棵二叉树合并

typedef struct TreeNode *HuffmanTree;
struct TreeNode{
    int Weight;
    HuffmanTree Left, Right;
} 
HuffmanTree Huffman( MinHeap H ) {
    /* 假设H->Size个权值已经存在H->Elements[]->Weight里 */   
    int i;  
    HuffmanTree T; 
    BuildMinHeap(H); /*将H->Elements[]按权值调整为最小堆*/     
    for (i = 1; i < H->Size; i++) { /*做H->Size-1次合并*/         
        T = malloc( sizeof( struct TreeNode) ); /*建立新结点*/         
        T->Left = DeleteMin(H);  /*从最小堆中删除一个结点，作为新T的左子结点*/
        T->Right = DeleteMin(H); /*从最小堆中删除一个结点，作为新T的右子结点*/         
        T->Weight = T->Left->Weight+T->Right->Weight;/*计算新权值*/         
        Insert( H, T ); /*将新T插入最小堆*/   
    }   
    T = DeleteMin(H);   
    return T; 
}
//转自https://www.icourse163.org/learn/ZJU-93001?tid=1206471203#/learn/content?type=detail&id=1211167094&cid=1213729254
集合及运算：
typedef struct{
    elementtype data;
    int parent;
}gather;

int find(elementtype x,gather s[]){	//在数组s中查找值为x的元素所属的集合
    int i=0;
    while(i<maxsize && s[i].data!=x) i++;
    if (i>=maxsize) return -1;	//未找到
    while(s[i].parent>=0) i=s[i].parent;
    return i;	//找到x所属集合，返回树根结点在数组s中的下标 
}

int combination(elementtype x,elementtype y,gather s[]){
    int a=find(x,s);
    int b=find(y,s);
    if (a!=b){
        if (-s[a].parent >= -s[b].parent){//如果集合a比较大,集合b并入集合a
            s[a].parent+=s[b].parent;
            s[b].parent=a;
        }
        else{
            s[b].parent+=s[a].parent;//如果集合b比较大,集合a并入集合b
            s[a].parent=b;
        }
    }
}
Kriens
关注
专栏目录
树的基础知识
qq_52320085的博客
04-01 2310
树的基础知识。 前序遍历，中序遍历，后序遍历 通过两种遍历反推二叉树 通过两种遍历得到另一种遍历
树的基本知识点（未完）
lishichengyan的博客
08-14 614
3、二叉树 （1）基本性质（其实很多是树的性质） ①除了叶子之
kaldi001 -- 树的内部结构
u012361418的博客
06-03 1314
决策树内部结构 该页面描述了语音决策树聚类代码的内部结构，代码实现为非常通用的结构和算法。 有关解释整个实现算法以及工具包如何使用，请参阅“如何在Kaldi中使用决策树”一节。 EventMap类 构建决策树代码的主要概念是“事件映射”，由EventMap类型表示。不要被“事件”这个术语误导，而错误地认为是特定时间发生的事情。事件只是一组（键，值）对，没有重复键。概念上，它可以由类型std
数据结构—哈夫曼树与哈夫曼编码
不忘初心，知行统一
11-26 981
一，什么是哈夫曼树 哈夫曼树是一种带权路径长度最短的二叉树，也称为最优二叉树。下面用一幅图来说明。 它们的带权路径长度分别为： 图a： WPL=5*2+7*2+2*2+13*2=54 图b： WPL=5*3+2*3+7*2+13*1=48 可见，图b的带权路径长度较小，我们可以证明图b就是哈夫曼树(也称为最优二叉树)。 二，如何构建哈夫曼树 一般可以按下面步骤构建： 1
数据结构学习日记三：树
qq_63494746的博客
08-10 119
树、二叉树的遍历、二叉搜索树、二叉平衡树、堆、堆排序、哈夫曼、集合、合查集、按秩归并、路径压缩
二叉树的基本内容
cang_ling的博客
01-02 248
为什么会有树这种数据结构 完全二叉树：从上到下，从左到右一次平铺 一个数组查询的最低复杂度可以为O1（在我们知道下表的前提下） 然而我们面对的数组大多是无序二不确定的数据结构，我们则需要for循环，一个for 循环的时间复杂度为O（n）级别。 有序序列的时间复杂度logn：利用折半查找法：定义出数组的第一位置和最后一个位置，两者相加除以2，得到中间值的位置，一次循环，得到logn级别的时间复杂度。 因为我们很难追求O1级别的时间复杂度，所以我们要尽力追求logn级别的时间复杂度； .
线段树模版（比较基本的线段树以及例题模板）
11-01
关于一些典型的线段树的例题，大家可以看一看，给一个评价，这些内容，后续我也会在博客上慢慢更新。希望大家多多的支持作者，谢谢！ 这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树...
树的基本操作
12-12
通过对二叉树和三叉树基本操作的学习，我们可以更好地理解和应用这些数据结构来解决实际问题。无论是二叉树还是三叉树，在程序设计中都有着广泛的应用场景，掌握它们的基本操作对于提升编程能力有着重要的意义。 ...
【数据结构试验】树的基本操作
06-15
1.实验目的： 熟悉树的基本定义，树的存储方式、建立方法及相关基本操作，能够根据实际情况选择合适的存储结构。 2.实验内容： 以二叉链表作存储结构，试编写前序、中序、后序遍历二叉树的算法。
机器学习-决策树（基本流程、划分选择）
lullaby_UUN的博客
11-16 4920
决策树（基本流程、划分选择）ID3算法
设备树基本概述
02-27 5689
1.设备树 设备树(Device Tree)是一种描述硬件的数据结构。 作用:提供设备信息。 时间:在操作系统引导阶段进行设备初始化的时候，数据结构中的硬件信息被检测并传递给操作系统。 设备树源文件(xxxx.dts) DTC编译 设备树二进制文件（xxxx.dtb） 2.设备树基本语法 设备树的基本单元是节点(node)，这些node被组织成树状结构，除了root node...
VTOL-7-Nano-3D-Print
09-17
VTOL-7-Nano-3D-Print for T1 Ranger
c1900-universalk9-mz.SPA.153-1.T.bin
最新发布
09-17
c1900-universalk9-mz.SPA.153-1.T.bin
常用命令_linux.zip
09-17
常用命令_linux
卡瓦牙椅E70E80-Vsion中文使用说明书第三部分.pdf
09-17
卡瓦牙椅E70E80-Vsion中文使用说明书第三部分.pdf
linux命令、脚本、基础知识学习_Linux-study.zip
09-17
linux命令、脚本、基础知识学习_Linux-study
发那科系统整套PMC梯形图设计调试维修 FANUC全套PMC设计 发那科标准PLC 详情从图2开始 内容很全 请仔细看完：
09-17
发那科系统整套PMC梯形图设计调试维修 FANUC全套PMC设计 发那科标准PLC 详情从图2开始 内容很全 请仔细看完： 1.刀库程序设计（斗笠 圆盘 夹臂 机械手 伞型 都包括） 2.刀架程序（电动 液压 伺服 都包括） 3.操作方式（标准板 第三方板） 4.进给轴控制（轴运动 限位 回零） 5.主轴控制（换挡 定向 攻丝） 6.外围程序设计（卡盘 台尾 冷却 润滑 排屑机 照明灯 三色灯） 7.报警程序设计 等等，不一一列举，详细目录见下图。 该资料内含中间地址表，中文注释，一目了然，可以直接使用，省事省力。 电气工程师、维修工程师的好帮手。
基于ssm的个性化影片推荐系统设计与实现.docx
09-17
基于ssm的个性化影片推荐系统设计与实现.docx
鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx
09-17
鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx 鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V1.0(1).docx鸿蒙OpenHarmony信创实训室建设方案V
树的基本知识与应用：二叉树遍历与哈夫曼树
总结而言，本讲内容覆盖了树的基本概念、二叉树的存储和遍历、二叉排序树的应用以及哈夫曼树的构造。同时，还介绍了广义表的定义、存储结构和深度，这些都是计算机科学中基础且重要的数据结构知识。深入理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值