rd算法分析

㈠ 请说明RR、OR、AR、AR%的计算方法以及意义。

相对危险度（relative risk，RR）。指暴露于某因素发生某事件的风险，即A/(A+B)，除以未暴露人群发生的该事件的风险，即C/(C+D)，所得的比值，即RR=［A/(A+B)］/［C/(C+D)］，RR适用于队列研究或随机对照试验。回顾性研究中无法计算发病率等，故无法计算RR，此时可以用OR 代替RR.
AR又叫特异危险度、率差（ratedifference, RD）和超额危险度（excessrisk），是暴露组发病率与对照组发病率相差的绝对值，它表示危险特异地归因于暴露因素的程度。相对危险度指暴露组发病率与非暴露组的发病率之比，它反映了暴露与疾病的关联强度，说明暴露使个体发病的危险比不暴露高多少倍，或者说暴露组的发病危险是非暴露组的多少倍。暴露对疾病的病因学意义大。
AR%归因危险度百分比：又称病因分值EF;是指暴露人群中发病或死亡归因于该暴露的部分占全部发病或死亡的百分比。AR%=（Ie-Io）/ Ie
=(RR-1)/RR
PAR人群归因危险度：指总人群发病率中归因于该暴露的部分。PAR=It-Io，It为全人群发病率Io为非暴露组发病率；
PAR%人群归因危险度百分比也称人群病因分值，指PAR占总人群发病率的百分比。=PAR/It=【Pe(RR-1)】/【(Pe(RR-1))+1】

㈡ 常用的排序算法特点和逻辑数据模型特点

常用的排序算法有插入排序，希尔排序，冒泡排序，快速排序，归并排序，堆排序还有基数排序。
排序算法一般考虑的就是两个方面，即时间复杂度和空间复杂度。
其中插入排序，冒泡排序是简单排序，排序的平均时间复杂度是O（n^2）, 最坏的情况是O(n^2)，辅助存储空间是O(1)。
快速排序的平均时间复杂度是O(nlogn), 最坏的情况是O(n^2), 辅助存储空间是O(logn)
归并排序的平均时间复杂度是O(nlogn), 最坏的情况是O(nlogn), 辅助存储空间是O(n)
堆排序平均时间复杂度是O(nlogn), 最坏的情况是O(nlogn), 辅助存储空间是O(1)
基数排序平均时间复杂度是O(d(n+rd)), 最坏的情况是O(d(n+rd)), 辅助存储空间是O(rd),其中d关键字的个数，rd是关键字的取值的个数。

从平均性能上来而言，快速排序最佳，其所需的时间最省，但快排在最坏的情况下的时间性能不如堆排序和归并排序。而后者相比的结果是，在n较大的时候，归并排序需要的时间比堆排序省，但它需要的辅助存储空间比较多。

从方法的稳定性来比较，基数排序是稳定的内排序，所有时间复杂度为O（n^2）的简单排序都是稳定的。然而，快速排序，归并排序，堆排序等时间性能较好的排序方法都是不稳定的。

具体每个排序的思想，楼主可以网络一下，网络都有相应的词条。

㈢ 用算法实现:单链表和顺序表删除。删除顺序表中值相同的多余结点

第8章排序(算法设计)习题练习答案
作者： 来源： http://www.csai.cn 2006年9月4日

13. 将哨兵放在R[n]中，被排序的记录放在R[0..n-1]中，重写直接插入排序算法。
解：
重写的算法如下：
void InsertSort(SeqList R)
{//对顺序表中记录R[0..n-1]按递增序进行插入排序
int i,j;
for(i=n-2;i>=0;i--) //在有序区中依次插入R[n-2]..R[0]
if(R[i].key>R[i+1].key) //若不是这样则R[i]原位不动
{
R[n]=R[i];j=i+1; //R[n]是哨兵
do{ //从左向右在有序区中查找插入位置
R[j-1]=R[j]; //将关键字小于R[i].key的记录向右移
j++;
}while(R[j].key<R[n].key]);
R[j-1]=R[n]; //将R[i]插入到正确位置上
}//endif
}//InsertSort.

14.以单链表作为存储结构实现直接插入排序算法。
解：
#define int KeyType //定义KeyType 为int型
typedef struct node{
KeyType key; //关键字域
OtherInfoType info; //其它信息域，
struct node * next; //链表中指针域
}RecNode; //记录结点类型
typedef RecNode * LinkList ; //单链表用LinkList表示

void InsertSort(LinkList head)
{//链式存储结构的直接插入排序算法,head是带头结点的单链表
RecNode *p,*q,*s;
if ((head->next)&&(head->next->next))//当表中含有结点数大于1
{
p=head->next->next;//p指向第二个节点
head->next=NULL;
q=head;//指向插入位置的前驱节点
while(p)&&(q->next)&&(p->key<q->next->key)
q=q->next;
if (p)
{s=p;p=p->next;// 将要插入结点摘下
s->next=q->next;//插入合适位置：q结点后
q->next=s;
}
}
}

