树和二叉树2——遍历

转载自:http://blog.youkuaiyun.com/markcnsc/article/details/8551143

 

保留版权,欢迎转载。请注明原始链接:http://blog.youkuaiyun.com/markcnsc/article/details/8551143)

  1. typedef struct _BT {  
  2.     struct _BT* lc;  
  3.     struct _BT* rc;  
  4.     int v;  
  5. } BT;  
  6.   
  7. void visit (BT* p);  
typedef struct _BT {
    struct _BT* lc;
    struct _BT* rc;
    int v;
} BT;

void visit (BT* p);


 

1 递归遍历 (中序为例)

  1. void traverse_in_order (BT* p)  
  2. {  
  3.     if (!p) return;  
  4.     traverse_in_order (p->lc);  
  5.     visit (p);  
  6.     traverse_in_order (p->rc);  
  7. }  
void traverse_in_order (BT* p)
{
    if (!p) return;
    traverse_in_order (p->lc);
    visit (p);
    traverse_in_order (p->rc);
}

2 非递归遍历 

2.1 先序非递归

Knuth版:
  1. void trv_pre_order (BT* h)  
  2. {  
  3.     static BT* s[N]; //#define N >= number of nodes    
  4.     int i = -1;  
  5.     BT* p = h;  
  6.    
  7.     while (p || i >= 0) {  
  8.         if (p) {  
  9.             visit (p);  
  10.             s[++ i] = p;  
  11.             p = p->lc;  
  12.         }  
  13.         else {  
  14.             p = s[i --];  
  15.             p = p->rc;  
  16.         }  
  17.     }  
  18. }  
void trv_pre_order (BT* h)
{
    static BT* s[N]; //#define N >= number of nodes 
    int i = -1;
    BT* p = h;
 
    while (p || i >= 0) {
        if (p) {
            visit (p);
            s[++ i] = p;
            p = p->lc;
        }
        else {
            p = s[i --];
            p = p->rc;
        }
    }
}

Sedgewick版:
  1. void trv_pre_order (BT* h)  
  2. {  
  3.     static BT* s[N]; //#define N >= number of nodes   
  4.     int i = -1;   
  5.     BT* p;   
  6.   
  7.     if (!h) return;   
  8.     s[++ i] = h;  
  9.     while (i >= 0) {  
  10.         p = s[i --];  
  11.         visit (p);  
  12.         if (p->rc)   
  13.             s[++ i] = p->rc;   
  14.         if (p->lc)   
  15.             s[++ i] = p->lc;   
  16.     }  
  17. }  
void trv_pre_order (BT* h)
{
    static BT* s[N]; //#define N >= number of nodes
    int i = -1; 
    BT* p; 

    if (!h) return; 
    s[++ i] = h;
    while (i >= 0) {
        p = s[i --];
        visit (p);
        if (p->rc) 
            s[++ i] = p->rc; 
        if (p->lc) 
            s[++ i] = p->lc; 
    }
}

2.2 中序非递归

  1. void trv_in_order (BT* h)  
  2. {  
  3.     static BT* s[N]; //#define N >= number of nodes    
  4.     int i = -1;  
  5.     BT* p = h;  
  6.    
  7.     while (p || i >= 0) {  
  8.         if (p) {  
  9.             s[++ i] = p;  
  10.             p = p->lc;  
  11.         }  
  12.         else {  
  13.             p = s[i --];  
  14.             visit (p);  
  15.             p = p->rc;  
  16.         }  
  17.     }  
  18. }  
void trv_in_order (BT* h)
{
    static BT* s[N]; //#define N >= number of nodes 
    int i = -1;
    BT* p = h;
 
    while (p || i >= 0) {
        if (p) {
            s[++ i] = p;
            p = p->lc;
        }
        else {
            p = s[i --];
            visit (p);
            p = p->rc;
        }
    }
}

2.3 后序非递归

  1. void trv_post_order (BT* h)  
  2. {  
  3.     static BT* s[N]; //#define N >= number of nodes    
  4.     int i = -1;  
  5.     BT* p = h;  
  6.     BT* q = NULL;  
  7.       
  8.     while (p || i >= 0) {  
  9.         if (p) {  
  10.             s[++ i] = p;  
  11.             p = p->lc;  
  12.         }  
  13.         else {  
  14.             p = s[i];  
  15.             if (!p->rc || p->rc == q) {  
  16.                 i --;  
  17.                 visit (p);  
  18.                 q = p;  
  19.                 p = NULL;  
  20.             }  
  21.             else {  
  22.                 p = p->rc;  
  23.             }  
  24.         }  
  25.     }  
  26. }  
void trv_post_order (BT* h)
{
    static BT* s[N]; //#define N >= number of nodes 
    int i = -1;
    BT* p = h;
    BT* q = NULL;
    
    while (p || i >= 0) {
        if (p) {
            s[++ i] = p;
            p = p->lc;
        }
        else {
            p = s[i];
            if (!p->rc || p->rc == q) {
                i --;
                visit (p);
                q = p;
                p = NULL;
            }
            else {
                p = p->rc;
            }
        }
    }
}

