【数据结构】二叉树的顺序结构及实现，堆，向上调整算法，向下调整算法，数组建堆...

杨利霞

【数据结构】二叉树的顺序结构及实现，堆，向上调整算法，向下调整算法，数组建堆算法，堆排序
$ Y+ V1 u! ]7 S5 i( _, n
文章目录
1.二叉树的顺序结构
0 b, T2 z) B" s9 y- q2.堆的概念及结构
$ H$ H0 J% o! Q8 u* M3.堆的实现
3.1堆的总实现
$ Q  e! J# y# {/ g9 D! i3.2堆的向上调整算法---O(logN)
2 G5 C: J  _+ z; }0 }: }3.3堆的向下调整算法---O(logN)
4.数组建堆算法（建大堆）
4.1向上调整建堆
4.2向下调整建堆
! D2 R" F+ ?5 C  G+ x$ s' _5.堆排序
# J. K) q) E2 Z  W- E2 O1.二叉树的顺序结构
普通的二叉树不适合用数组来存储，因为它可能会存在大量的空间浪费，而完全二叉树更适合使用顺序结构存储。现实中我们通常通过堆（堆是一种二叉树的结构），使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。
8 B6 n: d/ y% e1 p3 @

5 W6 s# U* k2 ]2 j7 P* d  n
5 E. _+ b0 U; e3 J- q/ Y2.堆的概念及结构
如果有一个关键码的集合K={k0,k1,k2,…,Kn-1},把它的所有元素按完全二叉树的顺序表存储方式存储在一个一维数组中，并满足以下情况：
" I& c  g1 K2 |2 X( e" c1 u" f
: F: q# X/ |1 W: F1.堆中某个节点的值总是不大于或不小于其父节点的值；
3 P0 z5 N. h% {5 t# |3 E2.堆总是一棵完全二叉树。
2 P1 ]2 q- d* Q  v# _' y# R6 D6 z

3.堆的实现
3.1堆的总实现
& D9 v) Y- b0 l& R( @堆的实现代码（全），请点击——>堆的实现代码
' d# w, F% c' }) }4 o5 ^: J: z4 O
3.2堆的向上调整算法—O(logN)
6 M: y# C0 h+ {/ u  x使用场景：向堆中插入数据，需要使用向上调整算法，因为向堆中插入数据是将数据插入到下标为size的位置，插入一个数据，size++，此时可能就不满足小堆（或大堆），因此要对其进行调整，此处以小堆为例，向上调整算法只需要从插入的结点位置开始和父节点比较（一路和祖先进行比较），若a[child]<a[parent],则交换，若a[child]>=a[parent],则满足小堆，直接break，跳出循环。同时，循环结束的条件是child==0,因为此时小数已经到达堆顶，调整完成。—一遍建堆，一遍调整

