平衡算法

A. 双足机器人有哪些常见的平衡算法

在最开始的双足机器人使用的平衡控制策略是“静态步行”（static walking）
这种策略的特点是：机器人步行的过程中，重心（COG，Center of Gravity)的投影始终位于多边形支撑区域（support region）内，
这种控制策略的好处在于：在整个的行进过程中，机器人可以在行走动作中停止而不摔倒，但代价是行动速度非常迟缓（每一步需要花费10秒甚至更长）（因为需要保持重心的投影始终位于支撑区域，否则将不稳定），因为静态步行和人类的期望相差甚远，
于是人类开发出来了另一种步行平衡策略：“动态步行”（dynamic walking）。
在动态步行中机器人的行动速度被提升至了每步不超过1秒。但是弊端也是显而易见的，机器人难以在运动的状态下立即停顿（惯性的作用），从而使得机器人在状态转换的过程中变得不稳定。为了解决惯性带来的影响，零力矩点（ZMP，zero moment point）被引入到了这一控制策略中。在单脚支撑相中，ZMP=COG。引入ZMP的好处在于，如果ZMP严格的存在于机器人的支撑区域中，机器人绝对不会摔倒。
Xzmp代表正向ZMP，Xmc代表质量中心的前进位移，l是倒立摆的长度，g是重力加速度。
由于复杂地形的双足平衡无法由单一的控制器实现，所以多个控制器的切换策略被用于解决平衡问题。在这一个策略中，机器人的行走被设定为一个周期（cycle）每一个周期被分成了不同的行走阶段（stage）

B. 求算法：三相平衡度如何算！

a44
,
b22
,
c11
有超过吗如何算?44，22，11是电流吗？如果是，则朋友小学没学好！44-11/44X100%=75%
不平衡达75%，与15%差了5倍！

C. 生产线平衡的计算方法

要衡量工艺总平衡状态的好坏，我们必须设定一个定量值来表示，即生产线平衡率或平衡损失率，以百分率表示。 首先，要明确一点，虽然各工序的工序时间长短不同，但如前所述，决定生产线的作业周期的工序时间只有一个，即最长工序时间--瓶颈工序时间。同时需要区分瓶颈时间与节拍时间，所谓的节拍时间TAKT TIME 是按照客户要求设计的，他的计算方法是等于工作时间*3600sec/需求产量
1、生产线的平衡计算公式
平衡率=（各工序时间总和/（工站数*瓶颈工序时间））*100%=（∑ti/（工站数*CT））*100%
2、生产线的平衡损失率计算公式
平衡损失率=1-（各工序时间总和/（工站数*Takt 时间）） ;
可以参考附图

D. 有没有人懂加全平衡算法求公式

比如数学、物理、化学是最强主科，每科权值是3。语文英语是次之主科，每科权值是2。历史地理是副科，每科权值是1。小红各科分数：数学60、物理50、化学50、语文70、英语80、历史90、地理100。小红加权平均分值=（60*3+50*3+50*3+70*2+80*2+90*1+100*1）/（3+3+3+2+2+1+1）=970/15=64.67分，权值越高，对最后结果影响越大！手机手打，望采纳

E. B-tree的平衡算法