15.设计一算法，使得在尽可能少的时间内重排数组，将所有取负值的关键字放在所有取非负值的关键字之前。请分析算法的时间复杂度。
解：
因为只需将负数关键字排在前面而无需进行精确排列顺序，因此本算法采用两端扫描的方法，就象快速排序采用的方法一样，左边扫描到正数时停止，开始扫描右边，遇到负数时与左边的当前记录交换，如此交替进行，一趟下来就可以完成排序。

void ReSort(SeqList R)
{//重排数组，使负值关键字在前
int i=1,j=n; //数组存放在R[1..n]中
while (i<j) //i<j表示尚未扫描完毕
{ while(i<j&&R[i].key<0) //遇到负数则继续扫描
i++;
R[0]=R[i]; //R[0]为辅助空间
while(i<j&&R[j].key>=0)// 遇到正数则继续向左扫描
j--;
R[i++]=R[j];R[j--]=R[0];//交换当前两个元素并移动指针
}//endwhile
}//ReSort

本算法在任何情况下的比较次数均为n(每个元素和0)相比，交换次数少于n/2，总的来说，时间复杂度为O(n).

*16.写一个双向冒泡排序的算法，即在排序过程中交替改变扫描方向。
解：
算法如下：
void BubbleSort(SeqList R)
{//R[1..n]是待排序文件，双向扫描冒泡排序
int i,j,k;
Boolean exchange; //交换标记
i=n;j=1;
exchange=TRUE;
while (i>j)&&(exchange)
{k=i-1;exchange=FALSE;
while (k>=j)//由下往上扫描
{if (r[k]>r[k+1])
{r[0]=r[k];r[k]=r[k+1];r[k+1]=r[k];exchange=TRUE;//交换
}//endif
k--;
}//endwhile
if (exchange)
{exchange=FALSE;
j++;k=j+1;
while(k<=i)//由上往下扫描
{if (r[k]<r[k-1])
{r[0]=r[k];r[k]=r[k-1];r[k-1]=r[k];exchange=TRUE;//交换
}//endif
k++;
}endwhile
i--;
}//endif
}endwhile
}//endsort

17.下面是一个自上往下扫描的冒泡排序的伪代码算法，它采用lastExchange 来记录每趟扫描中进行交换的最后一个元素的位置，并以它作为下一趟排序循环终止的控制值。请仿照它写一个自下往上扫描的冒泡排序算法。
void BubbleSort(int A[],int n)
//不妨设A[0..n-1]是整型向量
int lastExchange,j,i=n-1;
while (i>0)
lastExchange=0;
for(j=0;j<i;j++)//从上往下扫描A[0..i]
if(A[j+1]<A[j]){
交换A[j]和A[j+1];
lastExchange=j;
}
i=lastExchange;//将i置为最后交换的位置
}//endwhile
}//BubbleSort

解：算法如下：
void BubbleSort(int A[],int n)
//不妨设A[0..n-1]是整型向量
int lastExchange,j,i=0;
while (i<n) //这一条很重要，如不改为这样，算法将无限循环下去
lastExchange=n;
for(j=n-1;j>i;j--)//从下往上扫描A[0..i]
if(A[j-1]<A[j]){
交换A[j]和A[j-1];
lastExchange=j;
}
i=lastExchange;//将i置为最后交换的位置
}//endwhile
}//BubbleSort

18.改写快速排序算法，要求采用三者取中的方式选择划分的基准记录；若当前被排序的区间长度小于等于3时，无须划分而是直接采用直接插入方式对其排序。
解：
改写后的算法如下：
void QuickSort(SeqList R,int low ,int high)
{//对R[low..high]快速排序
int pivotpos;
if(high-low<=2)//若当前区内元素少于3个
{//则进行直接插入排序
InsertSort(R,low,high);
}
else
{
pivotpos=midPartion(R,low,high);
QuickSort(R,low,pivotpos-1);
QuickSort(R,pivotpos+1，high);
}
}//QuickSort

int midPartion(SeqList R,int i, int j)
{//三者取中规则定基准
if(R[(i+j)/2].key>R[i].key)
{ 交换R[(i+j)/2]和R[i];}
if(R[i].key>R[j].key)
{ 交换R[i]和R[j];}
if(R[i].key)<R[(i+j)/2].key)
{ 交换R[i]和R[(i+j)/2];}
//以上三个if语句就使区间的第一个记录的key值为三个key的中间值
return Partion(R,i,j);//这样我们就可以仍使用原来的划分算法了
}

19.对给定的j(1≤j≤n ),要求在无序的记录区R[1..n]中找到按关键字自小到大排在第j个位置上的记录(即在无序集合中找到第j个最小元)，试利用快速排序的划分思想编写算法实现上述的查找操作。
答：
int QuickSort(SeqList R,int j,int low,int high)
{ //对R[low..high]快速排序
int pivotpos； //划分后的基准记录的位置
if(low<high){//仅当区间长度大于1时才须排序
pivotpos=Partition(R，low，high)； //对R[low..high]做划分
if (pivotpos==j) return r[j];
else if (pivotpos>j) return(R,j,low,pivotpos-1);
else return quicksort(R,j,pivotpos+1,high);
}
} //QuickSort

20.以单链表为存储结构，写一个直接选择排序算法。
答：
#define int KeyType //定义KeyType 为int型
typedef struct node{
KeyType key; //关键字域
OtherInfoType info; //其它信息域，
struct node * next; //链表中指针域
}RecNode; //记录结点类型