# Y  Q* }8 @# }$ g. \7 A代码实现：（以建小堆为例）
# I" ~  a; \- m8 c
7 ]5 v; N3 M  Z& d1 G4 \& k- K, Zvoid Swap(HPDataType* e1, HPDataType* e2)
{
        HPDataType tmp = *e1;
8 q7 d0 M  V* [1 C8 r! R: q        *e1 = *e2;
        *e2 = tmp;
% V. f& t6 p3 [$ I}
void AdjustUp(HPDataType* a,int child)
  J' b$ M$ X9 k1 l{
" a; A, q; h+ x$ x+ C2 c        int parent = (child - 1) / 2;
        while (child > 0)
; p4 R' x. z5 D6 j# Z+ m1 C1 o        {
                if (a[child] < a[parent])
5 ]0 D* I# \( e4 v& }                {
                        Swap(&a[child], &a[parent]);
                        //向上调整
3 f7 Z6 d: n8 @$ B( n/ o                        child = parent;
                        parent = (child - 1) / 2;
                }
( C# P4 r( e1 V$ V- }& T! b                else//满足小堆条件
* f8 W$ c, v5 `# J                {
                        break;
                }
/ q3 V5 _1 @% ~; m7 r8 I& v- F        }
}
7 ], h% p9 o6 j+ s# T- T% k//插入x，继续保持堆形态
void HeapPush(HP* php, HPDataType x)//插入数据到堆中
: x+ s; V' b- y1 w{
" J- b, F7 |; j* v# K        assert(php);
        //扩容
        if (php->size == php->capacity)
) e- E& h' E' Y$ f3 X% q4 f; d        {
                int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
                HPDataType* tmp = (HPDataType*)realloc(php->a, newcapacity * sizeof(HPDataType));
                if (tmp == NULL)
                {
                        perror("realloc fail");
                        exit(-1);
                }
* z3 }7 N6 @- Y; f                php->a = tmp;
                php->capacity = newcapacity;
# S6 v8 R, ^3 ]3 V# V        }
        php->a[php->size] = x;
: w0 ?9 P8 ?; m# L1 l0 _7 y, T        php->size++;

        //向上调整函数
& a3 ^3 F( T6 Y; }        AdjustUp(php->a, php->size - 1);
}

0 E. Z, [& @! x; T1 l3 B1
2
4 \" d  M6 O6 y+ L3 z" y3
# I: p6 r9 Q6 {( C% h" O4
6 J( R; N3 O6 F2 V5
6
5 e3 Y& I4 \. X4 E4 ]: f6 m7
8
9 }3 U" J; `: P! }0 ~& ], A! H9
10
11
7 Z- }  o1 r+ {4 a12
13
$ f# C5 w& R! N) H- G14
15
16
3 m- S, J: N0 F5 Z8 A! S17
18
' t( G) [3 ^& `+ P19
20
21
0 O9 \6 r* ~" F1 ~) w22
6 {6 F- C3 T* Y6 A% n9 c23
24
25
) O4 X5 }0 M  e) |* O26
6 z' _. A! |2 p% z9 i2 q27
6 t0 W; I2 ^3 K28
  `  h1 Z" X/ O4 ^! Y29
- U- ?4 y8 g- O4 |2 l! ?5 {+ }$ {3 n1 |2 C30
31
32
33
34
35
- M1 ]& Y9 i& n5 F! L36
# w. E+ T8 n: c( {# d) M37
38
! g1 ~3 r/ X( g4 A39
+ \5 ]1 y% Y. D$ T* i& t40
1 h8 e3 e9 V/ @) F) b$ l  d41
42
43
44
45
( G8 N! x& X8 g46
47

7 z# M% R; H3 U! X
* [- i- g6 x: W  n, P6 s7 q( R3.3堆的向下调整算法—O(logN)
1.使用场景：删除堆顶元素HeapPop，需要用到堆的向下调整算法。
删除堆顶元素，作用：找次大的数或者次小的数—时间复杂度O(logN)
方法：在删除堆顶元素时用到了向下调整算法，建立了一个小堆，如果我们使用向前挪动数组元素的方法，删除堆顶元素，时间复杂度为O(N);如果先将堆顶元素和最后一个元素交换，然后size–，删除这个元素，再用向下调整算法，时间复杂度就是O(logN)。
2.向下调整算法的前提是：当前的树左右子树必须都是一个堆
3.算法的核心思想：从根结点开始，选出左右孩子中小的那一个，跟父亲交换，因为是建小堆（原来的堆是小堆），所以小的往上交换，大的往下沉，如果要建大堆则相反。
1 V8 _+ \( A+ |3 Q8 m" U& m
下图是在利用向下调整算法建一个小堆：

4 y8 a0 u7 {2 N4 u. J6 d; o
4 m7 u+ ~8 p7 o( [5 s4 g- z2 o1 N代码实现：（建小堆为例）

+ N3 U  q0 P, X+ {% i5 E8 x//向下调整算法---O(logN)
5 b6 D/ J4 |3 Q$ ~3 x4 F4 Wvoid AdjustDown(HPDataType* a,int size,int parent)
{
2 {3 ~) M/ d  U+ t, w. z' T) T- x4 @        //先假设左边的孩子是最小的
        int minchild = parent * 2 + 1;
& |+ C6 q4 A0 R) V4 n- {        while (minchild < size)
        {
                //找出小的那个孩子进行交换
3 C0 P1 B' K- v8 D3 J                if (minchild+1<size && a[minchild + 1] < a[minchild])
! u# B6 t4 Y  T* F& m' E                {
+ e/ Q+ r  I) \1 l: ~: I$ d                        minchild += 1;
                }
                if (a[minchild] < a[parent])
' @9 z) [, i5 o* Z& v                {
                        Swap(&a[parent], &a[minchild]);
                        parent = minchild;
                        minchild = 2 * parent + 1;
                }
                else
                {
                        break;
                }
7 _4 a- l0 [6 k% ?. j5 ]! I* P        }
0 R, h0 U6 s( O( Q& X6 U}
void HeapPop(HP* php)//删除堆中的数据。保持堆形态
{
        assert(php);
9 ^& a% a2 L2 E# q3 T. V$ s! W6 g        assert(!HeapEmpty(php));
4 E5 N! D7 u: w3 K2 K        //方法：交换堆顶和最后一个元素
8 v- i2 [$ c) ~8 P8 y5 G8 R, J$ \" b        //如果用挪动的方式，时间复杂度为O(N),而用向下调整算法，时间复杂度只有O(logN)
$ k# b& R. F0 w. O        Swap(&php->a[0], &php->a[php->size - 1]);
        php->size--;
! _; s) d) b4 F9 S* e# G
8 `- R5 o- h+ G        AdjustDown(php->a, php->size, 0);//从堆顶的位置开始，向下调整
}