3 层次遍历

  1. void trv_level_order (BT* h)  
  2. {  
  3.     static BT* q[N]; //#define N >= number of nodes;   
  4.     int i = 0, j = 0;  
  5.     BT* p;  
  6.       
  7.     if (!h) return;  
  8.     q[++ i] = h;  
  9.     while (i != j) {  
  10.         p = [j=(j+1)%N];  
  11.         visit (p);  
  12.         if (p->lc)  
  13.             q[i=(i+1)%N] = p->lc;  
  14.         if (p->rc)  
  15.             q[i=(i+1)%N] = p->rc;  
  16.     }  
  17. }  

 

内容概要:本文详细介绍了一种基于Simulink的表贴式永磁同步电机(SPMSM)有限控制集模型预测电流控制(FCS-MPCC)仿真系统。通过构建PMSM数学模型、坐标变换、MPC控制器、SVPWM调制等模块,实现了对电机定子电流的高精度跟踪控制,具备快速动态响应和低稳态误差的特点。文中提供了完整的仿真建模步骤、关键参数设置、核心MATLAB函数代码及仿真结果分析,涵盖转速、电流、转矩和三相电流波形,验证了MPC控制策略在动态性能、稳态精度和抗负载扰动方面的优越性,并提出了参数自整定、加权代价函数、模型预测转矩控制和弱磁扩速等优化方向。; 适合人群:自动化、电气工程及其相关专业本科生、研究生,以及从事电机控制算法研究与仿真的工程技术人员;具备一定的电机原理、自动控制理论和Simulink仿真基础者更佳; 使用场景及目标:①用于永磁同步电机模型预测控制的教学演示、课程设计或毕业设计项目;②作为电机先进控制算法(如MPC、MPTC)的仿真验证平台;③支撑科研中对控制性能优化(如动态响应、抗干扰能力)的研究需求; 阅读建议:建议读者结合Simulink环境动手搭建模型,深入理解各模块间的信号流向与控制逻辑,重点掌握预测模型构建、代价函数设计与开关状态选择机制,并可通过修改电机参数或控制策略进行拓展实验,以增强实践与创新能力。
根据原作 https://pan.quark.cn/s/23d6270309e5 的源码改编 湖北省黄石市2021年中考数学试卷所包含的知识点广泛涉及了中学数学的基础领域,涵盖了实数、科学记数法、分式方程、几何体的三视图、立体几何、概率统计以及代数方程等多个方面。 接下来将对每道试题所关联的知识点进行深入剖析:1. 实数与倒数的定义:该题目旨在检验学生对倒数概念的掌握程度,即一个数a的倒数表达为1/a,因此-7的倒数可表示为-1/7。 2. 科学记数法的运用:科学记数法是一种表示极大或极小数字的方法,其形式为a×10^n,其中1≤|a|<10,n为整数。 此题要求学生运用科学记数法表示一个天文单位的距离,将1.4960亿千米转换为1.4960×10^8千米。 3. 分式方程的求解方法:考察学生解决包含分母的方程的能力,题目要求找出满足方程3/(2x-1)=1的x值,需通过消除分母的方式转化为整式方程进行解答。 4. 三视图的辨认:该题目测试学生对于几何体三视图(主视图、左视图、俯视图)的认识,需要识别出具有两个相同视图而另一个不同的几何体。 5. 立体几何与表面积的计算:题目要求学生计算由直角三角形旋转形成的圆锥的表面积,要求学生对圆锥的底面积和侧面积公式有所了解并加以运用。 6. 统计学的基础概念:题目涉及众数、平均数、极差和中位数的定义,要求学生根据提供的数据信息选择恰当的统计量。 7. 方程的整数解求解:考察学生在实际问题中进行数学建模的能力,通过建立方程来计算在特定条件下帐篷的搭建方案数量。 8. 三角学的实际应用:题目通过在直角三角形中运用三角函数来求解特定线段的长度。 利用正弦定理求解AD的长度是解答该问题的关键。 9. 几何变换的应用:题目要求学生运用三角板的旋转来求解特定点的...
Python基于改进粒子群IPSO与LSTM的短期电力负荷预测研究内容概要:本文围绕“Python基于改进粒子群IPSO与LSTM的短期电力负荷预测研究”展开,提出了一种结合改进粒子群优化算法(IPSO)与长短期记忆网络(LSTM)的混合预测模型。通过IPSO算法优化LSTM网络的关键参数(如学习率、隐层节点数等),有效提升了模型在短期电力负荷预测中的精度与收敛速度。文中详细阐述了IPSO算法的改进策略(如引入自适应惯性权重、变异机制等),增强了全局搜索能力与避免早熟收敛,并利用实际电力负荷数据进行实验验证,结果表明该IPSO-LSTM模型相较于传统LSTM、PSO-LSTM等方法在预测准确性(如MAE、RMSE指标)方面表现更优。研究为电力系统调度、能源管理提供了高精度的负荷预测技术支持。; 适合人群:具备一定Python编程基础、熟悉基本机器学习算法的高校研究生、科研人员及电力系统相关领域的技术人员,尤其适合从事负荷预测、智能优化算法应用研究的专业人士。; 使用场景及目标:①应用于短期电力负荷预测,提升电网调度的精确性与稳定性;②为优化算法(如粒子群算法)与深度学习模型(如LSTM)的融合应用提供实践案例;③可用于学术研究、毕业论文复现或电力企业智能化改造的技术参考。; 阅读建议:建议读者结合文中提到的IPSO与LSTM原理进行理论学习,重点关注参数优化机制的设计思路,并动手复现实验部分,通过对比不同模型的预测结果加深理解。同时可拓展尝试将该方法应用于其他时序预测场景。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值