树学

最新推荐文章于 2022-10-02 14:51:33 发布
最新推荐文章于 2022-10-02 14:51:33 发布
阅读量427 收藏 10
点赞数 5
分类专栏： 数据结构 文章标签： 二叉树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dsfdsfdsf222/article/details/106001691
版权

文章目录

（一）简介

树的层次：根节点为第一层
结点的度：结点拥有的子树
叶子结点：度为0
满二叉树：每一层的结点都为当层结点的最大数
完全二叉树：除最后一层 每一层的结点都为当层结点的最大数 最后一层结点在最左边连续

（二）建树步骤

strcut node
{
typename data ; //数据域
node* lchild;//指向左子树根节点的指针
node* rchild; //指向右子树根节点的指针
}
建树前根结点为空
node* root = NULL;
返回一个新节点
node*  newNode(int v)
{
  node* Node = new node;
  Node -> data = v;
  Node -> lchild = Node -> rhild = NULL;//左右儿子初始化
  return Node;
}

查找一个数并作修改
void search(node* root,int x,int newdata)
{
    if(root == NULL)
        return;
    if(root -> data == x)
        root -> data = newdata;
    search(root -> lchild, x , newdata);
    search(root -> rchild, x , newdata);
}
void insert(node* &root,int x)
{
    if(root == NULL)
    {
        root = newNode();
        return ;
    }
    if
    {
        insert(root -> lchild , x);
    }
    else 
    {
        insert(root -> rchild, x);
    }
}
node* create(int data[],int n)
{
    node* root = NULL;
    for(int i  =0 ; i < n;i++)
    {
        insert(root , data[i]);
    }
    return root;
}

对于完全二叉树的存储 用1-n的下标将二叉树从左至右从上至下编号存入数组中 其顺序正好是层序遍历

（三）二叉树遍历

（1）先序遍历

void preorder(node* root)
{
    if(root == NULL)
        return;
    printf("%d",root -> data);
    preorder(root -> lchild);
    preorder(root -> rchild);
}

(2) 中序遍历

void inorder(node* root)
{
    if(root == NULL)
        return;
    preorder(root -> lchild);
     printf("%d",root -> data);
    preorder(root -> rchild);
}

（3）后序遍历

void postorder(node* root)
{
    if(root == NULL)
        return;
    preorder(root -> lchild);
    preorder(root -> rchild);
      printf("%d",root -> data);
}

（4）层序遍历

void Layerorder(node* root)
{
    queue<node*> q;
    q.push(root);
    while(!q.empty())
    {
        node* now = q.front();
        q.pop();
        printf("%d",now -> data);
        if(now -> lchild)q.push(now -> lchild);
        if(now -> rchild)q.push(now -> rchild);
    }
}

（5）记录层数的层序遍历

struct node
{
    int data;
    int layer;
    node* lchild;
    node* rchild;
};
void Layerorder(node* root)
{
    queue<node*> q;
    q.push(root);
    root -> layer = 1;
    while(!q.empty())
    {
        node* now = q.front();
        q.pop();
        printf("%d",now -> data);
        if(now -> lchild) 
        {
        now -> lchild -> layer = now -> layer + 1;
        q.push(now -> lchild);
        }
        if(now -> rchild)
        {
        now -> rchild -> layer = now -> layer + 1;
        q.push(now -> rchild);
        }
    }
}

（四）还原二叉树

（1）先中还原

node* create(int prel,int prer,int inl,int inr)
{
    if(prel > prer)
        return NULL;//先序长度小于0
    node* root = new node;
    int k;
    for(k = inl ; k <= inr ; k++)
    {
        if(in[k] == pre[prel])
            break
    }//在中序中寻找与先序相同的结点
    //k点之前的点即为左子树结点个数
    int numleft = k - inl;
    //返回左子树的区间
    root -> lchild =create(prel + 1, prel + numleft ,inl , k -1);
   //返回右子树的区间
    root -> rchild = create(prel + numleft +1 ,prer , k + 1 , inr);
    return root;
}

（2）中后还原

node* create(int postl,int postr,int inl,int inr)
{
    if(postl > postr)
        return NULL;
    node* root = new node;
    root -> data =  post[postr];
    int k;
    for( k = inl ; k <= inr ;k ++)
        if(post[postr] == in[k])
        break;
    int numleft = k - inl;
    //区间长度要为numleft 
    root -> lchild = create(postl,postl + numleft-1,inl,k -1 );
    root -> rchild = create(postl  + numleft , potr - 1 , k + 1, inr);
}