* [6 }! a  [- i  A$ j1
& J2 P7 j! E3 A0 i2
3
& B( [$ p& m2 |. z* t9 p8 G4
5 j: ?, t$ a, U5
( {  y& m9 Y: w: @6
. I, L# p+ D' l* ?" R$ L3 p% M7
8
. M% D6 A, z0 x0 A9
+ u: i. _$ H$ C9 u0 K7 G1 G10
11
12
13
' Z; p7 ]( |% _14
15
+ p; X9 S* Q5 }; c16
17
4 i/ b* {! z: ^, F. n  M18
19
20
7 Q8 |: o' `+ ?21
5 X* t8 X( y9 z2 c4 E5 \5 X5 x: R: |22
$ a5 g/ f) Q2 B23
24
25
+ c3 ]& g4 y& b- b26
. z( m" H  |' J. T7 p27
* w: \( {# N+ i" e9 s+ ~( y# F* \% O28
6 ^- B0 \7 F4 \1 |29
4 q  V" j; P% b$ D& a; p30
31
32
& F8 {7 q) M/ y" S, S7 I33
34
6 k3 W( U6 j- \! n8 v, Y0 V( ?* E* Q5 y35
4.数组建堆算法（建大堆）
下面我们给出一个数组，这个数组逻辑上可以看做一棵完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。那么根结点的左右子树不是堆，我们怎么调整呢？这里介绍两种算法，优先使用向下调整算法，时间复杂度更优。

6 \! b0 T- A  k% p9 \3 z0 |* B数组建堆代码的实现，请点击——>数组建堆算法

4.1向上调整建堆
1 N' k' K6 D" U/ w( q' T/ B在原数组的基础上（物理上），第一个元素保持不动，之后的元素类似HeapPush,堆的插入，向上调整建堆。向上调整建堆的时间复杂度分析：O(N*logN)

  y; N  v- o6 G: v6 h
代码实现：

; j- E4 g) k: c3 H#include<stdio.h>
1 X# E1 ?& \1 h4 W. T/ P3 evoid Swap(int* e1, int* e2)
& d; @) d2 t7 H+ T7 _, M* t9 U# f{
        int tmp = *e1;
* X0 W6 U7 b8 {" L& B; }        *e1 = *e2;
        *e2 = tmp;
. W& \4 d7 G' J% F' Y* b}
3 A* V3 g' B4 y; R% vvoid AdjustUp(int* a, int child)
{
4 Q6 s; j: z( p5 m        int parent = (child - 1) / 2;
" H# @3 j. a) w' h6 [        while (child>0)
        {
                if (a[child] > a[parent])//建大堆
                {
                        Swap(&a[child], &a[parent]);
                        child = parent;
+ g* @6 b7 D$ y4 |6 C                        parent = (child - 1) / 2;
                }
1 o2 Y7 _% l" G/ ~, P3 y( k1 m% G                else
                {
                        break;
6 O; ?$ Q5 m' W7 p                }
2 q* G3 m0 K) E# d6 \$ `% l5 \        }
, l2 U! o/ B1 B/ g" V- \}
//向上调整算法建堆
void HeapCreate(int* a, int n)
- r* }# [. v; e7 |: P0 Z{
, f9 |' D8 ~6 E; C; _1 `: X        //向上调整建堆,第一个元素保持不动
' E% K4 ~7 I! z1 v; u        for (int i = 1; i < n; i++)
" a+ R6 K+ l/ @        {
0 J4 D2 I) S. U6 _2 b1 K; @, ^5 S                AdjustUp(a, i);//物理上是个数组，在数组的基础上建堆,从第2个数据开始插入，一边插入一边建堆
        }
}
8 D) x1 v# f" N2 C3 K, X/ Rvoid HeapPrint(int* a, int n)
{
        for (int i = 0; i < n; i++)
        {
                printf("%d ", a);
  L' G1 u: h/ n: \: x+ x        }
8 s( x; J4 Q. v$ y7 F% V3 q}
int main()
{
- ]9 G; ^4 Z' X        int a[] = { 65,100,60,32,50,70 };
        //int a[] = { 15,1,19,25,8,34,65,4,27,7 };
) t9 r$ g* u- c3 m0 z7 o, q3 S" l3 n5 k4 ^
2 l- r# ^2 A6 p6 S9 P5 k        HeapCreate(a, sizeof(a) / sizeof(a[0]));
        HeapPrint(a, sizeof(a) / sizeof(a[0]));
2 B4 j% B- U1 O# b1 N2 D# z}

1
2
3
* I* I+ E' A9 L# i5 |6 e" I8 B4
) e' O8 l1 d2 g9 |/ _. ?& b  i4 w* B5
2 u: w: r+ o  m  e0 Q; B+ _1 w1 q6
7
- ^& b" @3 O+ Z& N) |8
9
10
; k# L" @) S  \9 O! _% c! ~11
12
6 P" V5 L( J, g" t* r$ j0 e13
14
15
16
17
18
19
( m7 D: J' g4 Q) w) d20
21
22
0 ~+ S9 V/ x/ {, @23
1 Q: d2 @( B/ t( i24
( Y( B2 _3 i+ a( X; @: P; l4 S25
$ K( I, ?$ ]$ a9 H26
: w' _- }, L  v$ e4 ]3 Z27
; \+ q/ g, P" r; q5 E& }28
29
  m  N. j& n" O8 K  u. D30
31
32
. ~! }9 B/ D" b$ D6 c% |8 e8 k# H33
34
35
36
/ |& k4 Z" t2 R, q4 c! u8 v/ h  X37
38
39
40
41
! L  ]7 u# L+ I42
43
/ Y- L# l+ d; K4 H3 J44
45
46
47
48
4.2向下调整建堆
向下调整建堆，从倒数第一个非叶子结点（最后一个结点的父亲）开始向下调整，调整完后，下标–，到另一个子树调整，直到调整到根。时间复杂度分析：O(N),优于向上调整建堆，分析见下图：
6 k, Y6 v$ Y# o$ F* i
4 V9 R. Q7 E- T# K
+ y4 a. h" J# M! U3 U
代码实现：
6 \  o+ K) Z! Y' ^, v: {
void AdjustDown(int* a, int size, int parent)
( D- Y4 G3 u) X* Q0 M{
        //先假设左边的孩子是最小的
        int minchild = parent * 2 + 1;
; s1 X6 C6 T, b) T        while (minchild < size)
        {
; B4 [+ z" `# N- k                //找出小的那个孩子
                if (minchild + 1 < size && a[minchild + 1] > a[minchild])
* f+ c/ v# s) q                {
                        minchild ++;
' a1 T; ^9 f, K& d! y                }
& s: o3 ]& m1 Q2 q( l$ q/ J                if (a[minchild] > a[parent])
                {
                        Swap(&a[minchild], &a[parent]);
                        parent = minchild;
                        minchild = 2 * parent + 1;
2 D$ C4 k% X# e, z. d4 _                }
! V, a/ \! ^+ N) E8 o                else
                {
$ n/ d- z3 H) n; L6 H                        break;
                }
        }
, u) x, m5 C1 n8 D. s}
2 H6 B8 @- e$ f1 \) G& Tvoid HeapCreate(int* a, int n)
{
3 B0 O( E2 u/ ^9 \. J0 V        //向上调整建堆,第一个元素保持不动
$ {- [1 w8 Y$ ^. C9 ]0 q8 W        //for (int i = 1; i < n; i++)
) ~. g6 H, B" }  Y, T        //{
: d: }0 k5 s2 @- ^7 B9 a        //        AdjustUp(a, i);//物理上是个数组，在数组的基础上建堆,从第2个数据开始插入，一边插入一边建堆
        //}
        //向下调整建堆
        //n-1是最后一个数据的下标，再-1/2算的就是最后一个结点的父节点
' n- ^( }. r) l' W        for (int i=(n - 1 - 1)/2;i>=0; i--)
% `0 ?5 R% @/ @- ^  u0 F4 s+ k! r9 u        {
0 V4 |' `6 x5 g1 s                AdjustDown(a, n, i);
& X! L- D; c8 y# b8 k' E        }
9 n7 e' v- T: y}
/ s9 k8 f' g- o$ R3 }
7 H! P$ m' B) {  g; Q0 F8 ]1
, ~' U) h' ?+ p1 q: s8 }2
9 `9 x- \, c+ Z' ]/ w3
4
5
6
7
5 H+ n; J+ ?# B1 d3 Q( s. G8
. r- v. F9 t8 ?9 z6 x- I5 L9
% |; M: K6 I+ M5 c& C# j10
11
$ t! i9 g0 N5 `7 j$ P12
5 j9 a% U& Y$ x$ D" W& s13
. |- n+ L! I& V5 i) f9 @14
15
16
17
: ]* T/ {$ e! n! z5 N18
19
' I2 M0 {8 K* R$ r7 ]20
7 W: _: E4 ?% l+ P/ t; z21
22
" K8 f+ z2 C( Y* r3 e$ @23
24
7 h% s7 C% t- Z# z5 j: I25
26
27
! v+ e3 z# ?. E+ p" v: T" n28
7 B* n: D) i$ U! U' Y# `  K% c29
30
+ j# k, B' R/ }6 Y2 S- U31
$ {: }' w4 L1 E' a8 |+ \# O- E6 N; ?32
33
34
35
36
( K  y1 _: G2 v' q& Z1 Y* A37
5.堆排序
堆排序实现代码，请点击——>堆排序代码

& G5 }! [* k$ I3 F1.堆排序的大思路，也是一种选择排序。大多数学生认为如果是排升序，建的是小堆，排降序建的是大堆，其实结果是相反的。
+ G! o/ n& a( e+ C- F升序—建大堆
/ P8 }# f) R" M8 V: s6 I降序—建小堆
* }+ u7 _# R: ^4 e6 D6 ]4 ?2.推论：假设我们排升序，建的是小堆，思路是，先用向下调整算法建一个小堆，时间复杂度为O(N),堆顶就是第一次找出的最小数，然后再将剩下的数据看成堆，重新建堆，选次小的数据。这种算法可以是可以，但是太多此一举了，并且整体下来的时间复杂度为O(N^2)。
假设升序—建大堆，思路是，先把一开始建好的大堆，第一个数据和最后位置交换，这样就排好了最大的那个数据，然后不把最后一个数据看作堆里面的，继续向下调整建堆，选出次大的，与倒数第二个数据交换，后续一次处理。这样整体下来的时间复杂度就是O(N*logN)

void HeapSort(int* a, int n)
- f. H1 X+ L- ^& v6 ?0 Y{
9 y7 Q# x: v+ n4 [% W. [/ z        //堆排序的大思路，也是一种选择排序
        //升序---大堆
0 s: s6 d/ Q$ G- X4 D        //降序---小堆
8 G) _9 n# i9 Q  l9 @; q        //先建堆：向下调整建堆---O(N)
        for (int i = (n - 1 - 1) / 2; i >= 0; i--)
        {
                AdjustDown(a, n, i);
7 H9 b, s8 \3 k        }

        //此时堆顶是最大元素，交换堆顶元素与最后一个元素
        //再将剩下的n-1个元素重新向下调整，找到次大的
        int i = 1;
) n. o: S4 v$ L6 y  d! y2 P        while (i < n)
' W( \0 d8 [& a3 m        {
                Swap(&a[0], &a[n - i]);
. N8 X: R; J: l: V, e" ?0 b/ x* \                AdjustDown(a, n-i, 0);
                i++;
  G- f) Q% v/ U/ C1 Y( n        }
}

————————————————
版权声明：本文为CSDN博主「SouLinya」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_63449996/article/details/126775501