点击刷新
堆排序相对冒泡这些要复杂一些，它需要先初始化堆。.net里List的排序就混合使用了堆排序和另2种排序。
出于学习目的，代码示范里不使用数组结构，数组取索引比较深涩。而使用嵌套类来实现。
1.初始化堆
排序肯定是有升序和降序两种，堆排序也一样，分为大顶堆和小顶堆。初始化堆的目的就是变为大顶堆或者小顶堆
传统的方法是取数组下标[n/2]向下取整，但直接取最后一个元素往前遍历也是可行的
下面用22,44,6,88,5几个数作为示范
step1.默认的树结构
step2.自顶向下，以22开始先比较44和6两个子树，比较方式可以先比较左子树和右子树，取最大的值再和父节点比较。
44和6先进行比较，44比较大。然后44再和22进行比较，发现比父节点大。然后执行交换
step3.然后比较22的两个子树，88比较大，执行交换
step4.由于内部执行了交换，再次进行遍历。发现88比44大，执行交换。
至此，初始化堆完成
2.执行排序
堆排序有一个有序区和无序区的概念，有序区同样在堆中，但是不参与排序。只有无序区参与排序，排序结果转移到有序区。
直到无序区没有之后，排序结束
step1.是初始化好的堆，没有进行任何操作
step2.需要不断的把第一个元素和最后一个元素进行交换，放入有序区，橙色的是有序区
step3.交换完成之后，再重复进行初始化堆，进行调整
step4.由于88是有序区的内容，所以只和左子树22比较后，进行交换。
step5.再次和第一个元素进行交换，加入到有序区。
堆排序完成
下面附上代码：
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace Hont { public class HeapSort { public class Node { /// <summary> /// 用了一下空对象模式，省去了判断null /// </summary> public readonly static Node EMPTY_NODE; public Node LeftChild { get; set; } public Node RightChild { get; set; } public Node Parent { get; set; } public int Value { get; set; } public bool IsUsed { get; set; } static Node() { EMPTY_NODE = new Node() { Value = 0, IsUsed = true }; } public Node() { LeftChild = EMPTY_NODE; RightChild = EMPTY_NODE; } public Node(Node parent) : this() { this.Parent = parent; } } /// <summary> /// 执行排序 /// </summary> /// <param name="sourceArray">原始数组</param> /// <param name="maxOrMin">降序还是升序</param> /// <returns>排序后的数组</returns> public int[] Sort(int[] sourceArray, bool maxOrMin = true) { Func<int, int, bool> compare = null; if (maxOrMin) compare = (a, b) => a > b; else compare = (a, b) => a < b; var rootNode = BuildHeap(sourceArray.ToList()); AdjustHeap(rootNode, compare); SortHeap(rootNode, compare); return OutputHeap(rootNode).ToArray(); } /// <summary> /// 构建堆，因为没有用数组去实现，需要额外构建 /// </summary> Node BuildHeap(List<int> sourceList) { Node result = new Node(); List<Node> nextDepthNodeList = new List<Node>(); List<Node> tmpNextDepthNodeList = new List<Node>(); BuildHeap(result, sourceList, nextDepthNodeList); for (int i = 0; i < nextDepthNodeList.Count; i++) { var item = nextDepthNodeList[i]; if (!BuildHeap(item, sourceList, tmpNextDepthNodeList)) { break; } if (i - 1 == nextDepthNodeList.Count) { nextDepthNodeList = tmpNextDepthNodeList; tmpNextDepthNodeList.Clear(); i = 0; } } var lastNode = GetLastSortNode(result); result.Value = lastNode.Value; if(lastNode.Parent.LeftChild == lastNode) { lastNode.Parent.LeftChild = Node.EMPTY_NODE; } else { lastNode.Parent.RightChild = Node.EMPTY_NODE; } return result; } bool BuildHeap(Node currentNode, List<int> sourceList, List<Node> nextDepthNodeList) { if (sourceList.Count < 1) return false; var firstNode = sourceList[0]; currentNode.LeftChild = new Node(currentNode) { Value = firstNode }; nextDepthNodeList.Add(currentNode.LeftChild); sourceList.RemoveAt(0); if (sourceList.Count > 0) { var lastNode = sourceList[sourceList.Count - 1]; currentNode.RightChild = new Node(currentNode) { Value = lastNode }; nextDepthNodeList.Add(currentNode.RightChild); sourceList.RemoveAt(sourceList.Count - 1); } return true; } /// <summary> /// 调整堆，调整至大顶堆或小顶堆，依据第二个参数 /// </summary> void AdjustHeap(Node heap, Func<int, int, bool> compare) { if (heap == Node.EMPTY_NODE) return; if (heap.LeftChild.IsUsed && heap.RightChild.IsUsed) return; var leftChild = heap.LeftChild; var rightChild = heap.RightChild; var leftChildValue = heap.LeftChild.Value; var rightChildValue = heap.RightChild.Value; if (leftChild.IsUsed) leftChildValue = compare(int.MinValue, int.MaxValue) ? int.MaxValue : int.MinValue; if (rightChild.IsUsed) rightChildValue = compare(int.MinValue, int.MaxValue) ? int.MaxValue : int.MinValue; var selectChild = compare(leftChildValue, rightChildValue) ? leftChild : rightChild; var flag = compare(selectChild.Value, heap.Value); if (flag) { var tmp = heap.Value; heap.Value = selectChild.Value; selectChild.Value = tmp; } AdjustHeap(heap.LeftChild, compare); AdjustHeap(heap.RightChild, compare); if (flag) { AdjustHeap(heap, compare); } } void SortHeap(Node root, Func<int, int, bool> compare) { while (!root.IsUsed) { var lastNode = GetLastSortNode(root); var tmpHeapValue = root.Value; root.Value = lastNode.Value; lastNode.Value = tmpHeapValue; lastNode.IsUsed = true; AdjustHeap(root, compare); } } /// <summary> /// 获得最后可用的堆成员，如果是IsUsed说明是有序区就跳过，主要用于排序时，首尾成员交换 /// </summary> Node GetLastSortNode(Node root) { Node result = root; while (true) { if (result.RightChild != Node.EMPTY_NODE && !result.RightChild.IsUsed) { result = result.RightChild; } else if (result.LeftChild != Node.EMPTY_NODE && !result.LeftChild.IsUsed) { result = result.LeftChild; } else { break; } } return result; } /// <summary> /// 遍历节点 /// </summary> void ForeachNode(Node root, Action<Node> foreachContent) { if (root != Node.EMPTY_NODE) { foreachContent(root); } if (root.LeftChild != Node.EMPTY_NODE) { ForeachNode(root.LeftChild, foreachContent); } if (root.RightChild != Node.EMPTY_NODE) { ForeachNode(root.RightChild, foreachContent); } } List<int> OutputHeap(Node root) { List<int> result = new List<int>(); ForeachNode(root, m => m.IsUsed = false); while (!root.IsUsed) { var tmpNode = GetLastSortNode(root); result.Add(tmpNode.Value); tmpNode.IsUsed = true; } return result; } } }
调用：
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using Hont; namespace HeapSortPackage { class Program { static void Main(string[] args) { HeapSort heapSort = new HeapSort(); var result = heapSort.Sort(new int[] { 22, 44, 88, 5, 6 }, true); Console.WriteLine(string.Join(",", result)); Console.Read(); } } }
© 著作权归作者所有
举报
发表评论
0/200