（三）中层还原

Node *rebuildTree(int ll, int lr, int il, int ir) {
 if(il > ir) return NULL; 
 Node *root = NULL;
 int i, j;
 for(i = ll; i<=lr; i++) {
  if(m[lev[i]] == 1) continue;
  bool flag = false;
  for(j = il; j<=ir; j++) {
   if(lev[i] == in[j]) {
    flag = true;
    break;
   }
  }
  if(flag) {
   m[lev[i]] = 1;
   root = new Node(lev[i]);
   root->left = rebuildTree(ll, lr, il, j-1);
   root->right = rebuildTree(ll, lr, j+1, ir); 
   break;
  }
 }
 return root;
}

（五）树的静态写法

struct node
{
    typename data;//数据域
    int child[maxn];
}NODE[maxn] //数组下标代替地址;
struct node
{
   typename data;
   vector<int> child;
}NODE[maxn];

（六）静态树遍历

（1）先根遍历

void preorder(int root)
{
    printf("%d",NODE[root].data);
    for(int i =0 ;i < NODE[root].child.size();i++)
        preorder(NODE[root].child[i]);
}

（2）层序遍历

//和动态没多大区别吧
void Layerorder(int root)
{
    queue<int> q;
    q.push(root);
    while(!q.empty())
    {
        int front = q.front();
        printf("%d",NODE[front].data);
        q.pop();
        for(int i =0 ; i < NODE[front].child.size();i++)
            q.push(NODE[front].child[i]);
    }
}

（七）还原二叉树题解

（1）1020 Tree Traversals (25分)

#include<iostream>
#include<queue>
using namespace std;
const int maxn = 100;
int post[maxn],inorder[maxn];
struct node
{
  int data;
  node* left;
  node* right;
};
node* rebuild(int postl,int postr,int inl,int inr)
{
  if(postl > postr)
    return NULL;
  node* root = new node;
  root -> data  = post[postr];
  int k;
  for(k = inl ; k <= inr ;k++)
    if(inorder[k] == post[postr])
  break;
  int numleft = k - inl;
  root -> left = rebuild(postl,postl + numleft -1,inl,k-1);
  root -> right = rebuild(postl + numleft ,postr-1, k +1, inr);
  return root;
}
void leveloreder(node* root)
{
  queue<node*> q;
  q.push(root);
  int digit =0 ;
  while(!q.empty())
  {
    node* a = q.front();
    q.pop();
    if(digit)
      cout<<" ";
    digit++;
    cout<<a -> data;
    if(a->left)q.push(a->left);
    if(a->right)q.push(a ->right);
  }
}
int main()
{
  int n;
  cin>>n;
  for(int i =0 ; i< n;i++)
    scanf("%d",&post[i]);
  for(int i = 0 ; i < n ;i++)
    scanf("%d",&inorder[i]);
  node * root = rebuild(0,n-1,0,n-1);
  leveloreder(root);
}

（2）1086 Tree Traversals Again (25分)

//建完树忘了返回根节点
#include<iostream>
#include<stack>
using namespace std;
const int maxn = 100;
int pre[maxn],inorder[maxn];
stack<int> s;
struct node
{
  int data;
  node* left;
  node* right;
};
node* rebuild(int prel,int prer,int inl,int inr)
{
  if(prel > prer)
    return NULL;
  node* root = new node ;
  root -> data = pre[prel];
  int k;
  for(k = inl;k <= inr ; k++)
    if(inorder[k] == pre[prel])
      break;
  int numleft = k - inl;
  root -> left = rebuild(prel+1,prel + numleft , inl,k-1);
  root -> right = rebuild(prel + numleft +1 , prer , k+1,inr);
  return root;
}
int num = 0;
void BFS(node* root)
{
  if(root == NULL)
    return;
  BFS(root -> left);
  BFS(root -> right);
  if(num)
    cout<<" ";
    num++;
  cout<<root -> data;
}
int main()
{
  int n;
  cin>>n;
  string stl;
  int index1=0,index2 =0 ;
  for(int i = 0; i < n *2 ;i++)
  {
    cin>>stl;
    if(stl == "Push")
    {
      cin>>pre[index1];
      s.push(pre[index1 ++]);
    }
    else if(stl == "Pop")
    {
      inorder[index2++] = s.top();
      s.pop();
    }
  }
  node* root = rebuild(0,n-1,0,n-1);
  BFS(root);
}

