标题：AVL
自平衡二叉查找树
概述在计算机科学中，AVL树是最先发明的自平衡二叉查找树。AVL树得名于它的发明者 G.M. Adelson-Velsky 和 E.M. Landis，他们在 1962 年的论文 "An algorithm for the organization of information" 中发表了它。AVL 节点数计算高度为 h 的 AVL 树，节点数 N 最多2^h − 1； 最少 （其中）。
最少节点数 n 如以费伯纳西数列可以用数学归纳法证明：
Nh= F【h+ 2】 - 1 (F【h+ 2】是 Fibonacci polynomial 的第h+2个数）。
即：
N0 = 0 （表示 AVL Tree 高度为0的节点总数）
N1 = 1 （表示 AVL Tree 高度为1的节点总数）
N2 = 2 （表示 AVL Tree 高度为2的节点总数）
Nh= N【h− 1】 + N【h− 2】 + 1 （表示 AVL Tree 高度为h的节点总数）
换句话说，当节点数为 N 时，高度 h 最多为。
节点的平衡因子是它的右子树的高度减去它的左子树的高度。带有平衡因子 1、0 或 -1 的节点被认为是平衡的。带有平衡因子 -2 或 2 的节点被认为是不平衡的，并需要重新平衡这个树。平衡因子可以直接存储在每个节点中，或从可能存储在节点中的子树高度计算出来。操作AVL树的基本操作一般涉及运做同在不平衡的二叉查找树所运做的同样的算法。但是要进行预先或随后做一次或多次所谓的"AVL 旋转"。
假设由于在二叉排序树上插入结点而失去平衡的最小子树根结点的指针为a（即a是离插入点最近，且平衡因子绝对值超过1的祖先结点），则失去平衡后进行进行的规律可归纳为下列四种情况：
单向右旋平衡处理RR：由于在*a的左子树根结点的左子树上插入结点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行一次右旋转操作； 
单向左旋平衡处理LL：由于在*a的右子树根结点的右子树上插入结点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行一次左旋转操作； 
双向旋转（先左后右）平衡处理LR：由于在*a的左子树根结点的右子树上插入结点，*a的平衡因子由1增至2，致使以*a为根的子树失去平衡，则需进行两次旋转（先左旋后右旋）操作。
双向旋转（先右后左）平衡处理RL：由于在*a的右子树根结点的左子树上插入结点，*a的平衡因子由-1变为-2，致使以*a为根的子树失去平衡，则需进行两次旋转（先右旋后左旋）操作。插入向AVL树插入可以通过如同它是未平衡的二叉查找树一样把给定的值插入树中，接着自底向上向根节点折回，于在插入期间成为不平衡的所有节点上进行旋转来完成。因为折回到根节点的路途上最多有 1.5 乘 log n 个节点，而每次 AVL 旋转都耗费恒定的时间，插入处理在整体上耗费 O(log n) 时间。　在平衡的的二叉排序树Balanced BST上插入一个新的数据元素e的递归算法可描述如下：　若BBST为空树，则插入一个数据元素为e的新结点作为BBST的根结点，树的深度增1； 　若e的关键字和BBST的根结点的关键字相等，则不进行； 　若e的关键字小于BBST的根结点的关键字，而且在BBST的左子树中不存在和e有相同关键字的结点，则将e插入在BBST的左子树上，并且当插入之后的左子树深度增加（+1）时，分别就下列不同情况处理之：　BBST的根结点的平衡因子为-1（右子树的深度大于左子树的深度，则将根结点的平衡因子更改为0，BBST的深度不变； 　BBST的根结点的平衡因子为0（左、右子树的深度相等）：则将根结点的平衡因子更改为1，BBST的深度增1； 　BBST的根结点的平衡因子为1（左子树的深度大于右子树的深度）：则若BBST的左子树根结点的平衡因子为1：则需进行单向右旋平衡处理，并且在右旋处理之后，将根结点和其右子树根结点的平衡因子更改为0，树的深度不变； 　若e的关键字大于BBST的根结点的关键字，而且在BBST的右子树中不存在和e有相同关键字的结点，则将e插入在BBST的右子树上，并且当插入之后的右子树深度增加（+1）时，分别就不同情况处理之。删除从AVL树中删除可以通过把要删除的节点向下旋转成一个叶子节点，接着直接剪除这个叶子节点来完成。因为在旋转成叶子节点期间最多有 log n个节点被旋转，而每次 AVL 旋转耗费恒定的时间，删除处理在整体上耗费 O(log n) 时间。查找在AVL树中查找同在一般BST完全一样的进行，所以耗费 O(log n) 时间，因为AVL树总是保持平衡的。不需要特殊的准备，树的结构不会由于查询而改变。（这是与伸展树查找相对立的，它会因为查找而变更树结构。）参考实现给出一个操作AVLTREE的完整程序 大部分由Peter Brass编写　#include <iostream.h>　#include <math.h>；　#include <stdlib.h>；　//建立一个整数类型　typedef struct obj_n_t　{　int obj_key；　} obj_node_t；　//建立树结点的基本机构　typedef struct tree_n_t 　{　int key；　struct tree_n_t *left,*right；　int height；　} tree_node_t；　//建立堆栈　#define MAXSIZE 512　tree_node_t *stack[MAXSIZE]; //warning!the tree can contain 256 leaves at most!　int i=0; //堆栈计数器　//堆栈清空　void stack_clear（）　{　while(i!=0)
{
stack[i-1]=NULL;
i--;
}
}
//堆栈为空
int stack_empty()
{
return(i==0);
}
//入栈函数
int push(tree_node_t *node)
{
if(i<MAXSIZE)
{
stack[i++]=node;
return(0);
}
else
return(-1);
}
//出栈函数
tree_node_t *pop()
{
if(i>0)
return(stack[--i]);
else
return(0);
}
//建立get_node函数，用于动态分配内存空间
tree_node_t *get_node()
{
tree_node_t *tmp;
tmp=(tree_node_t *)malloc(sizeof(tree_node_t));
return(tmp);
}
//建立return_node函数，用于释放内存
void return_node(tree_node_t *free_node)
{
free(free_node);
}
//建立左旋转函数
void left_rotation(tree_node_t *node)
{
tree_node_t *tmp;
int tmp_key;
tmp=node->left;
tmp_key=node->key;
node->left=node->right;
node->key=node->right->key;
node->right=node->left->right;
node->left->right=node->left->left;
node->left->left=tmp;
node->left->key=tmp_key;
}
//建立右旋转函数
void right_rotation(tree_node_t *node)
{
tree_node_t *tmp;
int tmp_key;
tmp=node->right;
tmp_key=node->key;
node->right=node->left;
node->key=node->left->key;
node->left=node->right->left;
node->right->left=node->right->right;
node->right->right=tmp;
node->right->key=tmp_key;
}
int rebalance(tree_node_t *node)
{
int finished=0;
while(!stack_empty()&&!finished)
{
int tmp_height,old_height;
node=pop(); //back to the root along the search path
old_height=node->height;
if(node->left->height-node->right->height==2)
{
if(node->left->left->height-node->right->height==1)
{
right_rotation(node);
node->right->height=node->right->left->height+1;
node->height=node->right->height+1;
}
else
{
left_rotation(node->left);
right_rotation(node);
tmp_height=node->left->left->height;
node->left->height=tmp_height+1;
node->right->height=tmp_height+1;
node->height=tmp_height+2;
}
}
else if(node->left->height-node->right->height==-2)
{
if(node->right->right->height-node->left->height==1)
{
left_rotation(node);
node->left->height=node->left->right->height+1;
node->height=node->left->height+1;
}
else
{
right_rotation(node->right);
left_rotation(node);
tmp_height=node->right->right->height;
node->left->height=tmp_height+1;
node->right->height=tmp_height+1;
node->height=tmp_height+2;
}
}
else
{
if(node->left->height>node->right->height)
node->height=node->left->height+1;
else
node->height=node->right->height+1;
}
if(node->height==old_height)
finished=1;
}
stack_clear();
return(0);
}
//建立creat_tree函数，用于建立一颗空树
tree_node_t *creat_tree()
{
tree_node_t *root;
root=get_node();
root->left=root->right=NULL;
root->height=0;
return(root); //build up an empty tree.the first insert bases on the empty tree.
}
//建立find函数，用于查找一个对象
obj_node_t *find(tree_node_t *tree,int query_key)
{
tree_node_t *tmp;
if(tree->left==NULL)
return(NULL);
else
{
tmp=tree;
while(tmp->right!=NULL)
{
if(query_key<tmp->key)
tmp=tmp->left;
else
tmp=tmp->right;
}
if(tmp->key==query_key)
return((obj_node_t*)tmp->left);
else
return(NULL);
}
}
//建立插入函数
int insert(tree_node_t *tree,obj_node_t *new_obj)
{
tree_node_t *tmp;
int query_key,new_key;
query_key=new_key=new_obj->obj_key;
if(tree->left==NULL)
{
tree->left=(tree_node_t *)new_obj;
tree->key=new_key;
tree->height=0;
tree->right=NULL;
}
else
{
stack_clear();
tmp=tree;
while(tmp->right!=NULL)
{
//use stack to remember the path from root to the position at which the new object should be inserted.
//then after inserting,we can rebalance from the parrent node of the leaf which pointing to new object to the root node.
push(tmp); 
if(query_key<tmp->key)
tmp=tmp->left;
else
tmp=tmp->right;
}
if(tmp->key==query_key)
return(-1);
else
{
tree_node_t *old_leaf,*new_leaf;
//It must allocate 2 node space in memory.
//One for the new one,another for the old one.
//the previous node becomes the parrent of the new node.
//when we delete a leaf,it will free two node memory spaces as well.
old_leaf=get_node();
old_leaf->left=tmp->left;
old_leaf->key=tmp->key;
old_leaf->right=NULL;
old_leaf->height=0;
new_leaf=get_node();
new_leaf->left=(tree_node_t *)new_obj;
new_leaf->key=new_key;
new_leaf->right=NULL;
new_leaf->height=0;
if(tmp->key<new_key)
{
tmp->left=old_leaf;
tmp->right=new_leaf;
tmp->key=new_key;
}
else
{
tmp->left=new_leaf;
tmp->right=old_leaf;
}
tmp->height=1;
}
}
rebalance(tmp);
return(0);
}
//建立删除函数
int del(tree_node_t *tree,int key)
{
tree_node_t *tmp,*upper,*other;
if(tree->left==NULL)
return(-1);
else if(tree->right==NULL)
{
if(tree->key==key)
{
tree->left=NULL;
return(0);
}
else
return(-1);
}
else
{
tmp=tree;
stack_clear();
while(tmp->right!=NULL)
{
upper=tmp;
push(upper);
if(key<tmp->key)
{
tmp=upper->left;
other=upper->right;
}
else
{
tmp=upper->right;
other=upper->left;
}
}
if(tmp->key!=key)
return(-1);
else
{
upper->key=other->key;
upper->left=other->left;
upper->right=other->right;
upper->height=upper->height-1;
return_node(tmp);
return_node(other);
rebalance(pop());
//here must pop,then rebalance can run from the parrent of upper,because upper has become a leaf.
return(0);
}
}
}
//建立测试遍历函数
int travel(tree_node_t *tree)
{
stack_clear();
if(tree->left==NULL)
push(tree); 
else if(tree->left!=NULL)
{
int m=0;
push(tree);
while(i!=m)
{
if(stack[m]->left!=NULL && stack[m]->right!=NULL)
{
push(stack[m]->left);
push(stack[m]->right);
}
m++;
}
}
return(0);
}
//建立测试函数
int test_structure(tree_node_t *tree)
{
travel(tree);
int state=-1;
while(!stack_empty())
{
--i;
if(stack->right==NULL && stack->height==0) //this statement is leaf,but also contains an empty tree
state=0;
else if(stack->left!=NULL && stack->right!=NULL)
{
if(abs(stack->height-stack->height)<=1)
state=0;
else
{
state=-1;
stack_clear();
}
}
}
stack_clear();
return(state);
}
//建立remove_tree函数
int remove_tree(tree_node_t *tree)
{
travel(tree);
if(stack_empty())
return(-1);
else
{
while(!stack_empty())
{
return_node(pop());
}
return(0);
}
}
void main()
{
tree_node_t *atree=NULL;
obj_node_t obj[256],*f; //MAXSIZE=n(number of leaf)+(n-1) number of node
int n,j=0;
cout<<"Now Let's start this program! There is no tree in memory.\n";
int item;
while(item!=0)
{
cout<<"\nRoot address = "<<atree<<"\n";
cout<<"\n1.Create a tree\n";
cout<<"\n2.Insert a int type object\n";
cout<<"\n3.Test the structure of the tree\n";
cout<<"\n4.Find a object\n";
cout<<"\n5.Travel\n";
cout<<"\n6.Delete a object\n";
cout<<"\n7.Remove the Tree\n";
cout<<"\n0.Exit\n";
cout<<"\nPlease select:";
cin>>item;
cout<<"\n\n\n";
switch(item)
{
case 1:
{
atree=creat_tree();
cout<<"\nA new empty tree has been built up!\n";
break;
}
case 2:
{
if(atree!=NULL)
while(n!=3458)
{
cout<<"Please insert a new object.\nOnly one object every time(3458 is an end code) : ";
cin>>n;
if(n!=3458)
{
obj[j].obj_key=n;
if(insert(atree,&obj[j])==0)
{
j++;
cout<<"Integer "<<n<<" has been input!\n\n";
}
else
cout<<"\n\nInsert failed!\n\n";
}
}
else
cout<<"\n\nNo tree in memory,insert Fail!\n\n";
break;
}
case 3:
{
if(atree!=NULL)
{
n=test_structure(atree);
if(n==-1)
cout<<"\n\nIt's not a correct AVL tree.\n\n";
if(n==0)
cout<<"\n\nIt's a AVL tree\n\n";
}
else
cout<<"\n\nNo tree in memory,Test Fail!\n\n";
break;
}
case 4:
{
if(atree!=NULL)
{
cout<<"\n\nWhat do you want to find? : ";
cin>>n;
f=find(atree,n);
if(f==NULL)
{
cout<<"\n\nSorry,"<<n<<" can't be found!\n\n";
}
else
{
cout<<"\n\nObject "<<f->obj_key<<" has been found!\n\n";
}
}
else
cout<<"\n\nNo tree in memory,Find Fail!\n\n";
break;
}
case 5:
{
if(atree!=NULL)
{
travel(atree);
for(int count=0;count<i;count++)
{
cout<<" "<<stack[count]->key<<",";
}
}
else
cout<<"\n\nNo tree in memory,Travel Fail!\n\n";
break;
}
case 6:
{
if(atree!=NULL)
{
cout<<"\n\nWhich object do you want to delete?\n\n";
cin>>n;
if(del(atree,n)==0)
{
cout<<"\n\n"<<n<<" has been deleted!\n\n";
}
else
cout<<"\n\nNo this object\n\n";
}
else
cout<<"\n\nNo tree in memory,Delete Fail!\n\n";
break;
}
case 7:
{
if(atree!=NULL)
{
remove_tree(atree);
cout<<"\n\nThe Tree has been removed!\n\n";
atree=NULL;
}
else
cout<<"\n\nNo tree in memory,Removing Fail!\n\n";
}
default:
cout<<"\n\nNo this operation!\n\n";
}
n=0;
}
}Java代码实现public class AVLTree<T extends Comparable<? super T>> {
private AVLNode<T> root;
public AVLTree() {
root = null;
}
/**
* Check if given item x is in the tree.
*/
public boolean contains(T x) {
return contains(x, root);
}
/**
* Internal method to check if given item x is in the subtree.
* 
* @param x
* the given item to check.
* @param t
* the node that roots the subtree.
*/
private boolean contains(T x, AVLNode<T> t) {
while (t != null) {
int compareResult = x.compareTo(t.element);
if (compareResult < 0)
t = t.left;
else if (compareResult > 0)
t = t.right;
else
return true;
}
return false;
}
/**
* Insert a new item to the AVL tree.
* 
* @param x
* the item to insert.
*/
public void insert(T x) {
root = insert(x, root);
}
/**
* Internal method to insert into a subtree.
* 
* @param x
* the item to insert.
* @param t
* the node that roots the subtree.
* @return the new root of the subtree.
*/
private AVLNode<T> insert(T x, AVLNode<T> t) {
if (t == null)
return new AVLNode<T>(x);
int compareResult = x.compareTo(t.element);
if (compareResult < 0) {
t.left = insert(x, t.left);
if (height(t.left) - height(t.right) == 2)
if (x.compareTo(t.left.element) < 0)
t = rotateWithLeftChild(t);
else
t = doubleWithLeftChild(t);
} else if (compareResult > 0) {
t.right = insert(x, t.right);
if (height(t.right) - height(t.left) == 2)
if (x.compareTo(t.right.element) > 0)
t = rotateWithRightChild(t);
else
t = doubleWithRightChild(t);
} else
;
t.height = Math.max(height(t.left), height(t.right)) + 1;
return t;
}
/**
* Return the height of root t, or -1, if null.
* 
* @param t
* an AVLNode.
* @return the height.
*/
private int height(AVLNode<T> t) {
return t == null ? -1 : t.height;
}
/**
* Single rotation (left-left). Update height, then return new root.
*/
private AVLNode<T> rotateWithLeftChild(AVLNode<T> z) {
AVLNode<T> y = z.left;
z.left = y.right;
y.right = z;
z.height = Math.max(height(z.left), height(z.right)) + 1;
y.height = Math.max(height(y.left), z.height) + 1;
return y;
}
/**
* Single rotation (right-right). Update height, then return new root.
*/
private AVLNode<T> rotateWithRightChild(AVLNode<T> z) {
AVLNode<T> y = z.right;
z.right = y.left;
y.left = z;
z.height = Math.max(height(z.left), height(z.right)) + 1;
y.height = Math.max(height(y.right), z.height) + 1;
return y;
}
/**
* Double rotation (left-right).
*/
private AVLNode<T> doubleWithLeftChild(AVLNode<T> z) {
z.left = rotateWithRightChild(z.left);
return rotateWithLeftChild(z);
}
/**
* Double rotation (right-left).
*/
private AVLNode<T> doubleWithRightChild(AVLNode<T> z) {
z.right = rotateWithLeftChild(z.right);
return rotateWithRightChild(z);
}
/**Remove item x.*/
public void remove(T x) {
root = remove(x, root);
}
/**
* Remove item x from subtree t.
* @param x the item to be removed.
* @param t the node that roots the subtree.
* @return the new root of the subtree.
*/
private AVLNode<T> remove(T x, AVLNode<T> t) {
if (t == null)
return t;
int compareResult = x.compareTo(t.element);
if (compareResult < 0) {
t.left = remove(x, t.left);
if (height(t.right) - height(t.left) == 2)
if (height(t.right.left) < height(t.right.right))
t = rotateWithRightChild(t);
else
t = doubleWithRightChild(t);
} else if (compareResult > 0) {
t.right = remove(x, t.right);
if (height(t.left) - height(t.right) == 2)
if (height(t.left.left) > height(t.left.right))
t = rotateWithLeftChild(t);
else
t = doubleWithLeftChild(t);
} else if (t.left != null && t.right != null) {
t.element = findMin(t.right).element;
t.right = remove(t.element, t.right);
if (height(t.left) - height(t.right) == 2)
if (height(t.left.left) > height(t.left.right))
t = rotateWithLeftChild(t);
else
t = doubleWithLeftChild(t);
} else {
t = (t.left != null) ? t.left : t.right;
}
if (t != null)
t.height = Math.max(height(t.left), height(t.right)) + 1;
return t;
}
public T findMin() {
if (isEmpty())
return null;
return findMin(root).element;
}
private AVLNode<T> findMin(AVLNode<T> t) {
while (t.left != null)
t = t.left;
return t;
}
public T findMax() {
if (isEmpty())
return null;
return findMax(root).element;
}
private AVLNode<T> findMax(AVLNode<T> t) {
while (t.right != null)
t = t.right;
return t;
}
public void makeEmpty() {
root = null;
}
public boolean isEmpty() {
return root == null;
}
/** Internal class AVLNode */
private static class AVLNode<T> {
T element;
AVLNode<T> left;
AVLNode<T> right;
int height;
public AVLNode(T element) {
this(element, null, null);
}
public AVLNode(T element, AVLNode<T> left, AVLNode<T> right) {
this.element = element;
this.left = left;
this.right = right;
this.height = 0;
}
}
}
AVL（李斯特内燃机及测试设备公司）
公司简介李斯特内燃机及测试设备公司 (AVL List GmbH）是一家在世界汽车、发动机行业拥有极高知名度和良好声誉的高科技公司。李斯特公司成立于1948年，当时只是一个简陋的设计工作间，今天她已发展成为一个集发动机科研、开发、设计、咨询、以及发动机测试设备生产的跨国高科技集团，3,100名员工。其总部位于风景如画的奥地利格拉茨市，45个子公司及分支机构遍布世界各地，是目前世界上最大的、独立的、私有的专业公司。也是全球规模最大的从事内燃机设计开发、动力总成研究分析以及有关测试系统和设备开发制造的私有公司。全世界所有的发动机制造商都在AVL的客户名单里，特别是内燃机领域。
AVL是世界三大权威内燃机研发机构之一。
公司发展
李斯特公司和中国的友谊源远流长。公司创始人老李斯特教授在1926年到1932年的6年时间里，一直到在上海同济大学任教。
在过去的几十年里，公司创始人老李斯特教授及AVL公司始终把为中国培养一流的科技人材、支持中国发动机事业的独立快速发展放在第一位。为此，他们向同济大学、吉林工业大学（现吉林大学）等科研教育单位捐赠了技术及设备；设立了奖学金，资助中国优秀学生，开展学术互访活动；为中国的汽车、火车、船用及工业用发动机进行开发设计、改型优化，并邀请中方技术人员参与相关的重要技术工作，在实践中培养中国发动机领域的人材，扶植中国发动机行业的独立发展。
老李斯特教授及AVL公司的倾心努力，得到了中国发动机行业的称赞。至今，中国的发动机行业一直把AVL公司亲切地称为"李斯特研究所"，言意之中即认为AVL公司是一个科研开发、人材培训的理想基地。
武侠小说里，武林高手往往内功深厚，掌握高超武艺，如郭靖的降龙十八掌，段誉的六脉神剑。
在中国汽车“江湖”，特别是发动机及内燃机“江湖”，AVL（李斯特内燃机及测试设备公司）绝对称得上“武林高手”，而且是来自奥地利的洋“武林高手”。据了解，AVL是唯一一家帮助用户从产品设计一直到投产，而且是唯一一家全部自己提供测试设备并百分之百由自己生产的公司。
目前，几乎你所听说过的国内、国外汽车生产厂家都是AVL公司的合作伙伴。其中，AVL的两大核心业务——内燃机开发设计和测试设备均占中国市场70%以上的份额；AVL在中国已拥有200多家中国用户，与一汽锡柴、潍柴、上柴、大柴等许多发动机及汽车厂家都有合作。
在2005上海国际车展上，奇瑞展示了多款轿车发动机，让人们大饱眼福；奇瑞也在前不久对外宣布了他们将进军欧美市场。奇瑞能有如此大的成就，其实也是多亏有了这位“武林高手”指点迷津。奇瑞董事长尹同耀曾在公开场合说过，“与AVL公司联合开发的世界一流的两个汽油机家族和柴油机系列，均采用了先进的技术，基本上与世界上发达公司技术水平发展同步，某些高配置的发动机达到世界领先水平，为奇瑞公司实行走出去战略打下了坚实基础。” 
“在AVL与奇瑞之间的合作项目中，AVL与奇瑞的相关负责人员一起沟通，进行分工来开发产品；我们的目标是帮助中国企业做强，能够自主开发品牌产品。”AVL中国地区总裁连世康（Michael Laske）介绍道。基于这一点，AVL仍会继续传授中国汽车企业“内功心法”。
助推“新潮流” 
2005年6月13日，连世康上任“绿色柴油机推广计划”（GDI）的联合执行主席。GDI最初由7家公司共同发起，如今已经进入第五个年头，GDI的核心成员几乎都是洋“武林高手”，包括戴姆勒—克莱斯勒，康明斯、博世、沃尔沃卡车等国际汽车巨头。
GDI向中央和地方政府以及企业、消费者介绍先进柴油机技术以及使用高品质的燃油和润滑油以达到更低的排放标准，旨在协助中国实现社会发展和环境保护的统一目标。
据了解，在2004年，欧洲客车市场的柴油机占有率达到了48%。在一些国家，在新车的销售中，柴油机车的比例甚至达到了60%—70%。
连世康认为，柴油机在中国的使用需要一个过程，因为以前的柴油发动机技术不行，柴油质量差等原因，导致在公路上，经常看到一连串黑烟从车尾冒出来。但是现在，柴油机技术已经有了很大的改进，但燃油和润滑油的品质还有待于进一步提高以适应先进的柴油机技术以使先进的绿色柴油机技术在环保改善问题上发挥更大的作用。GDI所有成员会共同努力，尽最大的努力帮助中国政府、企业及公众，让他们了解目前柴油机的技术和今后的发展趋势。
由于快速的经济增长，中国需要从国外进口更多的石油以维持工业和交通运输的需求，而同时这些工业以及运输业也无时无刻都在产生和排放污染。GDI成员认为清洁柴油和高级的汽车柴油机技术可以帮助中国减少对进口石油的依赖，可以减少气体排放污染，并可以帮助政府和汽车消费者节省在汽油上的支出。
据了解，在油耗相同的情况下，柴油机车可以驾驶的距离比汽油机车要多30%。更好的燃料经济意味着汽车消费者使用更少的燃料，同时从使用柴油机车中节省支出。对于一个汽车消费者，如果每年行驶20，000公里，使用柴油机车可以每年节省4,000—5,000 人民币（或每个月大概330—415 人民币）。
在中国，如果有1/3的轿车使用柴油机，那么整个国家每天就可以节省百万元人民币，同时减少了对国外燃油的进口依赖。
而且，使用柴油还带来很多好处，柴油机比较省油，柴油机车比汽油机车的二氧化碳排放量少30%；柴油机是非常耐用的，使用寿命比汽油机要长。
连世康认为，在3—5年内，中国使用柴油机的状况会有较明显的变化。
据悉，今年以来，油价持续上涨等消息，似乎使柴油车的前景变得光明起来。汽车企业将柴油车及柴油发动机的研发视为重点，成为一种新的趋势。
日前，专注于SUV生产的华泰现代表示，油价上涨在很大程度上冲击了销量，推出柴油SUV是一种比较经济、节约成本的做法。
有这种计划的并不只是华泰现代，长丰猎豹也表示，下阶段将考虑推出柴油SUV；中兴汽车也有此计划。
除了SUV企业，轿车企业也将柴油车项目提上了日程。上海大众的柴油版帕萨特和POLO也正在研发过程中。同时，东风雪铁龙和长安福特也准备在今后推出柴油轿车。
但目前，国内企业研发柴油机能力到底怎么样呢，它们能赶上柴油“新潮流”吗？或许，我们可以从连世康讲述AVL与国内外客户合作的情况中略知一二。“如果说国内客户与国外客户有什么不同的话，很明显，国外的公司比较有经验，同你合作时非常清楚需要的是什么，项目的定义、到底要达到什么样的指标……在这方面他们不会再与我们协商。而国内的客户普遍对发动机开发整个流程所需的时间估计不足，通常要求产品设计、开发的时间越短越好，对样机出来以后的工作往往重视不够。” 
据了解，样机出来以后的过程是非常重要的，它需要通过实验来检验，包括12万公里的路试等，确定发动机的设计和工艺到底过不过关。国内许多客户为了抢夺市场空间，通常要求AVL缩短项目周期。对此，AVL只有尽力与客户协商想出许多办法来解决用户的问题。
新产品投产一个很重要的问题是供应商的选择，连世康又一次指出了中国客户的软肋。“中国的主机企业对供应商控制得不大好。AVL可以提出用哪些供应商的零件，但到底用不用这些供应商、这些零件是怎样生产的，AVL控制不了。”这有时就让AVL陷入了困境，有些客户拿到的零件是劣质的，AVL的设计技术就算太高明，也难免不会出问题。中国“缘”读到这，或许让读者最为困惑的是，从目前来看，新型柴油机技术在中国处于起步阶段，在洋“武林高手”面前，很多国内企业本身具有的技术显得不堪一击。那像AVL这样的洋“武林高手”，为何还要强调愿与中国企业共同合作，一起沟通、探讨来研发呢？除了商业上的考虑外，从AVL的发展历程看，有一点是不容忽视的，这就是“缘分”。
1926年，有一位老外怀着对中国的向往来到了上海，并在那里开始了他的发动机领域的生涯。这位老外就是AVL的创始人老李斯特教授。从1926年到1932年的6年时间里，他在上海同济大学任职教授。“他不仅深受学生的爱戴，自己也深深地爱上了中国这个‘古老优秀’的国家，爱上了这里的人民。” 
李斯特公司成立于1948年，当时只是一个简陋的设计工作间，后来不断扩大业务。
文化大革命还未结束，老李斯特教授即指示所属公司尽可能向中国输出世界一流的技术及设备。
在随后的25年里，老李斯特教授及AVL公司始终把为中国培养一流的科技人材、支持中国发动机事业的独立快速发展放在第一位。为此，他们向同济大学、吉林工业大学（现吉林大学）等科研教育单位捐赠了技术及设备；设立了奖学金，资助中国优秀学生，开展学术互访活动；为中国的汽车、火车、船用及工业用发动机进行开发设计、改型优化，并邀请中方技术人员参与相关的重要技术工作，在实践中培养中国发动机领域的人才，扶植中国发动机行业的独立发展。
另外，为中国政府部门提供咨询及支持，也是李斯特公司一直不懈努力的一部分：1987年，李斯特公司曾协助机械部制定了《中国内燃机发展系列型谱》；协助国家机械局制定《中国柴油机烟度排放标准》，为其无偿提供咨询、设备等各种软硬件帮助。
1995年，又一个热爱中国文化的美国人加盟AVL。早在1981年，他就踏上了中国本土，那时候他只是20岁出头的小伙子，之前担任过研究员、院长助理，调查、撰写、编辑、翻译有关中国大陆和台湾地区经济状况的文章，对中国的经济发展有相当的了解。
之后，他担任过美国公司FUQUA WORLD TRADE CORPORATION 及CONTITRADE SERⅥCES. INC的中国部经理，还担任过TRANSCONTINENTAL TRADE && FINANCE LIMITED美国部经理等职位。
这个人就是连世康，他最骄傲的事情之一就是他能讲一口流利的普通话。
连世康具有较强的管理与领导能力，对中国市场非常了解，工作经验丰富等等，使AVL在中国市场如虎添翼。
AVL于1995年设立上海代表处，1999年在福建厦门与国家科技部中国科技开发院（厦门）合资成立了“厦门海腾发动机测试设备有限公司”。
2001年是AVL公司在中国开展业务的第26个年头，5月19日，李斯特技术中心（上海）有限公司在上海市举行了隆重的奠基仪式，包括奥地利总统、上海市副市长在内的中奥两国政府官员及行业专家、媒体人士等各界朋友出席了仪式。
随着在中国业务的不断扩大和发展，AVL公司于2003年在重庆开设了第三个代表处，以适应西部大开发战略及开拓广大西部市场的需要，使西部广大客户能享受与东部沿海地区同样快捷方便贴近客户的服务。
苦炼“内功” 
当然，能称得上“武林高手”的一大必备条件是，要具有高强的“武艺”。对于AVL——“五脏”这么“庞大”的高手，最需要做的是不断修炼，提高内功。连世康认为，最关键的因素是公司的人员，管理好人的因素，保持良好的工作气氛，公司才有很好的发展。
记得唐峻先生曾说过，“我任微软中国公司总裁时，有一个不成文规定——任何到微软工作的人，都需要经过我的面试。当时很多人不太理解，认为CEO这么做有浪费时间之嫌。事实上，我的用意是：通过面试，让所有进微软的员工感受到公司对其的重视。有一次，我在美国开会，而国内有一个岗位急需招人，因此有位员工‘逃过’我的面试直接进入微软。在接下来的试用期，他表现得很出色。不过几个月过后，他来找我，让我再面试他一次。原因是：在平时，员工间互相调侃时，大伙喜欢拿他开玩笑，因为他没经过我的面试，是溜进来，类似‘非正式军’。我对他说：他已经表现得很称职，不需要面试，不过他很坚持。最后我满足了他的愿望，面试让他从心理上感觉自己是个纯粹的微软人。” 
在这一点上，连世康与唐骏可谓不谋而合，连世康认为，“每个员工都是公司的商标，而不是工厂，生产设备，电脑或者办公室。”所以，要做到尊重每个员工，每次招聘新员工，连先生不管有多忙，都要抽出时间与面试者面谈，之后他（她）才成为AVL中国公司的新员工。
此外，作为一家技术咨询公司，AVL很重视技术创新。据了解，AVL在中国每年的销售收入从1995年的400万美元增长到2004年的近6000万美元，而公司总部每年销售收入的10%左右要确保用于新技术的研发。连世康认为，AVL要始终保持比客户了解更多更新的技术，才能更好地为客户服务。
目前，AVL总部的研究部门里正在使用着48个发动机试验室，其中有整车噪声试验室，14个排放试验室等，都在应用AVL自己生产的排放仪和转鼓。AVL在市场上推出的每一个新产品都是经过AVL产品设计部门苛刻的试验。
连世康称，AVL5年之前在中国的绝大多数业务是测试设备，现在设计研发的项目越来越多。随着大批外国公司在中国开始建立技术中心，他们在测试设备方面的需求量很大。未来几年，设计研发业务将以中国公司为主，测试设备业务以外国公司为主。
而且，随着AVL在中国的业务不断扩大，人员增多，到年底AVL将迁往三元桥附近的佳程广场办公；2006年，AVL将成立广州办事处。连世康称，广州、重庆、上海、北京等地是中国汽车发展集中的地方，AVL将扩大在这些地方的投资，以扩大AVL在中国的业务。未来3—5年内，将使中国发展成为AVL的第二大战略市场。目前，德国、美国是AVL的前两大战略市场，中国排在第三位。
AVL－气动布局分析与设计软件
AVL是Athena Vortex Lattice的简称，由美国麻省理工学院的Drela博士及其学生开发，可用用于亚声速飞机气动特性和操稳特性的分析。