/* btrees.h */
/*
* 平衡多路树的一种重要方案。
* 在 1970 年由 R. Bayer 和 E. McCreight 发明。
*/
#define M 1
/* B 树的阶，即非根节点中键的最小数目。
* 有些人把阶定义为非根节点中子树的最大数目。
*/
typedef int typekey;
typedef struct btnode { /* B-Tree 节点 */
int d; /* 节点中键的数目 */
typekey k[2*M]; /* 键 */
char *v[2*M]; /* 值 */
struct btnode *p[2*M+1]; /* 指向子树的指针 */
} node, *btree;
/*
* 每个键的左子树中的所有的键都小于这个键，
* 每个键的右子树中的所有的键都大于等于这个键。
* 叶子节点中的每个键都没有子树。
*/
/* 当 M 等于 1 时也称为 2-3 树
* +----+----+
* | k0 | k1 |
* +-+----+----+---
* | p0 | p1 | p2 |
* +----+----+----+
*/
extern int btree_disp; /* 查找时找到的键在节点中的位置 */
extern char * InsValue; /* 与要插的键相对应的值 */
extern btree search(typekey, btree);
extern btree insert(typekey,btree);
extern btree delete(typekey,btree);
extern int height(btree);
extern int count(btree);
extern double payload(btree);
extern btree deltree(btree);
/* end of btrees.h */
/*******************************************************/
/* btrees.c */
#include <stdlib.h>
#include <stdio.h>
#include btrees.h
btree search(typekey, btree);
btree insert(typekey,btree);
btree delete(typekey,btree);
int height(btree);
int count(btree);
double payload(btree);
btree deltree(btree);
static void InternalInsert(typekey, btree);
static void InsInNode(btree, int);
static void SplitNode(btree, int);
static btree NewRoot(btree);
static void InternalDelete(typekey, btree);
static void JoinNode(btree, int);
static void MoveLeftNode(btree t, int);
static void MoveRightNode(btree t, int);
static void DelFromNode(btree t, int);
static btree FreeRoot(btree);
static btree delall(btree);
static void Error(int,typekey);
int btree_disp; /* 查找时找到的键在节点中的位置 */
char * InsValue = NULL; /* 与要插的键相对应的值 */
static int flag; /* 节点增减标志 */
static int btree_level = 0; /* 多路树的高度 */
static int btree_count = 0; /* 多路树的键总数 */
static int node_sum = 0; /* 多路树的节点总数 */
static int level; /* 当前访问的节点所处的高度 */
static btree NewTree; /* 在节点分割的时候指向新建的节点 */
static typekey InsKey; /* 要插入的键 */
btree search(typekey key, btree t)
{
int i,j,m;
level=btree_level-1;
while (level >= 0){
for(i=0, j=t->d-1; i<j; m=(j+i)/2, (key > t->k[m])?(i=m+1):(j=m));
if (key == t->k [ i ]){
btree_disp = i;
return t;
}
if (key > t->k [ i ]) /* i == t->d-1 时有可能出现 */
i++;
t = t->p[ i ];
level--;
}
return NULL;
}
btree insert(typekey key, btree t)
{
level=btree_level;
InternalInsert(key, t);
if (flag == 1) /* 根节点满之后，它被分割成两个半满节点 */
t=NewRoot(t); /* 树的高度增加 */
return t;
}
void InternalInsert(typekey key, btree t)
{
int i,j,m;
level--;
if (level < 0){ /* 到达了树的底部: 指出要做的插入 */
NewTree = NULL; /* 这个键没有对应的子树 */
InsKey = key; /* 导致底层的叶子节点增加键值+空子树对 */
btree_count++;
flag = 1; /* 指示上层节点把返回的键插入其中 */
return;
}
for(i=0, j=t->d-1; i<j; m=(j+i)/2, (key > t->k[m])?(i=m+1):(j=m));
if (key == t->k[ i ]) {
Error(1,key); /* 键已经在树中 */
flag = 0;
return;
}
if (key > t->k[ i ]) /* i == t->d-1 时有可能出现 */
i++;
InternalInsert(key, t->p[ i ]);
if (flag == 0)
return;
/* 有新键要插入到当前节点中 */
if (t->d < 2*M) {/* 当前节点未满 */
InsInNode(t, i); /* 把键值+子树对插入当前节点中 */
flag = 0; /* 指示上层节点没有需要插入的键值+子树，插入过程结束 */
}
else /* 当前节点已满，则分割这个页面并把键值+子树对插入当前节点中 */
SplitNode(t, i); /* 继续指示上层节点把返回的键值+子树插入其中 */
}
/*
* 把一个键和对应的右子树插入一个节点中
*/
void InsInNode(btree t, int d)
{
int i;
/* 把所有大于要插入的键值的键和对应的右子树右移 */
for(i = t->d; i > d; i--){
t->k[ i ] = t->k[i-1];
t->v[ i ] = t->v[i-1];
t->p[i+1] = t->p[ i ];
}
/* 插入键和右子树 */
t->k[ i ] = InsKey;
t->p[i+1] = NewTree;
t->v[ i ] = InsValue;
t->d++;
}
/*
* 前件是要插入一个键和对应的右子树，并且本节点已经满
* 导致分割这个节点，插入键和对应的右子树，
* 并向上层返回一个要插入键和对应的右子树
*/
void SplitNode(btree t, int d)
{
int i,j;
btree temp;
typekey temp_k;
char *temp_v;
/* 建立新节点 */
temp = (btree)malloc(sizeof(node));
/*
* +---+--------+-----+-----+--------+-----+
* | 0 | ...... | M | M+1 | ...... |2*M-1|
* +---+--------+-----+-----+--------+-----+
* |<- M+1 ->|<- M-1 ->|
*/
if (d > M) { /* 要插入当前节点的右半部分 */
/* 把从 2*M-1 到 M+1 的 M-1 个键值+子树对转移到新节点中,
* 并且为要插入的键值+子树空出位置 */
for(i=2*M-1,j=M-1; i>=d; i--,j--) {
temp->k[j] = t->k[ i ];
temp->v[j] = t->v[ i ];
temp->p[j+1] = t->p[i+1];
}
for(i=d-1,j=d-M-2; j>=0; i--,j--) {
temp->k[j] = t->k[ i ];
temp->v[j] = t->v[ i ];
temp->p[j+1] = t->p[i+1];
}
/* 把节点的最右子树转移成新节点的最左子树 */
temp->p[0] = t->p[M+1];
/* 在新节点中插入键和右子树 */
temp->k[d-M-1] = InsKey;
temp->p[d-M] = NewTree;
temp->v[d-M-1] = InsValue;
/* 设置要插入上层节点的键和值 */
InsKey = t->k[M];
InsValue = t->v[M];
}
else { /* d <= M */
/* 把从 2*M-1 到 M 的 M 个键值+子树对转移到新节点中 */
for(i=2*M-1,j=M-1; j>=0; i--,j--) {
temp->k[j] = t->k[ i ];
temp->v[j] = t->v[ i ];
temp->p[j+1] = t->p[i+1];
}
if (d == M) /* 要插入当前节点的正中间 */
/* 把要插入的子树作为新节点的最左子树 */
temp->p[0] = NewTree;
/* 直接把要插入的键和值返回给上层节点 */
else { /* (d<M) 要插入当前节点的左半部分 */
/* 把节点当前的最右子树转移成新节点的最左子树 */
temp->p[0] = t->p[M];
/* 保存要插入上层节点的键和值 */
temp_k = t->k[M-1];
temp_v = t->v[M-1];
/* 把所有大于要插入的键值的键和对应的右子树右移 */
for(i=M-1; i>d; i--) {
t->k[ i ] = t->k[i-1];
t->v[ i ] = t->v[i-1];
t->p[i+1] = t->p[ i ];
}
/* 在节点中插入键和右子树 */
t->k[d] = InsKey;
t->p[d+1] = NewTree;
t->v[d] = InsValue;
/* 设置要插入上层节点的键和值 */
InsKey = temp_k;
InsValue = temp_v;
}
}
t->d =M;
temp->d = M;
NewTree = temp;
node_sum++;
}
btree delete(typekey key, btree t)
{
level=btree_level;
InternalDelete(key, t);
if (t->d == 0)
/* 根节点的子节点合并导致根节点键的数目随之减少，
* 当根节点中没有键的时候，只有它的最左子树可能非空 */
t=FreeRoot(t);
return t;
}
void InternalDelete(typekey key, btree t)
{
int i,j,m;
btree l,r;
int lvl;
level--;
if (level < 0) {
Error(0,key); /* 在整个树中未找到要删除的键 */
flag = 0;
return;
}
for(i=0, j=t->d-1; i<j; m=(j+i)/2, (key > t->k[m])?(i=m+1):(j=m));
if (key == t->k[ i ]) { /* 找到要删除的键 */
if (t->v[ i ] != NULL)
free(t->v[ i ]); /* 释放这个节点包含的值 */
if (level == 0) { /* 有子树为空则这个键位于叶子节点 */
DelFromNode(t,i);
btree_count--;
flag = 1;
/* 指示上层节点本子树的键数量减少 */
return;
} else { /* 这个键位于非叶节点 */
lvl = level-1;
/* 找到前驱节点 */
r = t->p[ i ];
while (lvl > 0) {
r = r->p[r->d];
lvl--;
}
t->k[ i ]=r->k[r->d-1];
t->v[ i ]=r->v[r->d-1];
r->v[r->d-1]=NULL;
key = r->k[r->d-1];
}
}
else if (key > t->k[ i ]) /* i == t->d-1 时有可能出现 */
i++;
InternalDelete(key,t->p[ i ]);
/* 调整平衡 */
if (flag == 0)
return;
if (t->p[ i ]->d < M) {
if (i == t->d) /* 在最右子树中发生了删除 */
i--; /* 调整最右键的左右子树平衡 */
l = t->p [ i ];
r = t->p[i+1];
if (r->d > M)
MoveLeftNode(t,i);
else if(l->d > M)
MoveRightNode(t,i);
else {
JoinNode(t,i);
/* 继续指示上层节点本子树的键数量减少 */
return;
}
flag = 0;
/* 指示上层节点本子树的键数量没有减少，删除过程结束 */
}
}
/*
* 合并一个节点的某个键对应的两个子树
*/
void JoinNode(btree t, int d)
{
btree l,r;
int i,j;
l = t->p[d];
r = t->p[d+1];
/* 把这个键下移到它的左子树 */
l->k[l->d] = t->k[d];
l->v[l->d] = t->v[d];
/* 把右子树中的所有键值和子树转移到左子树 */
for (j=r->d-1,i=l->d+r->d; j >= 0 ; j--,i--) {
l->k[ i ] = r->k[j];
l->v[ i ] = r->v[j];
l->p[ i ] = r->p[j];
}
l->p[l->d+r->d+1] = r->p[r->d];
l->d += r->d+1;
/* 释放右子树的节点 */
free(r);
/* 把这个键右边的键和对应的右子树左移 */
for (i=d; i < t->d-1; i++) {
t->k[ i ] = t->k[i+1];
t->v[ i ] = t->v[i+1];
t->p[i+1] = t->p[i+2];
}
t->d--;
node_sum--;
}
/*
* 从一个键的右子树向左子树转移一些键，使两个子树平衡
*/
void MoveLeftNode(btree t, int d)
{
btree l,r;
int m; /* 应转移的键的数目 */
int i,j;
l = t->p[d];
r = t->p[d+1];
m = (r->d - l->d)/2;
/* 把这个键下移到它的左子树 */
l->k[l->d] = t->k[d];
l->v[l->d] = t->v[d];
/* 把右子树的最左子树转移成左子树的最右子树
* 从右子树向左子树移动 m-1 个键+子树对 */
for (j=m-2,i=l->d+m-1; j >= 0; j--,i--) {
l->k[ i ] = r->k[j];
l->v[ i ] = r->v[j];
l->p[ i ] = r->p[j];
}
l->p[l->d+m] = r->p[m-1];
/* 把右子树的最左键提升到这个键的位置上 */
t->k[d] = r->k[m-1];
t->v[d] = r->v[m-1];
/* 把右子树中的所有键值和子树左移 m 个位置 */
r->p[0] = r->p[m];
for (i=0; i<r->d-m; i++) {
r->k[ i ] = r->k[i+m];
r->v[ i ] = r->v[i+m];
r->p[ i ] = r->p[i+m];
}
r->p[r->d-m] = r->p[r->d];
l->d+=m;
r->d-=m;
}
/*
* 从一个键的左子树向右子树转移一些键，使两个子树平衡
*/
void MoveRightNode(btree t, int d)
{
btree l,r;
int m; /* 应转移的键的数目 */
int i,j;
l = t->p[d];
r = t->p[d+1];
m = (l->d - r->d)/2;
/* 把右子树中的所有键值和子树右移 m 个位置 */
r->p[r->d+m]=r->p[r->d];
for (i=r->d-1; i>=0; i--) {
r->k[i+m] = r->k[ i ];
r->v[i+m] = r->v[ i ];
r->p[i+m] = r->p[ i ];
}
/* 把这个键下移到它的右子树 */
r->k[m-1] = t->k[d];
r->v[m-1] = t->v[d];
/* 把左子树的最右子树转移成右子树的最左子树 */
r->p[m-1] = l->p[l->d];
/* 从左子树向右子树移动 m-1 个键+子树对 */
for (i=l->d-1,j=m-2; j>=0; j--,i--) {
r->k[j] = l->k[ i ];
r->v[j] = l->v[ i ];
r->p[j] = l->p[ i ];
}
/* 把左子树的最右键提升到这个键的位置上 */
t->k[d] = l->k[ i ];
t->v[d] = l->v[ i ];
l->d-=m;
r->d+=m;
}
/*
* 把一个键和对应的右子树从一个节点中删除
*/
void DelFromNode(btree t, int d)
{
int i;
/* 把所有大于要删除的键值的键左移 */
for(i=d; i < t->d-1; i++) {
t->k[ i ] = t->k[i+1];
t->v[ i ] = t->v[i+1];
}
t->d--;
}
/*
* 建立有两个子树和一个键的根节点
*/
btree NewRoot(btree t)
{
btree temp;
temp = (btree)malloc(sizeof(node));
temp->d = 1;
temp->p[0] = t;
temp->p[1] = NewTree;
temp->k[0] = InsKey;
temp->v[0] = InsValue;
btree_level++;
node_sum++;
return(temp);
}
/*
* 释放根节点，并返回它的最左子树
*/
btree FreeRoot(btree t)
{
btree temp;
temp = t->p[0];
free(t);
btree_level--;
node_sum--;
return temp;
}
void Error(int f,typekey key)
{
if (f)
printf(Btrees error: Insert %d! ,key);
else
printf(Btrees error: delete %d! ,key);
}
int height(btree t)
{
return btree_level;
}
int count(btree t)
{
return btree_count;
}
double payload(btree t)
{
if (node_sum==0)
return 1;
return (double)btree_count/(node_sum*(2*M));
}
btree deltree (btree t)
{
level=btree_level;
btree_level = 0;
return delall(t);
}
btree delall(btree t)
{
int i;
level--;
if (level >= 0) {
for (i=0; i < t->d; i++)
if (t->v[ i ] != NULL)
free(t->v[ i ]);
if (level > 0)
for (i=0; i<= t->d ; i++)
t->p[ i ]=delall(t->p[ i ]);
free(t);
}
return NULL;
}
/* end of btrees.c */

