Pascal 二叉树的问题

2 二叉树

堆排序怎么建立初始堆_堆排序建立初始堆详细步骤

堆排序怎么建立初始堆_堆排序建立初始堆详细步骤

(1)空二叉树——(a)；

(2)只有一个根结点的二叉树——(b)；

(3)右子树为空的二叉树——(c)；

(4)左子树为空的二叉树——(d)；

(5)完全二叉树——(e)

注意：尽管二叉树与树有许多相似之处，但二叉树不是树的特殊情形。

2.两个重要的概念：

(1)完全二叉树——只有最下面的两层结点度小于2，并且最下面一层的结点都集中在该层最左边的若干位置的二叉树；

(2)满二叉树——除了叶结点外每一个结点都有左右子女且叶结点都处在层的二叉树,。

如下图：

完全二叉树

3.二叉树的性质

(1) 在二叉树中，第i层的结点总数不超过2^(i-1)；

(2) 深度为h的二叉树最多有2h-1个结点(h>=1)，最少有h个结点；

(3) 对于任意一棵二叉树，如果其叶结点数为N0，而度数为2的结点总数为N2，

则N0=N2+1；

(4) 具有n个结点的完全二叉树的深度为int（log2n）+1

(5)有N个结点的完全二叉树各结点如果用顺序方式存储，则结点之间有如下关系：

若I为结点编号则 如果I<>1，则其父结点的编号为I/2；

如果2I<=N，则其左儿子（即左子树的根结点）的编号为2I；若2I>N，则无左儿子；

如果2I+1<=N，则其右儿子的结点编号为2I+1；若2I+1>N，则无右儿子。

4.二叉树的存储结构：