（3）1102 Invert a Binary Tree (25分)

//给出反转后的二叉树 还原后输出中序 后序
#include<iostream>
#include<queue>
using namespace std;
const int maxn  = 1000;
bool vis[maxn];
int n,num =0 ;
struct Node
{
  int left,right;
}node[maxn];
int chartonum(char ch)
{
  if(isdigit(ch))
  {
      vis[ch - '0'] = true;
    return ch-'0';
  }
  else
    return -1;
}
//找到静态二叉树的根 即没用任何结点指向的
int findroot()
{
  for(int i =0 ; i < n ; i++)
  if(vis[i] == false)
      return i;
}
//通过后序遍历反转二叉树
//原则上先序也可以 不过先序反转后 后面BFS左右调换了

void postorder(int root)
{
  if(root == -1)
    return;
  postorder(node[root].left);
  postorder(node[root].right);
  swap(node[root].left,node[root].right);
}
void BFS(int root)
{
  queue<int> q;
  q.push(root);
  while(!q.empty())
  {
    int root = q.front();
    q.pop();
    if(num)
      cout<<" ";
      cout<<root;
    num ++;
    if(node[root].left!= -1)q.push(node[root].left);
    if(node[root].right != -1) q.push(node[root].right);
  }
}
void in(int root)
{
  if(root == -1)
    return;
 in(node[root].left);
    if(num)
      cout<<" ";
      cout<<root;
    num ++;
  in(node[root].right);
}
int main()
{
  char a,b;
  cin>>n;
  for(int i =0 ; i < n ;i ++)
  {
    cin>>a>>b;
    node[i].left = chartonum(a);
    node[i].right = chartonum(b);
  }
  int root = findroot();
  postorder(root);
  BFS(root);
  cout<<endl;
  num =0 ;
  in(root);
}

（八）树的遍历 （DFS）

1090 Highest Price in Supply Chain (25分)

//给出一颗供应树 再给出结点的价格，每向下一层 价格提升%r
//求最高价以及 最高价的结点数

#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
const int maxn =100;
vector<int> v[maxn];
double p,r;
int digit =0 ,maxdepth = 0;
void dfs(int root,int index)
{
  if(index > maxdepth)
  {
    digit =1 ;
    maxdepth = index;
  }
  else if(index == maxdepth)
    digit ++;
    if(v[root].size() ==0)
        return;
  for(int i =0 ; i< v[root].size();i++)
    dfs(v[root][i] , index + 1);
}
int main()
{
  int n,root;
  cin>>n;
  cin>>p>>r;
  r = r /100;
  for(int i =0 ; i < n ;i ++)
  {
    int id;
    cin>>id;
    if(id != -1)
      v[id].push_back(i);
    else
      root = i;
  }
  dfs(root , 0);
  printf("%.2f %d",p * pow(1+r,maxdepth),digit);
}

1079 Total Sales of Supply Chain (25分)

//给出供应树 
10 1.80 1.00 //结点个数，货物单价，r
3 2 3 5 // 第i号结点所拥有的结点 及其 下标
1 9    // 若 为0 则 表示叶子节点后一位表示权重
1 4
1 7
0 7
2 6 1
1 8
0 9
0 4
0 3
#include<iostream>
#include<vector>
#include<cmath>
using namespace std;
const int maxn = 1000000;
int n;
double p,r,ans =0;
//结构体存储权值以及孩子结点
struct
{
  int data;
  vector<int> v;
}node[maxn];
void dfs(int root , int depth)
{
  if(node[root].v.size()==0)
  {
    ans += node[root].data * pow(1+r/100,depth);
    return;
  }//遇到叶子结点 则求和
  for(int i =0 ; i < node[root].v.size();i++)
    dfs(node[root].v[i] , depth + 1);
}
int main()
{
  cin>>n>>p>>r;
  for(int i = 0; i < n ;i ++)
  {
    int j;
    cin>>j;
    if(j)
    {
      int id;
      for(int k =0 ; k < j; k++)
      {
        cin>>id;
        node[i].v.push_back(id);
      }
    }
    else
      cin>>node[i].data;
  }
  dfs(0,0);
  printf("%.1f",ans* p);
}