typedef RecNode * LinkList ; //单链表用LinkList表示

void selectsort(linklist head)
{RecNode *p,*q,*s;
if(head->next)&&(head->next->next)
{p=head->next;//p指向当前已排好序最大元素的前趋
while (p->next)
{q=p->next;s=p;
while(q)
{if (q->key<s->key) s=q;
q=q->next;
}//endwhile
交换s结点和p结点的数据；
p=p->next;
}//endwhile
}//endif
}//endsort

21.写一个heapInsert(R,key)算法，将关键字插入到堆R中去，并保证插入R后仍是堆。提示：应为堆R增加一个长度属性描述(即改写本章定义的SeqList类型描述，使其含有长度域)；将key先插入R中已有元素的尾部(即原堆的长度加1的位置，插入后堆的长度加1)，然后从下往上调整，使插入的关键字满足性质。请分析算法的时间。
答：
#define n 100//假设文件的最长可能长度
typedef int KeyType; //定义KeyType 为int型
typedef struct node{
KeyType key; //关键字域
OtherInfoType info; //其它信息域，
}Rectype; //记录结点类型

typedef struct{
Rectype data[n] ; //存放记录的空间
int length;//文件长度
}seqlist;

void heapInsert(seqlist *R,KeyType key)
{//原有堆元素在R->data[1]~R->data[R->length],
//将新的关键字key插入到R->data[R->length+1]位置后，
//以R->data[0]为辅助空间，调整为堆(此处设为大根堆)
int large;//large指向调整结点的左右孩子中关键字较大者
int low,high;//low和high分别指向待调整堆的第一个和最后一个记录
int i;
R->length++；R->data[R->length].key=key;//插入新的记录
for(i=R->length/2;i>0;i--)//建堆
{
low=i;high=R->length;
R->data[0].key=R->data[low].key;//R->data[low]是当前调整的结点
for(large=2*low;large<=high;large*=2){
//若large>high，则表示R->data[low]是叶子，调整结束；
//否则令large指向R->data[low]的左孩子
if(large<high&&R->data[large].key<R->data[large+1].key)
large++;//若R->data[low]的右孩子存在
//且关键字大于左兄弟，则令large指向它
if (R->data[0].key<R->data[large].key)
{ R->data[low].key= R->data[large].key;
low=large;//令low指向新的调整结点
}
else break;//当前调整结点不小于其孩子结点的关键字，结束调整
}//endfor
R->data[low].key=R->data[0].key;//将被调整结点放入最终的位置上
}//end of for
}end of heapinsert

算法分析：
设文件长度为n,则该算法需进行n/2趟调整，总的时间复杂度与初建堆类似，最坏时间复杂度为O(nlgn)，辅助空间为O(1).

22.写一个建堆算法：从空堆开始，依次读入元素调用上题中堆插入算法将其插入堆中。
答：
void BuildHeap(seqlist *R)
{
KeyType key;
R->length=0;//建一个空堆
scanf("%d",&key);//设MAXINT为不可能的关键字
while(key!=MAXINT)
{
heapInsert(R,key);
scanf("%d",&key);
}
}

23.写一个堆删除算法：HeapDelete(R,i),将R[i]从堆中删去，并分析算法时间，提示：先将R[i]和堆中最后一个元素交换，并将堆长度减1，然后从位置i开始向下调整，使其满足堆性质。
答：
void HeapDelete(seqlist *R,int i)
{//原有堆元素在R->data[1]~R->data[R->length],
//将R->data[i]删除，即将R->data[R->length]放入R->data[i]中后，
//将R->length减1，再进行堆的调整，
//以R->data[0]为辅助空间，调整为堆(此处设为大根堆)
int large;//large指向调整结点的左右孩子中关键字较大者
int low,high;//low和high分别指向待调整堆的第一个和最后一个记录
int j;
if (i>R->length)
Error("have no such node");
R->data[i].key=R->data[R->length].key;
R->length--；R->data[R->length].key=key;//插入新的记录
for(j=i/2;j>0;j--)//建堆
{
low=j;high=R->length;
R->data[0].key=R->data[low].key;//R->data[low]是当前调整的结点
for(large=2*low;large<=high;large*=2){
//若large>high，则表示R->data[low]是叶子，调整结束；
//否则令large指向R->data[low]的左孩子
if(large<high&&R->data[large].key<R->data[large+1].key)
large++;//若R->data[low]的右孩子存在
//且关键字大于左兄弟，则令large指向它
if (R->data[0].key<R->data[large].key)
{ R->data[low].key= R->data[large].key;
low=large;//令low指向新的调整结点
}
else break;//当前调整结点不小于其孩子结点的关键字，结束调整
}//endfor
R->data[low].key=R->data[0].key;//将被调整结点放入最终的位置上
}//end of for
}end of HeapDelete

24.已知两个单链表中的元素递增有序，试写一算法将这两个有序表归并成一个递增有序的单链表。算法应利用原有的链表结点空间。
答：
typedef struct node{
KeyType key; //关键字域
OtherInfoType info; //其它信息域，
struct node * next; //链表中指针域
}RecNode; //记录结点类型