F. 平衡二叉树算法

多值结点平衡二叉树的结构及算法研究
1引言
传统的AV1.树是一种应用较为广泛的数据结构，适合”几组织在内存中的较小索引.它的
每个结l从上存储有一个关键字、一个平衡因子和两个指针项，山”几它是一棵接近”几理想状态的
平衡二叉树，所以AV1.树具有很高的查询效率.但正如任何事物都具有两而性一样，AV1.树同
样存在比较严重的缺l从，一是存储效率比较低:真正有用的关键字在结l从上所，片的空间比例较
小，而作为辅助信息的平衡因子和指针却，片据较大的空间;二是额外运算量比较大:当有结l从
被插入或删除而导致AV1.树不平衡时，AV1.树就需要进行调整而保持它的平衡性，山”几每个
结l从上只有一个关键字，所以任何一次的数据插入或删除都有可能导致AV1.树的平衡调整，
这种频繁的调整运算将大大降低AV1.树的存取效率.为解决以上问题，结合T3树每个结l从可
以存储多个关键字项的优l侧}l，木文提出了多值结l从平衡二叉树(简称MAV1.树)，它的主要特
点在”几每个MAV1.树的结l从都存储有多个关键字项，而其它信息仍与AV1.树一样，即一个平
衡因子和两个指针项.
2 MAV1.树结构描述
MAV1.树仍旧是一种平衡二叉树，它的整体树型结构和算法也是建立在传统的平衡二叉
树基础之上的.MAV1.树的特征在”几它的每个结l从都可以存储多个关键字(较理想的取值大约
在20} 50个之间).用C++语言描述的MAV1.树结l从结构如卜:
struct NodeStruct
int IJ1emsOnNode;
int bf:
struct NodPStruct*lch;ld:
//一结点中项的数目
//平衡因子
//夕.子
struct NodeStruct * rchild:
}lemType }lemsi Max}lem} ;//结点中的项数组
Node T:
在这种结构中.ElemsOnNode反映的是“当前状态卜”该结l从中关键字项的个数.当在此结
点插入一个关键字时.FlemsOnNode值加1.当删除一个关键字时.则FlemsOnNode值减1.每个
结l从上可存储的关键字个数介J几1 } M axElem之间.bf为平衡因r.其作用等同J几AV1.树的平
衡因r. MAV1.树的任一结l从的平衡因r只能取一1 ,0和1.如果一个结l从的平衡因r的绝对
值大”几1.则这棵树就失去了平衡.需要做平衡运算保持平衡.lehild和:child分别为指向左右
J"树根结0的指针.Flems[ i]为结0中第i个关键字项.Flems} MaxFlem”是一个按升序排列的
关键字数组.具体的MAV1.树结l从结构如图1所示.
}lemsOnNode一h‘一* leh;ld一
图1
reh击3
}lemsi 0}一
树结点结构
}lemsi Max}lem}
MAVT
MAV1.树的结构特l从使它比AV1.树具有更高的存储效率.在AV1.树或MAV1.树中.实际
有用的信急只有关键字.1f1! ElemsOnNode ,bf ,lehild和:child都是为了构建树型结构If1J不得不添
加的辅助信急. MAV1.树就是通过减小这些辅助信急的比例来获得较高的存储效率.山MAV1.
树结l从的定义可以看出:FlemsOnNode和bf为int型.各，片4个字节长度.指针型的lchild和
rchild也各，片4个字节长度.在以上四项信急中.AV1.树结l从除了没有ElemsOnNode外.其余和
MAV1.树相同.现假设关键字长度为24字节.M axFl二值定为50.则对AV1.树来说.它的结l从
长度为36字节.其中辅助信h,长度为12字节;If}J MAV1.树的结l从长度是1. 2K字节.其中辅助
信急长度为16字节.山此可以看出.MAV1.树在存储时.结l从中辅助信急长度，片整个结l从长度
的比例是很小的.它对存储空间的利用效率比 AV1.树要高.这一l从对”几主要而向内存应用的
MAV1.树来说是非常重要的.
在实际的应用中.当MAV1.树作为数据库索引结构时.为进一步节约内存空间.结l从中Fl-
emType的结构可根据实际需要作不同的定义.
( 1)当排序关键字较短时.可以直接将数据库中的关键字值拷贝到索引文件中.这样
MAV1.树既有较快的运行速度又不会，片用太大的空间.此时ElemType定义如卜
struct IdxRlemStruct
{
int RecPos://金己录号
KeyType Key://关键字
}R1emType;
( 2}当排序关键字较长时.如果直接将数据库中的关键字值拷贝到索引文件中会，片据较大
的空间.此时可以采用只存储关键字地址的形式.这样不管关键字有多长.映射到MAV1.树后
都只，片据一个指针的固定长度.这种以时间换空间的方法比较适合内存容量有限的情况.此时
ElemType定义如卜
struct Tdxl?lemStruct
int RecPos:
char * Key
R1emType;
//记录号
//关键字指钊
3基于MAUI.树的运算
MAUI.树的基木运算.包括MAUI.树的建立、记录的插入、删除、修改以及查询.这些算法
与基J几AVI.树的算法相似.都建立在一叉查询和平衡算法基础上.
3. 1 MAVI,树的平衡运算
如果在一棵原木是平衡的MAUI.树中插入一个新结l从.造成了不平衡.此时必须调整树的
结构.使之平衡化“21 .MAUI.树的平衡算法与AVI.树的平衡算法是相同的.但山J几MAUI.树的
每个结l从中都存储有多个关键字.所以在关键字个数相同的情况卜. MAUI.树的应用可以大大
减少平衡运算的次数.例如.假设具有n个关键字的待插入序列在插入过程中有5%(根据随
机序列特l从的不同.此数值会有所差异.这里以比较保守的5%为例)的新产生结l从会导致一
叉树出现不平衡.对AVI.树来说.山”几需要为每个关键字分配一个结l从.所以在整个插入过程
中做平衡的次数为n * 5%;对J几MAUI.树.设MAUI.树中M axFl二的值被定义为k(k为大J几1
的正整数少，则平均每k次的数据插入才会有一个新结l从产生，所以在整个插入过程中需做平
衡的次数仅为(nlk) * 5%.即在M axFl二取值为k的情况卜.对”几相同的待插入关键字序列.
在插入过程中MAUI.树用J几平衡运算的开销是AVI.树的1/ k.
3. 2数据查找
在MAUI.树上进行查找.是一个从根结l从开始.沿某一个分支逐层向卜进行比较判等的过
程.假设要在MAUI.树上查找的值为GetKey.查找过程从根结l从开始.如果根指针为NU1.1..则
查找失败;否则把要查找的值GetKey与根结l从关键字数组中的最小项Elems [ 0]进行比较.如
果GetKev小”几当前结i最小关键字.则递归查找左r树;如果GetKey'大”几Elems [ 0].则将
GetKey'与根结0关键字数组中的最大项Fletns} MaxFl二一1]进行比较.如果GetKey'大”几当前
结l从最大关键字.则递归查找右r树;否则.对当前结l从的关键字数组进行查找(山”几是有序序
列.可以采用折半查找以提高效率).如果有与GetKey'相匹配的值.则查找成功.返回成功信
息,7{报告查找到的关键字地址.
3. 3数据插入
数据插入是构建MAV1.树的基础.设要在MAV1.树*T上插入一个新的数据兀素GetKev,
其递归算法描述如卜:
(1)若*T为空树.则申清一新结} ' Elems} MaxElem}.将GetKey'插入到Flems[ 0]的位置.树
的深度增1.
(2)若*T未满.则在*T中找到插入位置后将GetKey'插入.JI在插入后保持结l从中的各
关键项有序递增.若己存在与GetKev相同的项.则不进行插入.
(3)如果*T为满结l从目一GetKey'值介”几Flems[ 0]和Flems} MaxFlem]之间.则在*T中找到
GetKev的插入位置posit ion.山”几*T木身就是满结l从.所以GetKev的插入必然会将原来*T中
的某个数据挤出去JI卜降到r树中.根据插入位置position的不同.分以卜几种情况处理:若*
T中存在与C etl} e`'相同的项.则不进行插入;若插入位置在*T结ii的前半部分(即position <
=MaxFlem/ 2).则将Flems[ 1]到Fletns} position”的数据依次左移一位.再把GetKey插入到Elems
} MaxFlem”中position的位置.Ifn原来*T中最左边项数据将被挤入到*T的左r树中.考察此
数据的特l从.它必然大”几*T左r树中的任一数据项.所以此时不需要作任何的额外运算.直
接将此数据插入到*T左r树根结i从的最右r孙位置处就可以了(见图2中插入，}} 11"后“1,>
的位置变化);若插入位置在*T结ii的后半部分(即position> MaxFlem/ 2).则将Fletns} posi-
tion}到Fletns} MaxFl二一2}的数据依次右移一位.再把GetKev插入到*T结0中position的位
置.与前一种情况类似.结l从中最右边被挤出的项将被插入到*T的右r树根结l从的最左r孙
的位置(见图2中插入“25"后" 30"的位置变化).
插入，"}i”插入”zs0
}o i is i }a
s}土 s
图2
满结点插入数据的过程
(4)若GetKey的值小”几T的最小项值.则将GetKey递归插入到T的左r树中.即在递归调
用时GetKey值不变Ifn T= T->lehild.
(5)若GetKey的值大”几T的最大项值.则将GetKey递归插入到T的右r树中.即在递归调
用时GetKey值不变Ifn T= T->rehild.
4结束语
山J几MAV1.树的结l从中存储有多个关键字值.所以它具有较高的存储效率;对MAV l树进
行查找是_分查找和顺序查找的结合.其查询效率只略低”几AV1.树.血山”几MAV1.树的平衡
运算比AV1.树要少得多.所以MAV1.树有很优秀的综合运算效率.综上所述.在数据量大、内
存容量相对较小、数据增删运算比较频繁的情况卜.用MAV1.树作为常驻内存的索引结构是一
种理想的选择.

G. 动平衡计算

允许不平衡量的计算公式为：M*e=mper*r，转子的偏心距e=G*1000/ω，转子的角速度ω=2πn/60。

上述计算公式中mper为允许不平衡量，M代表转子的自身重量，单位是kg；G代表转子的平衡精度等级 ，单位是mm/s；ω代表转子的角速度，单位是弧度/秒；r代表转子的校正半径，单位是mm；n代表转子的工作转速，单位是rpm；e代表转子的偏心距，单位是μm。

(7)平衡算法扩展阅读：

平衡时的转速和工作转速不一致，造成平衡精度下降。例如：有不少转子属于二阶临界转速的扰性转子，由于平衡机本身转速有限，这些转子若采用工艺平衡，则无法有效地防止转子在高速下发生变形而造成的不平衡。

有些转子，由于受到尺寸和重量上的限制，很难甚至无法在平衡机上平衡。例如：对于大型发电机及透平一类的特大转子，由于没有相应的特大平衡装置，往往会造成无法平衡。

H. SSD平衡磨损算法的疑问

SSD装得越满，速度就越受影响，这个是没错的。因为负载平衡算法要用到剩余空间，但SandForce主控受这个影响较大，而M4影响不大。
至于你一开始说的那个极端情况，也不是简单这样分析。通常主控会把频繁读写的热数据平摊到每个颗粒每个区块。长远来看，这样性能会很受影响（因为平衡磨损均摊会造成大量地址变动），但对寿命而言，50MB热数据只是毛毛雨。
对于你的实际情况，请注意一点：读，是几乎不产生磨损的；写，才影响寿命。SSD主控的使命是兼顾性能和寿命，没事的时候吃饱了撑的去挪动超大文件？无论如何，主控不可能为了磨损平均度就玩命地搬移数据，平摊的过程本身就要造成读写，这方面SSD会有自己的算法来做到平衡。记住一点，寿命到时基本所有颗粒的磨损度都差不多！不可能给你造成只有某个颗粒读写特别厉害的情况。更何况还有预留空间，即使有颗粒超出预期地早挂，还有备份的顶上。
关于你说的WIN7后台挪动的问题，我只问你一句：相比winxp，win7才有的trim指令是干吗的？不就是为了SSD后台智能优化，恢复性能回收可用地址的嘛！这一切都是无声智能的。而且你要明白，一个超大的系统文件可能地址都分散映射在不同的SSD颗粒里面，即使为了磨损平衡，也只要变动很少一部分地址而已，没必要整个挪动大文件的。
对于你的补充，相信你现在也该明白了，如果在这种极端情况下，SSD主控会逐渐把不动的那些数据小部分小部分转移，让这100M的读写磨损尽量平均分布到所有颗粒上，了解？
PS：所以我当初狠狠心，直接上M4 128G了，系统盘丢进去，魔兽丢进去，还剩60G不到空间，干脆再把所有应用软件通通扔进去，这下能加速的都加速了，剩余空间也足够，寿命也好速度也好都妥妥的。
建议你去PCEVA论坛固态硬盘板块看看，版大对SSD的讲解深入浅出，以后看到OCZ之流的动辄5，600M速度就能一眼看穿猫腻在哪里。很庆幸，选了镁光，选了M4~