1053 Path of Equal Weight (30分)

//遍历树 输出所有到叶节点时权重和等于给定值的路径
//主要考点 树的遍历 保存路径

#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int maxn = 100000;
struct student
{
  int weight;
vector <int> child;
}node[maxn];
int path[maxn],s;
bool cmp(int a,int b)
{
  return node[a].weight > node[b].weight;
}
void dfs(int root ,int numnode,int sum)
{
  if(sum > s)return;
  if(sum == s)
  {
    if(node[root].child.size()!=0) return；
    //判断并输出路径

    for(int i = 0; i < numnode ; i++)
    {
      printf("%d",node[path[i]].weight);
      if(i < numnode - 1) cout<<" ";
      else
        cout<<endl;
    }
  }
  for(int i = 0 ; i < node[root].child.size();i++)
  {
    int child = node[root].child[i];
    path[numnode] = child;//就一个普普通通的数组存储这一步的结点 因为递归的性质 numnode 会覆盖其他的路径 就很妙
    dfs(child,numnode+1,sum + node[child].weight);
  }
}
int main()
{
  int n,m;
  cin>>n>>m>>s;
  for(int i = 0; i < n ; i++ )
    cin>>node[i].weight;
  for(int i = 0 ; i <  m ; i++)
  {
    int id,digit;
    cin>>id>>digit;
    for(int j = 0; j < digit ; j++)
    {
      int son;
      cin>>son;
      node[id].child.push_back(son);
    }
    //这一步把结点排序 这样先遍历权重较大的结点 
    sort(node[id].child.begin(),node[id].child.end(),cmp);
  }
  path[0] =  0;
 dfs(0,1,node[0].weight);
}

（九）二叉查找树（BST）

（一）简介

Binary Search Tree、排序二叉树、
左子树所有结点的数据域 都小于 右子树的 结点数据域

（二）操作集

//查找
void search(node* root,int x)
{
    if(root == NULL)
    {
        cout<<"search failed\n";
        return;
    }
    if(x == root -> data)
    {
        cout<<root -> data;
    }
    else if(x < root -> data)
        search(root -> left,x);
    else 
        search(root -> right,x);
}
//对于二叉查找树 其内部数据的顺序是一定的 若查询失败 那么失败的位置一定是其插入的位置
void insert(node* &root , int x)
{
    if(root == NULL)
    {
        root = newnode(x);
        return ;
    }
    if(x == root -> data)
    return;
    else if(root -> data < x)
        insert(root -> left , x);
    else insert(root -> right,x);
}
node* create(int data[] , int n)
{
    node* root = NULL;
    for(int i = 0 ; i < n;i++)
    {
        insert(root,data[i]);
    }
    return root;
}
//删除操作
//对于删掉一个根节点 一种方法是找出找出左子树中最大的结点
//覆盖掉根节点
//另一种则是在右子树找到的最小的结点覆盖根节点
//左子树中最大的结点只需要从它的根节点一直向右寻找
//右子树最小的结点反之亦然
node* findmin(node* root)
{
    while(root -> right)
        root = root -> right;
    return root;
}
node* findmax(node* root)
{
    while(root -> left)
        root = root -> left;
    return root;
}
（1）如果当前结点为空说明不存在 直接返回；
（2）如果找到了 开始进入删除环节
  a：如果是叶子结点 直接删除
  b:如果存在左孩子，寻找前驱pre 让pre覆盖root
   再递归删除pre；
  c:如果存在右孩子 同理
（3）如果结点值大于x，向左子树递归；
（4）如果结点值小于x，向右子树递归；
void deletenode(node* &root , int x)
{
    if(root == NULL) return;
    if(root -> data == x)
    {
        if(root -> left == NULL && root -> right == NULL)
            root = NULL;
        else if(root -> left != NULL)
        {
            node* pre = findmax(root -> left);
            root -> data = pre -> data;
            deletenode(root -> left,pre -> data);
        }
        else 
        {
            node* pre = findmin(root -> right);
            root -> data = pre -> data;
            deletenode(root -> right , pre -> data);
        }
    }
    else if(root -> data > x)
        deletenode(root -> left , x);
    else 
        deletenode(root -> right,x);
}

1043 Is It a Binary Search Tree (25分)