typedef RecNode * LinkList ; //单链表用LinkList表示

void mergesort(LinkList la,LinkList lb,LinkList lc)
{RecNode *p,*q,*s,*r;
lc=la;
p=la;//p是la表扫描指针，指向待比较结点的前一位置
q=lb->next;//q是lb表扫描指针，指向比较的结点
while(p->next)&&(q)
if (p->next->key<=q->key)
p=p->next;
else {s=q;q=q->next;
s->next=p->next;p->next=s;//将s结点插入到p结点后
p=s;}
if (!p->next) p->next=q;
free(lb);
}

25.设向量A[0..n-1]中存有n个互不相同的整数，且每个元素的值均在0到n-1之间。试写一时间为O(n)的算法将向量A排序，结果可输出到另一个向量B[0..n-1]中。
答：
sort(int *A,int *B)
{//将向量A排序后送入B向量中
int i;
for(i=0;i<=n-1;i++)
B[A[i]]=A[i];
}

*26.写一组英文单词按字典序排列的基数排序算法。设单词均由大写字母构成，最长的单词有d个字母。提示：所有长度不足d个字母的单词都在尾处补足空格，排序时设置27个箱子，分别与空格，A，B...Z对应。
答：
#define KeySize 10 //设关键字位数d=10
#define Radix 27 //基数rd为27
typedef RecType DataType;//将队列中结点数据类型改为RecType类型
typedef struct node{
char key[KeySize]; //关键字域
OtherInfoType info; //其它信息域，
}RecType; //记录结点类型
typedef RecType seqlist[n+1];

void RadixSort(seqlist R)
{
LinkQueue B[Radix];
int i;
for(i=0;i<Radix;i++)//箱子置空
InitQueue(&B[i]);
for(i=KeySize-1;i>=0;i--){//从低位到高位做d趟箱排序
Distribute(R,B,i);//第KeySize-i趟分配
Collect(R,B);//第KeySize-i趟收集
}
}

void Distribute(seqlist R,LinkQueue B[], int j)
{//按关键字的第j个分量进行分配，初始时箱子为空
int i;
j=KeySize-j; // 确定关键字从低位起的位置
for(i=0;i<n;i++) //依次扫描R[i]，将其装箱
if (R[i].key[j]-'A'>26)
EnQueue(&B[0],R[i]);//将第j位关键字位空格的记录入第0个队列
else EnQueue(&B[0],R[R[i].key[j]-'A'+1]);
}

void Collect(seqlist R,LinkQueue B[])
{
//依次将各非空箱子中的记录收集起来，本过程结束，各箱子都变空
int i,j;
for (j=0;j<Radix;j++)
while(!QueueEmpty(&B[j]))
R[i++]=DeQueue(&B[j]);//将出队记录依次输出到R[i]中
}

㈣ rd是什么意思

rd abbr. DOS命令 ： 删除空的子目；注册营养师（Registered Dietitian）；乡村免费邮递。

短语词组：

1.Ginsenoside Rd 人参皂甙Rd；人参皂苷Rd；人参皂甙。

2.Side Rd 辅路；

3.Main Rd 干道；地址；

4.Ordinary Rd 一般道路；一般门路；

5.rd millennium 第3千年。

(4)rd算法分析扩展阅读：

双语例句：

1.By Colleen Hurley, RD, Certified Kids Nutrition Specialist The holidays are officially here, and many families celebrate the holiday season with food.

科尔林恩.赫尔利.RD，注册儿童营养专家 节假日正式到来，许多家庭拿出食物庆祝这一节日。

2.They leaned against 4203-RD and worked through their rote of tender gestures: hand-holding, modest-mouthed kisses, a giddy lowering to the ground, me an awkward weight following them down.

他们倚靠在4203-RD上，一板一眼地做起那套温柔把式：拉手、深浅有度的亲吻、晕晕忽忽地往地上滑，我这个糟糕的重负则跟着他们倒地。

3.RD: We do not currently support SCA, but we definitely plan to.

RD：我们目前不会支持SCA，但是我们的确有这个计划。

㈤ 雷达处理信号，以点目标成像为例，采用RD算法，先用距离压缩，然后距离校正，最后方位压缩，各有何用

距离压缩其实就是匹配滤波的过程，距离矫正就是距离对齐了，方位压缩就是方位向匹配滤波，压出目标的方位，对于点目标成像，可以不用距离矫正的

㈥ 加权平均资本成本计算方法

计算方法为每种资本的成本乘以占总资本的比重，然后将各种资本得出的数目加起来