(1）顺序存储方式

type node=record

data:datatype

l,r:integer;

end;堆排序初始堆不，因为这个堆的顺序存在多个，只要满足根和子之间的关系就行。堆排序指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质。数据是事实或观察的结果，是对客观事物的逻辑归纳，是用于表示客观事物的未经加工的原始素材。数据可以是连续的值，比如声音、图像，称为模拟数据。

var tr:array[1..n] of node;

(2)链表存储方式，如：

type btree=^node；

node=record

data:datatye;

end;

5.普通树转换成二叉树：凡是兄弟就用线连起来，然后去掉父亲到儿子的连线，只留下父母到其个子女的连线。

6.二叉树的遍历运算（递归定义）

(1)先序遍历

访问根；按先序遍历左子树；按先序遍历右子树

(2)中序遍历②BuildHeap的实现

按中序遍历左子树；访问根；按中序遍历右子树

(3)后序遍历

按后序遍历左子树；按后序遍历右子树；访问根

例1.用顺序存储方式建立一棵有31个结点的满二叉树，并对其进行先序遍历。

program erchashu1;

var b:array[1..31] of char;

e:array[1..63] of byte;

n,h,i,k:integer;

procedure tree(t:integer);

if e[t]=0 then exit

else

write(b[t]);e[t]:=0;

t:=2t;tree(t);

t:=t+1;tree(t);

end;

end;

repeat

write('n=');readln(n);

until (n>0) and (n<6);

fillchar(e,sizeof(e),0);

k:=trunc(exp(nln(2)))-1;

for i:=1 to k do e[i]:=1;

for i:=1 to 26 do b[i]:=chr(64+i);

for i:=1 to 5 do b[26+i]:=chr(48+i);

h:=1 ;tree(h);

wrin;

end.

例2.用顺序存储方式建立一棵如图所示的二叉树，并对其进行先序遍历。

program tree1;

const n=15;

type node=record

data:char;

l,r:0..n;

end;

var tr:array[1..n] of node;

e:array[1..n] of 0..1;

i,j:integer;

procedure jtr;

var i:integer;

for i:=1 to n do

with tr[i] do

readln(data,l,r);

end;

procedure search(m:integer);

with tr[m] do

write(data);

if l<>0 then search(l);

if r<>0 then search(r);

end;

end;

jtr;search(1);wrin;

end.

例3 用链表存储方式生成上述二叉树，中序遍历之。

2.根据广义表串（以#结束）生成二叉树。

program ltree;

const n=8;

type trlist=^node;

node=record

da:char;

l,r:trlist;

end;

var s:array[1..n] of trlist;

p,root:trlist;

ch:char;

top,k:integer;

procedure creat(var head:trlist);

read(ch);

top:=0;

while ch<>'#' do

case ch of

'A'..'Z':begin new(p);p^.da:=ch;p^.l:=nil;p^.r:=nil;

if top<>0 then

case k of

1:s[top]^.l:=p;

2:s[top]^.r:=p;

end

end;

'(':begin top:=top+1;s[top]:=p;k:=1;end;

')': top:=top-1;

',': k:=2;

end;

read(ch);

end;

head:=s[1];

end;

procedure inorder(head:trlist);

if head^.l<>nil then inorder(head^.l);

write(head^.da);

if head^.r<>nil then inorder(head^.r);

end;

write('Input tree string:');

creat(root);

inorder(root);

end.

5.3 二叉树的应用

1. 哈夫曼树与哈夫曼码

树的路径长度：一棵树的每一个叶结点到根结点的路径长度的和。

带权二叉树：给树的叶结点赋上某个实数值（称叶结点的权）。

带权路径长度：各叶结点的路径长度与其权值的积的总和。

哈夫曼树（二叉树）：带权路径长度最小的二叉树。

如何构建哈夫树：（思想是：权越大离跟越近）

program gojiantree;

const n=4;m=7;

type node=record

w:real;

parent,lchild,rchild:0..m

end;

htree=array[1..m] of node;

var htree1:htree;

procedure gjtree(var ht:htree);

var i,j:integer;

all1,all2:real;

p1,p2:0..m;

with ht[i] do

w:=0;lchild:=0;rchild:=0;parent:=0;

end;

for i:=1 to n do read(ht[i].w);

for i:=n+1 to m do

p1:=0;p2:=0;

all1:=1000;all2:=1000;

for j:=1 to i-1 do

if ht[j].parent=0 then

if ht[j].w

begin all2:=all1;all1:=ht[j].w;p2:=p1;p1:=j end

else if ht[j].w

ht[p1].parent:=i;

ht[p2].parent:=i;

ht[i].lchild:=p1;

ht[i].rchild:=p2;

ht[i].w:=ht[p1].w+ht[p2].w;

end;

end;

gjtree(htree1);

end.

哈夫曼码：哈夫曼树的非叶结点到左右孩子的路径分别用0，1 表示，从根到叶的路径序列即为哈夫曼码。

哈夫曼码是不会发生译码多义性的不等长编码，广泛应用实际中。

（原因是任何一字符的编码不是更长编码的前缀部分，为什么？）

2.排序二叉树

排序二叉树：每一个参加排列的数据对应二叉树的一个结点，且任一结点如果有左（右）子树，则左（右）子树各结点的数据必须小（大）于该结点的数据。中序遍历排序二叉树即得排序结果。程序如下：

program pxtree;

const

a:array[1..8] of integer=(10,18,3,8,12,2,7,3);

type point=^nod;

nod=record

w:integer;

right,left:point ;

end;

var root,first:point;k:boolean;i:integer;

procedure hyt(d:integer;var p:point);

if p=nil then

new(p);

with p^ do begin w:=d;right:=nil;left:=nil end;

if k then begin root:=p; k:=false end;

end

else with p^ do if d>=w then hyt(d,right) else hyt(d,left);

end;

procedure hyt1(p:point);

with p^ do

if left<>nil then hyt1(left);

write(w:4);

if right<>nil then hyt1(right);

end

end;

first:=nil;k:=true;

for i:=1 to 8 do hyt(a[i],first);

hyt1(root);wrin;

end.

3.堆排序

Ri<=R2i 和Ri<=R2i+1(或>=)

堆的性质：堆的根结点上的元素是堆中的最小元素，且堆的每一条路径上的元素都是有序的。

堆排序的思想是：

1）建初始堆（将结点[n/2],[ n/2]-1,...3,2,1分别调成堆）

2）当未排序完时

输出堆顶元素，删除堆顶元素，将剩余的元素重新建堆。

程序如下：

program duipx;

const n=8;

type arr=array[1..n] of integer;

var a:arr;i:integer;

procedure sift(var a:arr;l,m:integer);

var i,j, t:integer;

i:=l;j:=2i;t:=a[i];

while j<=m do

if (ja[j+1]) then j:=j+1;

if t>a[j] then

begin a[i]:=a[j];i:=j;j:=2i; end

else exit;

end;

a[i]:=t;

end;

for i:=(n div 2) downto 1 do

sift(a,i,n);

for i:=n downto 2 do

write(a[1]:4);

sift(a,1,i-1);

end;

wrin(a[1]:4);

end.

急！ 内部堆排序算法的实现！！！包括大根堆的实现和小根堆的实现！！！要完整的！！！

1、 堆排序定义

n个关键字序列Kl，K2，…，Kn称为堆，当且仅当该序列满足如下性质(简称为堆性质)：

(1) ki≤K2i且ki≤K2i+1 或(2)Ki≥K2i且ki≥K2i+1(1≤i≤ )

若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如小根堆示例和大根堆示例所示。

2、大根堆和小根堆

根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆。

根结点(亦称为堆顶)的关键字是堆里所有结点关键字中者，称为大根堆。

①堆中任一子树亦是堆。

②以上讨论的堆实际上是二叉堆(Binary Heap)，类似地可定义k叉堆。

3、堆排序特点

堆排序(HeapSort)是一树形选择排序。

堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字(或最小)的记录。

4、堆排序与直接插入排序的区别

直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较作。

堆排序可通过树形结构保存部分比较结果，可减少比较次数。

5、堆排序

堆排序利用了大根堆(或小根堆)堆顶记录的关键字(或最小)这一特征，使得在当前无序区中选取(或最小)关键字的记录变得简单。

（1）用大根堆排序的基1.将上述二叉树用广义表表示为A(B(D,E(G)),C(F(,H)))本思想

① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

② 再将关键字的记录R[1](即堆顶)和无序区的一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③ 由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字的记录R[1]和该区间的一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

① 初始化作：将R[1..n]构造为初始堆；

② 每一趟排序的基本作：将当前无序区的堆顶记录R[1]和该区间的一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。

①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻，堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止。

（3）堆排序的算法：

void HeapSort(SeqIAst R)

{ //对R[1..n]进行堆排序，不妨用R[0]做暂存单元

int i；

BuildHeap(R)； //将R[1-n]建成初始堆

for(i=n;i>1；i--){ //对当前无序区R[1..i]进行堆排序，共做n-1趟。

R[0]=R[1]；R[1]=R[i];R[i]=R[0]； //将堆顶和堆中一个记录交换

Heapify(R，1，i-1)； //将R[1..i-1]重新调整为堆，R[1]可能违反堆性质

} //HeapSort

（4） BuildHeap和Heapify函数的实现

因为构造初始堆必须使用到调整堆的作，先讨论Heapify的实现。

① Heapify函数思想方法

每趟排序开始前R[l..i]是以R[1]为根的堆，在R[1]与R[i]交换后，新的无序区R[1..i-1]中只有R[1]的值发生了变化，故除R[1]可能违反堆性质外，其余任何结点为根的子树均是堆。因此，当被调整区间是R[low..high]时，只须调整以R[low]为根的树即可。

"筛选法"调整堆

R[low]的左、右子树(若存在)均已是堆，这两棵子树的根R[2low]和R[2low+1]分别是各自子树中关键字的结点。若R[low].key不小于这两个孩子结点的关键字，则R[low]未违反堆性质，以R[low]为根的树已是堆，无须调整；否则必须将R[low]和它的两个孩子结点中关键字较大者进行交换，即R[low]与R[large](R[large].key=max(R[2low].key，R[2low+1].key))交换。交换后又可能使结点R[large]违反堆性质，同样由于该结点的两棵子树(若存在)仍然是堆，故可重复上述的调整过程，对以R[large]为根的树进行调整。此过程直至当前被调整的结点已满足堆性质，或者该结点已是叶子为止。上述过程就象过筛子一样，把较小的关键字逐层筛下去，而将较大的关键字逐层选上来。因此，有人将此方法称为"筛选法"。

具体的算法

要将初始文件R[l..n]调整为一个大根堆，就必须将它所对应的完全二叉树中以每一结点为根的子树都调整为堆。

显然只有一个结点的树是堆，而在完全二叉树中，所有序号 的结点都是叶子，因此以这些结点为根的子树均已是堆。这样，我们只需依次将以序号为 ， -1，…，1的结点作为根的子树都调整为堆即可。

具体算70 54 [2] [3]法。

5、大根堆排序实例

6、 算法分析

堆排序的时间，主要由建立初始堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。

堆排序的最坏时间复杂度为O(nlgn)。堆排序的平均性能较接近于最坏性能。

由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。

堆排序是就地排序，辅助空间为O(1)，

它是不稳定的排序方法。

急急！请问，序列 {29.70.54.32.64.78}使用最小堆的堆排序方法排序每一趟的排序结果

void HeapAdjust(int array[],int i,int nLength)

(1) 序列 {29, 70, 54, 32, 64, 78} 有6个数据,先建立"完全二叉树",

[1]=29,[2]=70,[3]=54,[4]=32,[5]=64,[6]=78

29 [1]

/ /

/ / / /

32 64 78 [4] [5] [6]

完全二叉树 对应的顺序号

(2) "完全二叉树"有6个结点,也就是N=6,要建立"初始堆",就要从第N/2号结点到

第1号结点进行调整,也就是按顺序,调整第3号结点,第2号结点,第1号结点,

这3个结点都有分支.

第3号结点,[3]=54,它比左分支78小,所以不用互换,二叉树保持不变,

此时,序列是 29 70 54 32 64 78

29

/

70 54

/ /

32 64 78

(3) 第2号结点,[2]=70,它比左分支32大,比右分支64大,而左分支32较小,互换32和70,

此时,序列是 29 32 54 70 64 78

29

/

32 54

/ /

70 64 78

(4) 第1号结点,[1]=29,它比左分支32小,比右分支54小,所以,不用互换,

此时,序列是 29 32 54 70 64 78

29

/

32 54

/ /

70 64 78

按照"最小堆"的规则,依次完成前3个结点的调整,得到"初始堆":

29 32 54 70 64 78

接下来,就是正式的排序过程,因为使用最小堆的堆排序方法,

所以,排序的结果是从大到小.

(5) 根29与一个结点78互换,78成为根结点,然后,78与32,64依次互换,

这一次的调整,得到最小值29.

78 32 32

/ / /

32 54 78 54 64 54

/ / /

70 64 29 70 64 29 70 78 29

(6) 根结点32与一个结点78互换,78成为根结点,然后,78与54互换,

这一次的调整,得到最小值32.

此时,序列是 54 64 78 70 32 29 78 54

/ /

64 54 64 78

/ /

70 32 29 70 32 29

(7) 根结点54与一个结点70互换,70成为根结点,70与64互换,

这一次的调整,得到最小值54.

此时,序列是 64 70 78 54 32 29

70 64

/ /

64 78 70 78

54 32 29 54 32 29

这一次的调整,得到最小值64.

此时,序列是 70 78 64 54 32 29

78 70

/ /

70 64 78 64

54 32 29 54 32 29

(9) 根结点70与一个结点78互换,得到一个完全有序的序列(从大到小):

图示:

78

70 64

54 32 29 //C语言测试程序

//使用最小堆的堆排序方法

#include

char fileName[]="d:heapSort.txt";

int printIndex;

int writeindex;

void printData(int a,int n) //屏幕打印数据

{int i;

printf("(%d) ",printIndex);

for(i=0;i

{printf("%d ",a[i]);

}printf("

");

printIndex++;

}void writeFile(int a,int n) //排序过程写入文件

{FILE fp;

int i;

fp=fopen(fileName,"a"); //"a"以附加的方式打开只写文件

if(fp == NULL)

{printf("

打开文件 %s 时出错.

",fileName);

return;

}fprintf(fp,"(%d) ",writeindex);

for(i=0;i

{fprintf(fp,"%d ",a[i]);

}fprintf(fp,"

");

fclose(fp); //关闭文件

writeindex++;

}//array是待调整的堆数组，i是待调整的数组元素的位置，nlength是数组的长度

//本函数功能是：根据数组array构建大根堆

{int nChild;

int nTemp;

for(;2i+1

{//子结点的位置=2（父结点位置）+1

nChild=2i+1;

//得到子结点中较小的结点

if(nChild < nLength-1 && array[nChild+1] < array[nChild])

{++nChild;

}//如果较小的子结点小于父结点那么把较小的子结点往上移动，替换它的父结点

if(array[i] > array[nChild])

{nTemp=array[i];

array[i]=array[nChild];

array[nChild]=nTemp;

}}

//堆排序算法

void HeapSort(int array[],int length)

{int i;

//调整序列的前半部分元素，调整完之后个元素是序列的的元素

//length/2-1是一个非叶.

for(i=length/2-1;i>=0;--i)

{HeapAdjust(array,i,length);

printData(array,length);

1.二叉树的基本形态：writeFile(array,length);

}printIndex=1;

writeindex=1;

//从一个元素开始对序列进行调整，不断的缩小调整的范围直到个元素

for(i=length-1;i>0;--i)

{//把个元素和当前的一个元素交换，

//保证当前的一个位置的元素都是在现在的这个序列之中的

array[i]=array[0]^array[i];

array[0]=array[0]^array[i];

array[i]=array[0]^array[i];

//不断缩小调整heap的范围，每一次调整完毕保证个元素是当前序列的值

HeapAdjust(array,0,i);

printData(array,length);

writeFile(array,length);

}}

{int num[]={29,70,54,32,64,78};

int i;

int len;

len=sizeof(num)/sizeof(int);

printIndex=0;

writeindex=0;

printData(num,len);

writeFile(num,len);

HeapSort(num,len);

printf("结果:

");

for(i=0;i

{printf("%d ",num[i]);

}printf("

排序的过程保存在文件 %s

",fileName);

return 0;

}

求解 数据结构 习题：对于存储在顺序表中的关键字序列（12,13,11,18,60,15,7,18,25,90）采用堆排序

for i:=1 to n do read(a[i]);

建堆：

12 13 11 25 90 15 7 18 18 60

12 90 15 25 13 11 7 18 18 60

12 90 15 25 60 1begin1 7 18 18 13

90 12 15 25 60 11 7 18 18 13

90 60 15 25 13 11 7 18 18 12

趟 90从堆移除 12到堆顶

12 60 15 25 13 11 7 18 18

60 12 15 25 13 11 7 18 18

60 25 15 12 13 11 7 18 18

60 25 15 18 13 11 7 18 12

free pacal 堆排序

（2）大根堆排序算法的基本作：

我编译了一下， 问题不少。

我建议您重新写一个， 参照这标准的模板。

希尔排序 是一种 不稳定 的排序方法 ， 时间复杂度为O(n^1.3)，空间复杂度为O(1)。算法：

依次加入元素，建立2叉堆；

再从堆底不断删除元素，直到堆空；

删除的元素就会有序。

堆排序是什么

int main()

堆排序（HeapSort）是一树形选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系（参见二叉树的顺序存储结构），在当前无序区中选择关键字（或最小）的记录

其过程为：

（1）用大根堆排序的基本此时,序列是 32 64 54 70 78 29思想

① 先将初始文件R[1..n]建成一个大根堆，此堆为初始的无序区

②再将关键字的记录R[1]（即堆顶）和无序区的一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字的记录R[1]和该区间的一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

……

直到无序区只有一个元素为止。

① 初始化作：将R[1..n]构造为初始堆；

②每一趟排序的基本作：将当前无序区的堆顶记录R[1]和该区间的一个记录交换，然后将新的无序区调整为堆（亦称重建堆）。

①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止

堆排序就是利用堆的数据结构进行排序，通过调整堆的结构使得关键字有一定的顺序。有堆和最小堆，堆排序在类似topK问题中经常应用，效率比其他内部排序算法高。

对元素序列如何进行堆排序

满二叉树

堆排序是借助（完全二叉树）结构来存储数据的，二叉树又是存储在一维数组中的，是通过二叉树的下标性质来存取数据。

堆：设有数据元素的（R1,R2,R3,...Rn)它们是一棵顺序二叉树的结点且有

首先，将数据存在一个数组中，通过二叉树的性质，找到一个分支结点，比较该结点和其孩子结点的数据大小，将最小的数据交换到该分支结点；如果有交换，并且孩子结点不是叶结点，再以该孩子结点为分支结点，与它的孩子结点比较。

以上处理了一个分支结点，再往左往上依次处理所有分支结点，一直处理到根结点，此时，序列中最小的数就在根结点的位置，初始数据构成了初始堆。

如果要用堆排序来对序列排序，建完初始堆，将根结点数据取出（是堆中元素数据最小的元素），用一个叶结点数据做为根结点，并将其沉底（将数据小的换上来）；如此取法，将所有元素处理完毕，排序完成。

软件设计师考试 | 第三章 数据结构 | 排序

设含 n 个记录的文件内容为 {R1,R2,...,Rn} ，相应的关键字为 {k1,k2,...,kn} 。经过排序确定一种排列 {Rj1,Rj2,...,Rjn} ，使得它们的关键字满足以下递增（或递减）关系： kj1<=kj2<=...<=kjn（或kj1>=kj2>=...>=kjn） 注意：。

排序方法的稳定与不稳定：

for i:=1 to m do内部排序和外部排序：

方法： 在插入第 i 个记录时， R1,R2,...,Ri-1 已经排好序，这时将 Ri 的关键字 ki 依次与关键字 ki-1,ki-2 等进行比较，从而找到应该插入的位置并将 Ri 插入，插入位置及其后的记录依次向后移动。

直接插入排序 是一种 稳定 的排序方法 ， 时间复杂度为O(n^2)，空间复杂度为O(1)。

方法： 首先将个记录的关键字和第二个记录的关键字进行比较，若为逆序，则交换这两个记录的值，然后比较第二个记录和第三个记录的关键字，依此类推，直到第 n-1 个记录和第 n 个记录的关键字比较过为止。上述过程称为趟冒泡排序，然后再进行多次冒泡排序，直到冒泡排序过程中没有进行相邻位置的元素交换处理为止。

冒泡排序 是一种 稳定 的排序方法 ， 时间复杂度为O(n^2)，空间复杂度为O(1)。

方法： 通过 n-i (1<=i<=n) 再次关键字之间的比较，从 n-i+1 个记录中选出关键字最小的记录，并和第 i 个记录进行交换，当 i 等于 n 时所有记录有序排列。

简单选择排序 是一种 不稳定 的排序方法 ， 时间复杂度为O(n^2)，空间复杂度为O(1)。

又称为“缩小增量排序”，它是对直接插入排序方法的改进。

方法： 先将整个待排序记录分割成若干子序列，然后分别进行直接插入排序，待整个序列中的记录基本有序时，再对全体记录进行一次直接插入排序。具体做法是：先取一个小于 n 的整数 d1 作为个增量，把文件的全部记录分成 d1 个组，即将所有距离为 d1 倍数序号的记录放在同一个组中，在各组内进行直接插入排序；然后取第二个增量 d2 (d2

快速排序 是一种 不稳定 的排序方法 ， 时间复杂度为O(nlogn)，空间复杂度为O(logn)。

方法： 对一组待排序记录的关键字，首先按堆的定义排成一个序列（即建立初始堆），从而可以输出堆顶的关键字（对于大根堆而言），然后将剩余的关键字再调整成新堆，便得到次大的关键字，如此反复，直到全部关键字排成有序序列为止。

堆排序 是一种 不稳定 的排序方法 ， 时间复杂度为O(nlogn)，空间复杂度为O(1)。

方法： 将两个或两个以上的有序文件合并成一个新的有序文件。实现方法是：把一个有 n 个记录的无序文件看成是由 n 个长度为 1 的有序子文件组成的文件，然后进行两两归并，得到 n/2 个长度为 2 或 1 的有序文件，再两两归并，如此重复，直到形成包含 n 个记录的有序文件为止。

归并排序 是一种 稳定 的排序方法 ， 时间复杂度为O(nlogn)，空间复杂度为O(n)。

方法： 设立 r 个队列，队列的编号分别为 0、1、2、...、r-1 。首先按有效位的值把 n 个关键字分配到这 r 个队列中；然后按照队列编号从小到大将各队列中的关键字依次收集起来；接着再按次低有效位的值把刚收集起来的关键字分配到 r 个队列中。重复上述分配和收集过程，直到按照有效位分配和收集。这样就得到一个从小到大有序的关键字序列。

对于 n 个记录，执行一次分配和收集的时间为 O(n+r) 。如果关键字有 d 位，则要执行 d 便。所以总的运算时间为 O(d(n+r)) 。

基数排序 是一种 稳定 的排序方法 ， 时间复杂度为O(d(n+rd))，空间复杂度为O(rd)。

各个排序方法的性能比较：

外部排序是对大型文件的排序，待排序的记录存放在外存。

常用的外部排序方法是归并排序。

堆排序初始堆吗

} /方法： 附设两个位置指示变量 i 和 j ，它们的初值分别指向序列的个记录和一个记录。设枢轴记录（通常是个记录）的关键字为 pivot ，则首先从 j 所指位置起向前搜索，找到个关键字小于 pivot 的记录时将记录向前移到 i 指示的位置，然后从 i 所指位置起向后搜索，找到个关键字大于 pivot 的记录时将该记录后移到 j 所指位置，重复该过程直至 i 与 j 相等为止。/endfor

五分钟玩转面试考点-数据结构-堆与最小堆（TOP N问题）

j++;

咳咳：俗话说： 脱离业务的技术，就是耍流氓 。那么我就要提出这篇文章的灵魂一问了，请听题：

a[1]:=a[i];

这个时候，感觉就是M个数中选择N个数 ，就是TOP N问题呀，是不是脑海中不由自主的蹦出了排序算法啦~

哈哈，咱就按照这个思路走。然后， 表面不慌，装思索中ing，其实内心再想：排序算法是啥呀？

冒泡排序 ，核心思想： 相邻比较。 每次将的浮出水面。

快速排序 ，核心思想： 分治法+挖坑填数。 每次选择一基数，排序完成左边比基数小，右边比基数大。一直切分（ 分治 ），直至选出 无序 的的N个整数。

堆排序（出场自带猪脚光环~） ，可以创建一个N大小的 最小堆 。然后balabala。

我就拿（内心PS：读书人的事情，怎么能说偷呢？）一下图吧，放在这里这里让大家容易理解~~

给定一个列表array=[16,7,3,20,17,8]，对其进行堆排序。

首先根据该数组元素构建一个完全二叉树，得到

然后需要构造初始堆，则从一个非叶开始调整，调整过程如下：

步：找到一个组（非叶）， 左8 pk 擂主3 ，左孩子8胜利！然后3和8互相调换位置。 败者3 没有子，结束比赛。

从右到左。组内pk， 左子树20 pk 右子树17 左子树20胜利，获得挑战擂主7的机会。 左子树20 pk 擂主7 左子树20胜利，20和7交换位置。 败者7 没有子，结束比赛。

从下到上， 左子树20 PK 右子树8 ，左子树20胜利。获得挑战擂主16的机会。 左子树20 pk 擂主16 左子树胜利，交换位置。

此时 败者16 含有孩子，将被挑战。

组内挑战开始： 左子树7 和 右子树17 组内pk，右子树17胜利。获取挑战擂主16的机会。 右子树17 和 擂主16 pk，右子树17胜利，交换位置。 败者16 无孩子，结束比赛。

这样就得到了 初始堆 。

哈哈，相信到这里，基本懂得同学还是懂，不懂得还是一脸XX。这是哪？我在干什么？你是谁？

1. 找到一个非叶，从右到左，从下到上 ，遍历所有 非叶 ；

2.若是父 小于 的子 ，那么交换父子的位置，但是要注意，交换之后 对其他的影响。

我们的目标是：

( 没有蛀牙.... ) 根一定是树中的值。同时，父大于子 。

切回到我们的问题。此时，你应该基本知道了堆的概念，为什么不选堆呢？因为咱们选最小堆就是采用 末位淘汰制 。将堆中最小元素剔除。

每次最小堆调整后，总会将整个堆中 最小的元素放在根上 ，然后我们分别取出 [N-1,M] 中的元素，若大于堆顶，则替换。然后（ 随着堆的蠕动，你可以动态想想这个画面~~ ） 再次 将最小元素选出放于堆顶。 直至堆里保存的都是的元素。

还是上面的数组，证据在上面，咱们就开始分析啦：

咱们从i=5，一个元素array[5]开始说起：

父 ：(i-1)/2=2， 他的父就是i=2 ，array[2]也就是3。

子 ： 2i+1=11，等等兄得，你越界了...你根本没有孩子...(名侦探小胖)

于是我就大胆推测一下， 一个非子就是array[2]。

反向推理一下 ：i=2时，左孩子：2i+1=5，右孩子：2i+2=6，但是下标是5，那么 只有一个孩子array[5] 也就是8。

那倒数第二个下标非叶的下标是啥？

博主内心独白：emmm我也不知道....继续套公式，看看有啥规律不。

数组倒数第二个下标数是i=4，(i-1)/2=1，那么 下标array[1]就是第2个父。

数组倒数第三个下标数是i=3，(i-1)/2=1，也是下标array[1]。

那倒数个下标非叶的下标是啥？

数组倒数第四个下标数是i=2，(i-1)/2=1，那么 下标array[0]就是第3个父。

数组倒数第三个下标数是i=1，(i-1)/2=1，也是下标array[0]。

此时还有吗？

数组倒数第五个下标数是i=0，(i-1)/2=-1，也是下标array[-1]。

也就是根没有父了....

等等，我好像发现啥规律了...

父是array[2]=3 array[1]=7 array[0]=16。

array=[16,7,3,20,17,8]

现在要开始 XX联盟S17 的比赛，比赛组根据玩家投票新采用了一种新的比赛规则，规则如下：

横向：每个新晋擂主可以参与更高一级的比赛，直至选出冠军。登顶大根堆顶峰；

纵向：每个擂主要被更低一级的选手挑战，需要证明自己实力，也可能被一撸到底；

简言之：能者上，弱者下

每一小组选出最强者，参与擂主pk， 胜利者获取下一次挑战机会；失败者要被挑战，直至完成一场胜利，或者排名倒数 。

而后，开始了激烈的小组比赛，擂主 先把收拾自己的东西 ，因为他也不知道自己是一败涂地还是保持原位！心里有些忐忑~

215. 数组中的第K个元素

对元素序列如何进行堆排序

lchild,rchild:btree;

堆排序是借助（完全二叉树）结构来存储数据的，二叉树又是存储在一维数组中的，是通过二叉树的下标性质来存取数据。

二叉树也是递归定义的，其结点有左右子树之分，逻辑上二叉树有五种基本形态：

首先，将数据存在一个数组中，通过二叉树的性质，找到一个分支结点，比较该结点和其孩子结点的数据大小，将最小的数据交换到该分支结点；如果有交换，并且孩子结点不是叶结点，再以该孩子结点为分支结点，与它的孩子结点比较

以上处理了一个分支结点，再往左往上依次处理所有分支结点，一直处理到根结点，此时，序列中最小的数就在根结点的位置，初始数据构成了初始堆