// 给出一组数据 建立二叉搜索树 问它的先序或
//镜像先序是否等于这个初始序列
//如果是 则输出对应的后序
#include<iostream>
#include<vector>
using namespace std;
const int maxn = 10000;
vector<int>origin,pre,prem,post,postm;
struct node
{
  int data;
  node* left,*right;
};
void insert(node* & root , int x)
{
  if(root == NULL)
  {
    root = new node;
    root -> data = x;
    root -> left = root -> right = NULL;
    return ;
  }
  if(x < root -> data) insert(root -> left , x);
  else insert(root -> right , x);
}
void preorder(node* root)
{
  if(root == NULL)
    return;
  pre.push_back(root -> data);
  preorder(root -> left);
  preorder(root -> right);
}
void premirror(node* root)
{
  if(root == NULL)
    return;
  prem.push_back(root -> data);
  premirror(root -> right);
  premirror(root -> left);
}
void postoeder(node * root)
{
  if(root == NULL)
    return ;
   postoeder(root -> left);
   postoeder(root -> right);
   post.push_back(root -> data);
}
void postmirror(node * root)
{
  if(root == NULL)
    return ;
   postmirror(root -> right);
   postmirror(root -> left);
   postm.push_back(root -> data);
}
int main()
{
 node* root = NULL;
  int n;
  cin>>n;
  int array[maxn];
  for(int i =0 ; i < n ; i++)
   {
    int id;
    cin>>id;
    origin.push_back(id);
    insert(root,id);
   }
  preorder(root);
  premirror(root);
  postoeder(root);
  postmirror(root);
  if(origin == pre)
  {
    cout<<"YES"<<endl;
    for(int i = 0 ; i < post.size();i++)
    {
      if(i)
        cout<<" ";
      cout<<post[i];
    }
  }
  else if(origin == prem)
  {
    cout<<"YES"<<endl;
    for(int i = 0; i < postm.size();i++)
    {
        if(i)
        cout<<" ";
      cout<<postm[i];
    }
  }
  else
    cout<<"NO";
}

1099 Build A Binary Search Tree (30分)

知道二叉搜索树的结构 和数据 我们可以把它还原

#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;
const int maxn = 100000;
int oridinary[maxn],bst[maxn];
int index=0,n;
struct Node
{
  int data;
  int left , right;
}node[maxn];
//核心还原代码 
void dfs(int root)
{
  if(root == -1)
    return ;
    //一直向左递归到底了就是其第一个插入位置
  dfs(node[root]. left);
  node[root].data = oridinary[index++];
  dfs(node[root]. right);
}
int digit =0 ;
void levelorder(int root)
{
  queue<int> q;
  q.push(root);
  while(!q.empty())
  {
    int a = q.front();
    q.pop();
    if(digit)
      cout<<" ";
    cout<<node[a].data;
    digit ++;
    if(node[a].left != -1) q.push(node[a].left);
    if(node[a].right != -1)q.push(node[a].right);
  }
}
int main()
{
  cin>>n;
  for(int i = 0; i < n ; i++)
  {
    cin>>node[i].left>>node[i].right;
  }
  for(int i = 0; i < n;i++)
    cin>>oridinary[i];
  sort(oridinary,oridinary+n);
  dfs(0);
  levelorder(0);
}

（十）平衡二叉树

（1）简介

对于序列1 2 3 4 5 若构建二叉查找树 会得到一条长链式
的树 即变成链表 
AVL树要求左右子树高度差距不超过1

（2）构建