WACC=(E/V）×Re+（D/V）×Rd×(1-Tc)

其中：

WACC=Weighted Average Cost of Capital（加权平均资本成本）

Re =股本成本

Rd =债务成本

E =公司股本的市场价值

D =公司债务的市场价值

V = E + D

E/V =股本占融资总额的百分比

D/V = 债务占融资总额的百分比

Tc = 企业税率

(6)rd算法分析扩展阅读：

加权平均资本成本的评估方法

采用收益途径评估公司价值时，评估师广泛使用的有两种方法——即权益法和投资资本法（有时候也叫直接法和间接法）。

权益法是通过折现公司的红利或股权现金流来评估公司股权的价值，这个折现率应该是反映权益投资者所要求 的回报率。

而投资资本法主要是关注并评估出公司整体的价值，不像权益法只评估权益。投资资本法的评估结果就是所有权利要求者所要求的价值，包括债权人和股东。

此时要求权益的价值就只能是把公司整体价值减去债权的价值（所以被称为间接法）。求取公司价值最普通的做法就是把公司所有投资者的现金流。

包括债权人 和股权投资者的现金流折现，而折现率则是加权平均资本成本——即权益成本和债务成本的加权平均值。

英文简写为WACC.所以，WACC是投资资本价值评估（间接）或公司权益价值评估（直接）的一个重要的计算参数。

加权平均资本成本法在个别项目评估中的应用

运用WACC 方法对个别项目价值进行评估时值得注意的地方就是要根据具体情况对个别项目的风险进行调整，因为资本加权平均成本是就企业总体而言的，一般用于公司整体资产价值的评估。

然而在现实当中，绝大部分企业进行的都是多角化经营，如一个生产型企业可能同时兼营商业或房地产，因而不同类型的投资项目就有着不同的风险。

如果简单的将公司平均资本成本用于公司所有部门和所有投资项目的评估，显然是不妥的。因此在运用WACC方法对个别风险项目进行价值评估时需要对加权平均资本成本进行调整。

对于不同风险的项目，要用不同的加权平均资本成本去衡量，为有关特定项目确定一个具体的接受标准。

根据公式rWACC= (S/B+S）×rs+(B/B+S）×rB×（1-TC）可以看出，要用加权平均资本成本法计算项目的资本成本，需要确定的因素有：

⑴权益融资比例：S/B+S；

⑵债务融资比例：B/B+S；

⑶税后债务融资成本：rB×（1-TC）；

⑷有杠杆（债务）下的权益资本成本rs。如果这四个要素分别确定了，即可用WACC法对采用混合融资的个别项目进行价值评估。

假设条件：

企业的经营风险可以用息税前收益X的标准差来表示，并据此将企业分成不同的组。若不同企业的经营风险程度相同，则它们的风险等级也相同，因而应属于同一组。

资本市场是完全的。其表现主要为第一，不存在交易费用；第二，对于任何投资者，无论是个人投资者还是机构投资者，其借款利率与贷款利率完全相同。

企业的负债属于无风险型，且永久不变，其利率等于无风险的市场基准利率。企业所承担的财务风险不随筹资数量与结构的变动而变动，且不存在破产的可能性。

企业新的投资项目的风险与企业原有水平一致。即新项目的投入不会改变企业整体的经营风险水平。企业的息税前收益X是个恒定的常量。

㈦ 偏最小二乘回归

matlab里面没有直接调用的partial least squares（PLS）.你可能要自己根据运算编啊．

不过你还有一个方法，你可以去下载一个叫chemometrics toolbox的工具装在MATLAB的TOOLBOX．那个TOOLBOX有直接调用的PLS．
偏最小二乘法 最小二乘法是一种数学优化技术，它通过最小化误差的平方和找到一组数据的最佳函数匹配。 用最简的方法求得一些绝对不可知的真值，而令误差平方之和为最小。 通常用于曲线拟合。很多其他的优化问题也可通过最小化能量或最大化熵用最小二乘形式表达。
偏最小二乘回归≈多元线性回归分析＋典型相关分析＋主成分分析
与传统多元线性回归模型相比，偏最小二乘回归的特点是：（1）能够在自变量存在严重多重相关性的条件下进行回归建模；（2）允许在样本点个数少于变量个数的条件下进行回归建模；（3）偏最小二乘回归在最终模型中将包含原有的所有自变量；（4）偏最小二乘回归模型更易于辨识系统信息与噪声（甚至一些非随机性的噪声）；（5）在偏最小二乘回归模型中，每一个自变量的回归系数将更容易解释。
在计算方差和协方差时，求和号前面的系数有两种取法：当样本点集合是随机抽取得到时，应该取1/(n-1)；如果不是随机抽取的，这个系数可取1/n。
多重相关性的诊断
1 经验式诊断方法
1、在自变量的简单相关系数矩阵中，有某些自变量的相关系数值较大。
2、回归系数的代数符号与专业知识或一般经验相反；或者，它同该自变量与y的简单相关系数符号相反。
3、对重要自变量的回归系数进行t检验，其结果不显着。
特别典型的是，当F检验能在高精度下通过，测定系数R2的值亦很大，但自变量的t检验却全都不显着，这时，多重相关性的可能性将很大。
4、如果增加（或删除）一个变量，或者增加（或删除）一个观测值，回归系数的估计值发生了很大的变化。
5、重要自变量的回归系数置信区间明显过大。
6、在自变量中，某一个自变量是另一部分自变量的完全或近似完全的线性组合。
7、对于一般的观测数据，如果样本点的个数过少，样本数据中的多重相关性是经常存在的。
但是，采用经验式方法诊断自变量系统中是否确实存在多重相关性，并不十分可靠，另一种较正规的方法是利用统计检验（回归分析），检查每一个自变量相对其它自变量是否存在线性关系。
2 方差膨胀因子
最常用的多重相关性的正规诊断方法是使用方差膨胀因子。自变量xj的方差膨胀因子记为（VIF）j，它的计算方法为
（4-5） （VIF）j =（1-R j2）-1
式中，R j2是以xj为因变量时对其它自变量回归的复测定系数。
所有xj变量中最大的（VIF）j通常被用来作为测量多重相关性的指标。一般认为，如果最大的（VIF）j超过10，常常表示多重相关性将严重影响最小二乘的估计值。
（VIF）j被称为方差膨胀因子的原因，是由于它还可以度量回归系数的估计方差与自变量线性无关时相比，增加了多少。
不妨假设x1,x2,…,xp均是标准化变量。采用最小二乘法得到回归系数向量B，它的精度是用它的方差来测量的。B的协方差矩阵为
Cov(B)= σ2 (X'X)-1
式中，σ2是误差项方差。所以，对于回归系数b j，有
Var(b j)= σ2cjj
cjj是(X'X)-1矩阵中第j个对角元素。可以证明，
cjj =（VIF）j
岭回归分析
1 岭回归估计量
岭回归分析是一种修正的最小二乘估计法，当自变量系统中存在多重相关性时，它可以提供一个比最小二乘法更为稳定的估计，并且回归系数的标准差也比最小二乘估计的要小。
根据高斯——马尔科夫定理，多重相关性并不影响最小二乘估计量的无偏性和最小方差性。但是，虽然最小二乘估计量在所有线性无偏估计量中是方差最小的，但是这个方差却不一定小。于是可以找一个有偏估计量，这个估计量虽然有微小的偏差，但它的精度却能够大大高于无偏的估计量。
在应用岭回归分析时，它的计算大多从标准化数据出发。对于标准化变量，最小二乘的正规方程为
rXXb=ryX
式中，rXX是X的相关系数矩阵，ryX是y与所有自变量的相关系数向量。
岭回归估计量是通过在正规方程中引入有偏常数c（c≥0）而求得的。它的正规方程为+
（4-8） （rXX+ cI） bR=ryX
所以，在岭回归分析中，标准化回归系数为
（4-9） bR =（rXX+ cI）-1 ryX
2 岭回归估计量的性质
（1）岭回归系数是一般最小二乘准则下回归系数的线性组合，即
（4-10） bR =（I+ crXX-1）-1b
（2）记β是总体参数的理论值。当β≠0时，可以证明一定存在一个正数c0，使得当0< c< c0时，一致地有
（4-11） E|| bR -β||2≤ E|| b -β||2
（3）岭回归估计量的绝对值常比普通最小二乘估计量的绝对值小，即
（4-12） || bR ||<|| b ||
岭回归估计量的质量取决于偏倚系数c的选取。c的选取不宜过大，因为
E（bR）=（I+ crXX-1）-1 E （b）=（I+ crXX-1）-1β
关于偏倚系数c的选取尚没有正规的决策准则，目前主要以岭迹和方差膨胀因子为依据。岭迹是指p-1个岭回归系数估计量对不同的c值所描绘的曲线（c值一般在0~1之间）。在通过检查岭迹和方差膨胀因子来选择c值时，其判断方法是选择一个尽可能小的c值，在这个较小的c值上，岭迹中的回归系数已变得比较稳定，并且方差膨胀因子也变得足够小。
从理论上，最佳的c值是存在的，它可以使估计量的偏差和方差的组合效应达到一个最佳水准。然而，困难却在于c的最优值对不同的应用而有所不同，对其选择还只能凭经验判断。
其他补救方法简介
最常见的一种思路是设法去掉不太重要的相关性变量。由于变量间多重相关性的形式十分复杂，而且还缺乏十分可靠的检验方法，删除部分多重相关变量的做法常导致增大模型的解释误差，将本应保留的系统信息舍弃，使得接受一个错误结论的可能和做出错误决策的风险都不断增长。另一方面，在一些经济模型中，从经济理论上要求一些重要的解释变量必须被包括在模型中，而这些变量又存在多重相关性。这时采用剔除部分相关变量的做法就不符合实际工作的要求。
另一种补救的办法是增加样本容量。然而，在实际工作中，由于时间、经费以及客观条件的限制，增大样本容量的方法常常是不可行的。
此外，还可以采用变量转换的方式，来削弱多重相关性的严重性。一阶差分回归模型有可能减少多重相关性的严重性。然而，一阶差分变换又带来了一些其它问题。差分后的误差项可能不满足总体模型中关于误差项不是序列相关的假定。事实上，在大部分情形下，在原来的误差项是不自相关的条件下，一阶差分所得到的误差项将会是序列相关的。而且，由于差分方法损失了一个观察值，这在小样本的情况下是极不可取的。另外，一阶差分方法在截面样本中是不宜利用的。
1 主成分分析
主成分分析的计算结果必然受到重叠信息的影响。因此，当人为地采用一些无益的相关变量时，无论从方向上还是从数量上，都会扭曲客观结论。在主成分分析之前，对变量系统的确定必须是慎之又慎的。
2 特异点的发现
第i个样本点（样本量为n）对第h主成分的贡献率是
（5-32） CTR(i)=Fh2(i)/(nλh) （若远超过1/n，为特异点）
3 典型相关分析
从某种意义上说，多元回归分析、判别分析或对应分析等许多重要的数据分析方法，都可以归结为典型相关分析的一种特例，同时它还是偏最小二乘回归分析的理论基石。
典型相关分析，是从变量组X中提取一个典型成分F=Xa，再从变量组Y中提取一个成分G=Yb，在提取过程中，要求F与G的相关程度达到最大。
在典型相关分析中，采用下述原则寻优，即
max<F,G>=aX'Yb a'X'Xa=1, b'Y'Yb=1
其结果为，a是对应于矩阵V11-1 V12 V22-1 V21最大特征值的特征向量，而b是对应于矩阵V22-1 V21V11-1 V12最大特征值的特征向量，这两个最大特征值相同。其中，
V11=X'X，V12=X'Y，V22=Y'Y。
F与G之间存在着明显的换算关系。
有时只有一个典型成分还不够，还可以考虑第二个典型成分。
多因变量的偏最小二乘回归模型
1 工作目标
偏最小二乘回归分析的建模方法
设有q个因变量和p个自变量。为了研究因变量与自变量的统计关系，观测了n个样本点，由此构成了自变量与因变量的数据表X和Y。偏最小二乘回归分别在X与Y中提取出t和u，要求：（1）t和u应尽可能大地携带它们各自数据表中的变异信息；（2）t和u的相关程度能够达到最大。在第一个成分被提取后，偏最小二乘回归分别实施X对t的回归以及Y对t的回归。如果回归方程已经达到满意的精度，则算法终止；否则，将利用X被t解释后的残余信息以及Y被t解释后的残余信息进行第二轮的成分提取。如此往复，直到能达到一个较满意的精度为止。若最终对X共提取了多个成分，偏最小二乘回归将通过施行yk对X的这些成分的回归，然后再表达成yk关于原自变量的回归方程。
2 计算方法
首先将数据做标准化处理。X经标准化处理后的数据矩阵记为E0=( E01,…,E0p)n×p，Y的相应矩阵记为F0=( F01,…,F0q)n×q。
第一步 记t 1是E0的第一个成分，t 1= E0w1，w1是E0的第一个轴，它是一个单位向量，即|| w1||=1。
记u 1是F0的第一个成分，u 1= F0c1，c1是F0的第一个轴，并且|| c1||=1。
于是，要求解下列优化问题，即
（7-1）
记θ1= w1'E0'F0c1，即正是优化问题的目标函数值。
采用拉格朗日算法，可得
（7-8） E0'F0F0'E0w1=θ12 w1
（7-9） F0'E0E0'F0c1=θ12 c1
所以，w1是对应于E0'F0F0'E0矩阵最大特征值的单位特征向量，而c1是对应于F0'E0E0'F0矩阵最大特征值θ12的单位特征向量。
求得轴w1和c1后，即可得到成分
t 1= E0w1
u 1= F0c1
然后，分别求E0和F0对t 1的回归方程
（7-10） E0= t 1 p1'+ E1
（7-12） F0= t 1r1'+ F1
式中，回归系数向量是
（7-13） p1= E0' t 1/|| t 1||2
（7-15） r1= F0' t 1/|| t 1||2
而E1和F1分别是两个方程的残差矩阵。
第二步 用残差矩阵E1和F1取代E0和F0，然后，求第二个轴w2和c2以及第二个成分t2，u2，有
t 2= E1w2
u 2= F1c2
θ2=< t2, u2>= w2'E1'F1c2
w2是对应于E1'F1F1'E1矩阵最大特征值的单位特征向量，而c2是对应于F1'E1E1'F1矩阵最大特征值θ22的单位特征向量。计算回归系数
p2= E1' t 2/|| t 2||2
r2= F1' t 2/|| t2||2
因此，有回归方程
E1= t 2 p2'+ E2
F1= t 2r2'+ F2
如此计算下去，如果X的秩是A，则会有
（7-16） E0= t 1 p1'+…+t A pA'
（7-17） F0= t 1r1'+ …+t A rA'+ FA
由于t1，…，t A均可以表示成E01，…，E0p的线性组合，因此，式（7-17）还可以还原成yk*= F0k关于xj*= E0j的回归方程形式，即
yk*=αk1 x1*+…+αkp xp*+ FAk， k=1,2,…,q
FAk是残差矩阵FA的第k列。
3 交叉有效性
如果多一个成分而少一个样本的预测误差平方和（所有因变量和预测样本相加）除以少一个成分的误差平方和（所有的因变量和样本相加）小于0.952，则多一个成分是值得的。
4 一种更简洁的计算方法
用下述原则提取自变量中的成分t 1，是与原则式（7-1）的结果完全等价的，即
（7-24）
（1）求矩阵E0'F0F0'E0最大特征值所对应的单位特征向量w1，求成分t 1，得
t 1= E0w1
E1= E0-t 1 p1'
式中， p1= E0' t 1/|| t 1||2
（2）求矩阵E1'F0F0'E1最大特征值所对应的单位特征向量w2，求成分t2，得
t 2= E1w2
E2= E1-t 2 p2'
式中， p2= E1' t 2/|| t2||2
……
（m）至第m步，求成分tm= Em-1wm，wm是矩阵Em-1'F0F0'Em-1最大特征值所对应的单位特征向量.
如果根据交叉有效性，确定共抽取m个成分t1，…，tm可以得到一个满意的观测模型，则求F0在t1，…，tm上的普通最小二乘回归方程为
F0= t 1r1'+ …+t mrm'+ Fm
偏最小二乘回归的辅助分析技术
1 精度分析
定义自变量成分th的各种解释能力如下
（1）th对某自变量xj的解释能力
（8-1） Rd(xj; th)=r2(xj, th)
（2）th对X的解释能力
（8-2） Rd(X; th)=[r2(x1, th) + …+ r2(xp, th)]/p
（3）t1，…，tm对X的累计解释能力
（8-3） Rd(X; t1，…，tm)= Rd(X; t1) + …+ Rd(X; tm)
（4）t1，…，tm对某自变量xj的累计解释能力
（8-4） Rd(xj; t1，…，tm)= Rd(xj; t1) + …+ Rd(xj; tm)
（5）th对某因变量yk的解释能力
（8-5） Rd(yk; th)=r2(yk, th)
（6）th对Y的解释能力
（8-6） Rd(Y; th)=[r2(y1, th) + …+ r2(yq, th)]/q
（7）t1，…，tm对Y的累计解释能力
（8-7） Rd(Y; t1，…，tm)= Rd(Y; t1) + …+ Rd(Y; tm)
（8）t1，…，tm对某因变量yk的累计解释能力
（8-8） Rd(yk; t1，…，tm)= Rd(yk; t1) + …+ Rd(yk; tm)
2 自变量x j在解释因变量集合Y的作用
x j在解释Y时作用的重要性，可以用变量投影重要性指标VIP j来测度
VIP j 2=p[Rd(Y; t1) w1j2+ …+ Rd(Y; tm) wmj2]/[Rd(Y; t1) + …+ Rd(Y; tm)]
式中，whj是轴wh的第j个分量。注意 VIP1 2+ …+ VIP p2=p
3 特异点的发现
定义第i个样本点对第h成分th的贡献率Thi2，用它来发现样本点集合中的特异点，即
（8-10） Thi2=thi2/((n-1)s h2)
式中，s h2是成分th的方差。
由此，还可以测算样本点i对成分t1，…，tm的累计贡献率
（8-11） Ti2= T1i2+ …+ Tmi2
当
Ti2≥m(n2-1)F0.05(m,n-m)/(n2 (n-m))
时，可以认为在95%的检验水平上，样本点i对成分t1，…，tm的贡献过大。
单因变量的偏最小二乘回归模型
1 简化算法
第一步 已知数据E0，F0，由于u 1= F0，可得
w1= E0'F0/|| E0'F0||
t 1= E0w1
p1= E0' t 1/|| t 1||2
E1= E0-t 1 p1'
检验交叉有效性。若有效，继续计算；否则只提取一个成分t 1。
第h步(h=2,…,m) 已知数据Eh-1，F0，有
wh= Eh-1'F0/|| Eh-1'F0||
t h= Eh-1wh
ph= Eh-1' t h/|| t h||2
Eh= Eh-1-th ph'
检验交叉有效性。若有效，继续计算h+1步；否则停止求成分的计算。
这时，得到m个成分t1，…，t m，实施F0在t1，…，t m上的回归，得
F0^= r1t 1+ …+ rmt m
由于t1，…，t m均是E0的线性组合，即
t h= Eh-1wh= E0wh*
所以F0^可写成E0的线性组合形式，即
F0^= r1 E0w1*+ …+ rm E0wm*= E0[r1 w1*+ …+ rm wm*]
最后，也可以变换成y对x1，…，x p的回归方程
y^= α0+α1x1+ …+αp xp

㈧ 常规的排序算法的共同点是什么

常规的排序算法的共同点是：
（1）比较；
（2）交换，即通过交换两个数据之间的位置关系来达到符合要求的次序；
（3）移动，它是交换的变形，也是通过把数据从某一存储地址换到另外的地址来达到符合要求的次序。
在计算机科学所使用的排序算法通常被分类为：
(a)计算的复杂度（最差、平均、和最好性能），依据列表(list)的大小(n)。
一般而言，好的性能是O(nlogn)，且坏的性能是O(n^2)。对于一个排序理想的性能是O(n)。
而仅使用一个抽象关键比较运算的排序算法总平均上总是至少需要O(nlogn)。
(b)存储器使用量（空间复杂度）（以及其他电脑资源的使用）
(c)稳定度：稳定的排序算法会依照相等的关键（换言之就是值）维持纪录的相对次序。
(d)一般的方法：插入、交换、选择、合并等等。交换排序包含冒泡排序和快速排序。插入排序包含希尔排序，选择排序包括堆排序等。

㈨ matlab中rd是什么意思

距雷达的距离及相对于雷达的径向速度。
rd的算法：原始数据加上距离向fft，再加上距离向参数导入ifft，之后使用方向位fft对距离徙矫正，加上参数在导入方位ifft，然后生成图像。