排序算法 堆排序_堆排序并且打印每一次排序结果

C# 排序算法 堆排序

使用环境 vs2017 .net core 2.1 控制台程序

实现方式：
一、基本概念
堆：这里是指一种数据结构，而不是我们在C#中提到的用于存储引用类型对象的地方。它可以被当成一棵完全二叉树。
binaryTree
为了将堆用数组来存放，这里对每个节点标上顺序。事实上，我们可以用简单的计算公式得出父节点，左孩子，右孩子的索引：
parent(i) = clip_image002[4]

left(i) = 2i

right(i)=2i + 1
1
2
3

最大堆和最小堆: 最大堆是指所有父节点的值都大于其孩子节点的堆，即满足以下公式：

A[parent[i]]clip_image002[6]A[i](A是指存放该堆的数组)

最小堆相反。

最大堆和最小堆是堆排序的关键，可知最大堆的根节点是堆中最大的节点。因此只要我们构造出最大(小)堆，最大(小)的元素也就得到了，然后再对剩下的元素继续构造最大(小)堆，就可以取出第二大(小)的元素，依此类推，直到排序完成。
1
2
3
4
5

二、构造最大(小)堆
我们已经得知构造最大(小)堆是堆排序的关键，下面就来看看如何构造最大堆。
万事开头难，首先来看一种特殊的情形吧：堆的根节点的左子树和右子树都已经是最大堆了，然而根节点却比孩子节点小，当然，这个堆不满足最大堆的定义。为了⑩这个堆成为最大堆，我们可以按如下步骤操作：
（1）将根节点与左右孩子中最大的交换
（2）交换之后可能会面临左或右子树不是最大堆的问题，但由于整个左(右)子树一开始就是最大堆，问题又回到了最开始的状态，因此只要如此反复即可得到最大堆。
对于上面的特殊堆已经找到了解决办法，但对于一般意义上的堆呢？
我们可以选择自底向上来构造：叶子节点是特殊的最大堆，举个例子有叶子节点a,b,它们的父节点是p;a,b肯定已经是最大堆了，这是要保证a,b,p组成的子树是最大堆。这个堆很眼熟是不是？没错，它就是前面提到的特殊的堆。在a,b,p组成的子树变成最大堆后，我们又可以类似的使该子树，该子树的父节点，以及同胞子树（或节点）组成的新子树成为最大堆，如此类推，最终使堆变为最大堆。

对于求解最小堆与此类似。

static void Main(string[] args)
        {
            Console.WriteLine("堆排序-示例");
            // 记录外部循环次数
            int outListInt = 0;
            // 记录内部循环次数
            int inListInt = 0;
            // 记录排序次数
            int sortListInt = 0;
            // 初始化 list 无序列表 加入一个非常大的数据
            List<int> sortList = new List<int>();
            //
            int[] baseIntList = new int[]
            {
                 99999999,65, 1, 5, 2, 7, 11, 2, 4, 3
            };
            // 
            HeapSort_BuildMaxHeap(baseIntList); // 建立大根堆。 
            Console.WriteLine("Build max heap:");
            foreach (int i in baseIntList)
            {
                Console.Write(i + " "); // 打印大根堆。 
            }

            Console.WriteLine("\r\nMax heap in each iteration:");
            for (int i = baseIntList.Length - 1; i > 0; i--)
            {
                HeapSort_Swap(ref baseIntList[0], ref baseIntList[i]); // 将堆顶元素和无序区的最后一个元素交换。 
                HeapSort_MaxHeaping(baseIntList, 0, i); // 将新的无序区调整为大根堆。 

                // 打印每一次堆排序迭代后的大根堆。 
                for (int j = 0; j < i; j++)
                {
                    Console.Write(baseIntList[j] + " ");
                }
                sortList.Add(baseIntList[0]);
                sortListInt += 1;
                Console.WriteLine(string.Empty);
            }
            Console.WriteLine();
            //
            Console.WriteLine("外部循环次数：" + outListInt);
            Console.WriteLine("内部循环次数：" + inListInt);
            Console.WriteLine("排 序 次 数：" + sortListInt);
            //
            OutputResult("输出结果", sortList);
            Console.ReadKey();
        }

        

        /// <summary> 
        /// 由底向上建堆。由完全二叉树的性质可知，叶子结点是从index=a.Length/2开始，所以从index=(a.Length/2)-1结点开始由底向上进行大根堆的调整。 
        /// </summary> 
        /// <param name="a"> 
        /// 待排序数组。 
        /// </param> 
        private static void HeapSort_BuildMaxHeap(int[] a)
        {
            for (int i = (a.Length / 2) - 1; i >= 0; i--)
            {
                HeapSort_MaxHeaping(a, i, a.Length);
            }
        }

        /// <summary> 
        /// 将指定的结点调整为堆。 
        /// </summary> 
        /// <param name="a"> 
        /// 待排序数组。 
        /// </param> 
        /// <param name="i"> 
        /// 需要调整的结点。 
        /// </param> 
        /// <param name="heapSize"> 
        /// 堆的大小，也指数组中无序区的长度。 
        /// </param> 
        private static void HeapSort_MaxHeaping(int[] a, int i, int heapSize)
        {
            int left = (2 * i) + 1; // 左子结点。 
            int right = 2 * (i + 1); // 右子结点。 
            int large = i; // 临时变量，存放大的结点值。 

            // 比较左子结点。 
            if (left < heapSize && a[left] > a[large])
            {
                large = left;
            }

            // 比较右子结点。 
            if (right < heapSize && a[right] > a[large])
            {
                large = right;
            }

            // 如有子结点大于自身就交换，使大的元素上移；并且把该大的元素调整为堆以保证堆的性质。 
            if (i != large)
            {
                HeapSort_Swap(ref a[i], ref a[large]);
                HeapSort_MaxHeaping(a, large, heapSize);
            }
        }

        /// <summary> 
        /// 交换两个整数的值。 
        /// </summary> 
        /// <param name="a">整数a。</param> 
        /// <param name="b">整数b。</param> 
        private static void HeapSort_Swap(ref int a, ref int b)
        {
            int tmp = a;
            a = b;
            b = tmp;
        }

        /// <summary>
        /// 格式化输出
        /// </summary>
        /// <param name="outputString">输出标题</param>
        /// <param name="baseIntLsit">输出内容</param>
        private static void OutputResult(string outputString, List<int> baseIntLsit)
        {
            Console.Write(outputString + ":");
            foreach (int itemInt in baseIntLsit)
            {
                Console.Write(itemInt + " ");
            }
        }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129