struct node
{
int v,height; // 增加了height 记录当前子树高度
node* lchild ,*rchild;
};
node * newNode(int v)
{
node * Node = new node;
Node -> v = v;
Node -> heght = 1;
Node -> lchild = Node -> rchild = NULL;
return Node;
}
int getheight(node * root)
{
if(root -> NULL) return 0;
return root -> height;
int getBalanceFactor(node* root)
{
return getheight(root -> lchild) - getheight(root -> rchild);
}
void updateHeight(node * root )
{
root -> height = max(getheight(root -> lchild),getheight(root -> rchild)) + 1 ;
}

（三）操作集

查找与二叉查找树无异 略
在这里插入图片描述

void LeftRotation(node * & root)
{
    node * temp = root -> lchild;
    //将root右儿子标记为temp
    root -> rchild = temp -> lchild;
    //step1 根节点右儿子变成temp左儿子
    temp -> lchild = root ;
    //step2 temp 左儿子变成根节点 旋转过程
    updateheight(root);
    updateheight(temp);
    root = temp;
    //根结点变成temp
}

void rightRotation(node* & root)
{
node * temp = root -> lchild;
//temp 为根节点左儿子 为右旋做准备
root -> lchild = temp -> rchild;
//step 1 根节点左儿子变成temp的右儿子
temp -> rchild = root;
//step temp右儿子指向root；
updateheight(root);
updateheight(temp);
root = temp;
}
插入
void insert(node * & root)
{
    if(root == NULL)
    {
        root = newNode(v);
        return ;
    }
    if(v < roott -> v)
    {
        insert(root -> lchild,v);
        updateheight(root);
        if(getBalanceFactor(root ) == 2)
        {
            if(getBalanceFactor(root -> left)==1)
            rightRotation(root);
            else if(getBalanceFactor(root -> left) ==-1)
            {
                leftrotation(root -> lchild);
                rightrotation(root);
            }
        }
    
    }
    else 
    {
        insert(root -> rchild,v);
        updateheight(root);
        if(getBalanceFactor(root) == -2)
        {
            if(getbalancefactor(root -> rchild) == -1)
                leftrotation(root);
            else if(getbalancefactor(root -> rchild) ==1)
            {
                rightrotation(root -> rchild);
                leftrotation(root);
            }
        }
    }
}
#include<iostream>
using namespace std;
struct node
{
    int v,height;
    node * lchild ,* rchild;
}* root;
node * newnode(int v)
{
    node * Node = new node;
    Node -> v = v;
    Node -> height = 1;
    Node -> lchild = Node -> rchild = NULL;
    return Node;
}
int getheight(node* root)
{
    if(root == NULL) return 0;
    return root -> height;
}
void updateheight(node* root)
{
    root -> height = max(getheight(root ->lchild) , getheight(root -> rchild)) + 1;
}
int  getbalancefactor(node* root)
{
    return getheight(root -> lchild) - getheight(root -> rchild);
}
void leftrotation(node* & root)
{
    node* temp = root -> rchild;
    root -> rchild = temp -> lchild;
    temp -> lchild = root;
    updateheight(root);
    updateheight(temp);
    root = temp;
}
void rightrotation(node* & root)
{
    node* temp = root -> lchild;
    root -> lchild = temp -> rchild;
    temp -> rchild  = root;
    updateheight(root);
    updateheight(temp);
    root = temp;
}
void insert(node*&root,int v)
{
    if(root == NULL)
    {
        root = newnode(v);
        return;
    }
    if(v < root -> v)
    {
        insert(root -> lchild , v);
        updateheight(root);
        if(getbalancefactor(root) == 2)
        {
            if(getbalancefactor(root -> lchild) == 1)
                rightrotation(root);
            else if(getbalancefactor(root -> lchild) == -1)
                {
                    leftrotation(root -> lchild);
                    rightrotation(root);
                }
        }
    }
    else
    {
        insert(root -> rchild , v);
        updateheight(root);
        if(getbalancefactor(root) == -2)
        {
            if(getbalancefactor(root -> rchild) == -1)
                leftrotation(root);
            else if(getbalancefactor(root -> rchild) == 1)
            {
                rightrotation(root -> rchild);
                leftrotation(root);
            }
        }
    }
}
int main()
{
    int n,v;
    cin>>n;
    for(int i =0 ; i < n ; i++)
        {
            cin>>v;
            insert(root,v);
        }
        cout<<root ->v;
}
two DDog
关注
专栏目录
【二叉树】二叉树的DFS和BFS遍历
Awt_FuDongLai的博客
07-01 3171
二叉树是一个非常基础的数据结构，是刷题中的老面孔了。 对于常见的数据结构，如数组、链表、栈、队列、哈希表、树、堆、图等，我们要掌握它们的遍历和访问方式。 二叉树通常有两种访问方式，DFS和BFS。其中DFS又分为前序、中序、后序三种方式。 1 二叉树的定义（Java） 二叉树在不同语言中的定义方式不一样，这里以Java为例。 class TreeNode { int val; TreeNode left; TreeNode right; TreeNode() { .
决策树学习笔记（一）
hczheng的专栏
09-07 9341
决策树学习笔记（一）前言 For GBDT:提升树、GBDT是以分类树或者回归树为基本分类器的提升方法，在看提升树算法的时候我发现对决策树学习的一些细节并不清晰了，于是决定从头再学一遍。之前的理解还是比较粗浅，一直以为决策树比较简单，类似于很多的简单规则一级一级拼凑起来，对决策树的条件概率表示、特征选择、决策树生成以及剪枝都没有真正的掌握。
牛客 树学 树形dp
lanshan1111的博客
04-15 218
思路： 如果是求根为1的点，整棵树的深度和，我们可以用一次dfs来统计每个节点的深度。 现在考虑换根：我们发现现在的根2的子树及2本身的深度都减1，其余点的深度都加1。 那么我们不仅需要统计每个点的深度，而且要统计每个节点子节点的数量cnti，再需要一次dfs。 然后最后一次dfs是dp的过程，考虑对于换根点v，其原来父节点为u，那么dpv=f[u]-cnt[i]+(n-cnt[i])。 ...
数学与树学（娱乐向）
weixin_30538029的博客
07-30 113
数学： 背景：在一次模拟赛中，Deepinc、DuanYue和Remarkable分别用了三个式子表示了同一个东西，而他们的式子目测毫无关系，而且是从不同的角度分析的，导致他们的做法肯定是正确的，但却各不相同，我们来看一下。 Deepinc：$ans=\frac{\sum\limits_{i=1}^{m}(i^k-(i-1)^k)*w[i]}{m^k}*(n-k+1)$ DuanY...
决策树学习
热门推荐
MOL
12-16 1万+
决策树学习是应用最广的归纳推理算法之一，它是一种逼近离散值函数的方法。在这种方法中学习到的函数被表示为一颗决策树，学习得到的决策树也能再被表示为多个if-then规则，以提高可读性。 决策树学习方法对噪声数据有很好的健壮性且能够学习析取表达式。 决策树学习算法有很多，比如ID3、C4.5、ASSISTANT等等。这些决策树学习方法搜索一个完整表示的假设空间，从而避免了受限假设空间的不足。决策树学习的归纳偏置是优先选择较小的树。 决策树表示法 决策树通过把实例从根节点排列(sort)到某个叶子节点来分类实
八叉树学习
cgsmalcloud的博客
03-15 5121
八叉树学习八叉树结构八叉树的存储结构1. 规则八叉树：2.线性八叉树：3.一对八式八叉树参考网站 八叉树结构 八叉树结构是由 Hunter 博士于1978年首次提出的一种数据模型。八叉树结构通过对三维空间的几何实体进行体元剖分，每个体元具有相同的时间和空间复杂度，通过循环递归的划分方法对三维空间的几何对象进行剖分，从而构成一个具有根节点的方向图。在八叉树结构中如果被划分的体元具有相同的属性，则该体元构成一个叶节点；否则继续对该体元剖分成8个子立方体，依次递剖分，如下示意图所示。 八叉树是一种用于描述三维空
决策树学习算法——ID3,C4.5,CART详解
weixin_49717022的博客
07-19 5278
一、决策树 决策树的学习过程包括三个步骤： a）特征选择。不同的特征和预测目标具有不同强度的相关性，选择相关性最强的特征能够有效提高预测效果。 b）节点分裂。训练集会在决策树中按照节点规则分流，如果 节点A 没办法给出一个满意的分类结果，那它就会选择分裂，分成 2 个或者多个节点。那么根据什么分裂呢？节点A 会用熵来判断用哪个特征分裂是最优的。 c）剪枝。决策树不加限制地分裂容易产生过拟合现象，剪枝可以一定程度地缓解过拟合，提高泛化能力。 决策树的学习算法有多种，常用的有：ID3，C4.5，CART。下面逐
MySQL技能树学习体验及期望
夜郎King的博客
10-02 8122
本文围绕MySQL技能树的学习和问答，讲述了MySQL技能的功能定位，两个技能树的主要内容整理，以及在学习当中遇到的一些网友的问题，帮助他们进行问题的解答。
决策树学习1-信息增益划分实例计算
魏晋小子的博客
07-26 5259
1. 算法流程及说明 首先给出决策树计算流程，该图来自于周志华老师的《机器学习》(经典教材) 书中提到，有三种情形会导致递归返回： -1 当前节点包含的样本属于同一类别； -2 当前属性集为空或者所有样本在所有属性上的取值相同 -3 当前节点包含的样本集合为空 并且强调了： -第2种情形将该节点中含样本最多的类别作为该节点的类别 -第3种情形将父节点中含样本最多的类别作为该节点的类别 个人认为这...
南京林业大学808测树学历年考研真题汇编
07-22
南京林业大学808测树学是一门专攻森林测量与调查技术的学科，它在林业教育中占有重要地位，特别是在研究生入学考试中。测树学是研究如何精确、高效地获取、分析和利用森林资源信息的一门科学，涵盖了森林生物量估算...
2008-2014、2017年南京林业大学808测树学考研真题
07-23
南京林业大学808测树学是一门专攻森林测量与评价的专业课程，其考研真题是备考者深入了解学科核心内容、提升应试能力的重要参考资料。测树学是林业科学中的一个重要分支，它主要研究如何精确地测量森林资源，包括...
中学六年级语文下册 行道树学案（无答案） 鲁教版五四制 学案.doc
10-21
【中学六年级语文下册《行道树》学案】主要围绕着鲁教版五四制教材中的《行道树》一文展开，旨在帮助学生深入理解课文内容，挖掘文章所蕴含的人生哲理，并培养学生的阅读分析能力和情感认知。这篇学案以导学案的形式...
测树学考试复习重点.doc
10-08
测树学考试复习重点.doc
12306抢票脚本 - Bypass
最新发布
09-17
12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306抢票脚本12306
单片机与蓝牙模块的无线通信项目实战.md
09-17
如何使用单片机与蓝牙模块（如HC-05/HC-06）实现无线通信的详细步骤。首先，介绍了蓝牙模块的基本工作原理、引脚功能及配置方法。接着，讲解了硬件设计，包括单片机与蓝牙模块的连接、按键与LED模块的接线。然后，详细描述了软件设计，包括串口通信的初始化、蓝牙模块的数据接收与处理。项目调试部分涉及蓝牙连接的测试、串口通信的验证及功能调试，确保系统稳定运行。最后，探讨了项目的扩展可能性，如双向通信、多个设备通信及低功耗设计。这些内容为构建一个基于单片机和蓝牙的无线通信系统提供了全面的指导。
计算机科学中的基数排序算法原理与实现
09-17
本文详细介绍了基数排序这一非比较型排序方法的算法原理以及其在实际应用中如何操作。从初始化桶到最后重构阵列的每一步均进行了阐述，并提供了基于Python的实现例子。另外，对基数排序的时间和空间复杂度给出了深入解析及其使用情境说明，有助于了解排序机制并正确评估算法性能优劣。 适合人群：具备基本算法基础的数据科学家，研究和开发人员。 使用场景及目标：帮助理解和学习基数排序的技术要点和内在逻辑，掌握其实现在固定长度整数集合上进行快速排序的操作技巧。 其它提示：尽管该排序方法在特定条件下效率显著高于比较式方法，但须谨慎应用于数据种类变化多样的环境中。
Python100道题(100).zip
09-17
基数排序
基于大语言模型的智能体架构设计模式
09-17
本文档提出了一套由18种架构设计模式组成的设计模式目录，旨在指导从事基础模型（FM）驱动的人工智能（GenAI）开发的研究者与实践者们有效地克服现有挑战。它涵盖了被动目标创建者、主动目标创建者以及投票合作等多角度的解决方案，并详细讨论了每个设计模式的具体应用背景与解决相关问题的能力，从而支持基于FM的技术创新和发展，为实现自主型任务导向智能体提供坚实的理论基础和技术支持。适用于所有对智能体开发感兴趣的人群。 适合人群：具有一定编程基础且关注于智能体系统开发的研究员、软件设计师及开发者。 使用场景及目标：帮助相关人员深入理解当前先进基于基础模型的智能体发展趋势，在实际项目实践中更好地应对智能体的目标制定与行为规划方面的各种复杂情况。 额外说明：本研究不仅限于具体的技术实现细节，更多地强调从高层次视角探索设计思路和策略，促进跨学科协作及知识积累共享。
决策树学习详解与应用示例
"决策树是一种广泛应用的机器学习算法，它通过构建树状模型来实现对数据的分类或回归。在本资源中，机器学习领域的专家Tom Mitchell的PPT详细介绍了决策树的学习过程，包括决策树的表示方法、ID3算法、熵与信息增益...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值