堆排序

以下是个人写的堆排序代码，原理我就不解释了（简单来说就是先建立一个大顶堆，然后进行顶点和最后节点的互换，互换之后需要重新建堆，两两比对，具体的话可以参照其他的，不过代码还是会于注释的。 #根据问题进行编码，由于数组下标是从0开始的，而树的节点从1开始，我们还需要引入一个辅助位置，Python提供的原始数据类型list实际上是一个线性(Array), #由于我们需要在序列最左边追加一个辅助位，线性表这样做的话开销很大，需要把数组整体向右移动，所以list类型没有提供形如appendleft的函数，但是在一个 #链表里做这种操作就很简单了，Python的collections库里提供了链表结构deque，我们先使用它初始化一个无序序列： from collections import deque #引用链表 def heap_adjust(data,start,length): #建一个大顶堆，上面最大，且父节点比左右两个子节点都要大 temp=data[start] #定义一个中间变量temp，代表父节点的值 left=start*2 #父节点下左节点的索引值 right=left+1 #父节点下右节点的索引值 while left<=length #主要在两两比对的时候需要用到while if left<length and data[left]<data[right]:

堆满足的条件：1，是一颗完全二叉树。2，大根堆：父节点大于各个孩子节点。每个节点都满足这个道理。小根堆同理。 parent = （i-1）/2 #i为当前节点 left = 2*i+1 right = 2*i + 2 堆可以分为大根堆和小根堆，这里用大根堆的情况来定义操作： (1)大根堆调整(max_heapify)： 将堆的末端子节点作调整，使得子节点永远小于父节点。这是核心步骤，在建堆和堆排序都会用到。 比较i的根节点和与其所对应i的孩子节点的值，当i根节点的值比左孩子节点的值要小的时候，就把i根节点和左孩子节点所对应的值交换，同理，就把i根节点和右孩子节点所对应的值交换。 然后再调用堆调整这个过程，可见这是一个递归的过程。 def max_heapify(heap,heapSize,root): # 调整列表中的元素并保证以root为根的堆是一个大根堆 ''' 给定某个节点的下标root，这个节点的父节点、左子节点、右子节点的下标都可以被计算出来。 父节点：(root-1)//2 左子节点：2*root + 1 右子节点：2*root + 2 即：左子节点 + 1 ''' left = 2*root + 1 right = left + 1 larger = root if left < heapSize and heap[larger] < heap[left]:

void swap(int* a,int i,int j){ int temp = a[i]; a[i] = a[j]; a[j] = temp; } void head(int* a,int current,int n){ if(current>=n) return; int left = 2*current; int right = left+1; int max_index; if(left>=n) return; if(right>=n) max_index=left; else max_index = (a[left]>a[right])?left:right; if(a[current]<a[max_index]) { swap(a[current],a[max_index]); heap(a,max_index,n); } } void sortheap(int *a,int n){ for(int i=N/2;i>=0;i--) heap(a,i,n); for(int i=n-1;i>=0;i--){ heap(a,0,i); swap(a,0,i); } } 来源： https://www.cnblogs.com/liangyc/p/11671146.html

/*堆排序*/ //根节点元素自顶向下移动到合适的位置以构成最大堆 void downToMaxHeap(vector<int> &arr, int bgn, int end) { int child; int parent = bgn; /*假根节点向下移动至合适的位置 --整个堆排序的核心代码块*/ while ((child = parent * 2 + 1) < end) { if ((child < end - 1) && (arr[child] < arr[child + 1])) ++child; //右孩子节点 if (arr[child] > arr[parent]) mySwap(&arr[child], &arr[parent]); else break; parent = child; } } //将数组构造为最大堆 void buildMaxHeap(vector<int> &arr, int bgn, int end) { if (bgn >= end - 1) return; int parent = end / 2 - 1; while (parent >= 0) { downToMaxHeap(arr, parent, end); --parent; } } //堆排序 void heapSort(vector<int> &arr, int bgn

1 public class HeapSort { 2 public static void main(String[] args) { 3 int[] a = new int[]{6, 2, 8, 3, 5, 1, 8, 6, 54, 64, -1, 2, 4, 4, 67}; 4 heapSort(a); 5 System.out.println(); 6 } 7 8 static void heapSort(int[] a) { 9 int bounds = a.length; 10 for (int i = bounds - 1; i >= 0; i--) maxHeap(i, bounds, a); 11 while (bounds > 0) { 12 int t = a[0]; 13 a[0] = a[bounds - 1]; 14 a[bounds - 1] = t; 15 bounds--; 16 for (int i = bounds - 1; i >= 0; i--) maxHeap(i, bounds, a); 17 } 18 } 19 20 static void maxHeap(int r, int bounds, int[] a) { 21 int left = (r + 1) * 2 - 1, right = left + 1; 22 if (left

最近要准备面试，补习数据结构和算法（都是泪），在这里做一个学习笔记。 今天学习最大堆和堆排序。 最大（小）堆： 实质：逻辑结构：完全二叉树；存储结构：数组。（参考这篇文章，详细讲述了二叉树的存储结构 http://www.cnblogs.com/pengyingh/articles/2396466.html ）； 特点：最大堆的父亲要大于等于孩子。（最小堆相反）； 堆排序：一种选择排序，每次在序列中取出最大值或最小值，相比直接选择排序，堆排序体现出了数据结构的好处。 原理：利用构建的最大堆的性质，每次最大堆的堆顶元素，将堆顶元素放到堆尾，即将数组的第一个元素和最后一个元素交换；再对剩下的N-1个元素循环操作，边排序完毕； 时间复杂度：O（nlogn）;(构建堆需要logn，堆排序需要n次构建)； 空间复杂度：O(1);只需要一个常量单元用于交换。 堆排序不适合排序小数据量；频繁建堆。 代码实现 #include <iostream> using namespace std; int parent( int i) //数组存储结构，完全二叉树 { return i/ 2 ; } int left( int i) { return i* 2 ; } int right( int i) { return i* 2 + 1 ; } void maxheap( int *a, int i,

写这篇的目的是因为对于堆排序过时间一长就忘记 所以记录下自己学习《算法导论》时的笔记 有错误的地方希望可以指出 首先介绍堆排序 （二叉）堆是一个数组 它可以看成是一个近似的完全二叉树 我们很容易计算得到他的父节点 左孩子 右孩子节点 数组下标从1开始 下标为1的为树的根 1. parent(i) return [i/2]; 2. left(i) return 2*i; 3 right(i); return 2*i +1; 二叉树有最小堆和最大堆这里我们只讨论最大堆 最大堆的性质 是 除了根节点以外的所有节点都满足 A[parent(i)] >= A[i]; 既某个节点的值最多与父节点一样大 堆排序算法其中两个步骤 1.调整堆 我们假设i节点的左右子树都是一个最大堆（先不要管为什么这样假设 读完后面就知道） 此时A[i] 可能小于 左孩子和右孩子 此时可能破坏最大堆的性质 l 为左孩子 r为右孩子 调整堆其实就是对A[i] 逐渐降级的过程 void MaxHeapify(int array[], int i, int length) { int l = i << 1; // 左孩子节点 int r = (i << 1) + 1; // 右孩子节点 int largest = 0; // 用来记录交换的是左孩子还是右孩子 if (l <= length && array[l] >

交换排序 冒泡排序 // 冒泡排序 ======================================= void bubbleSort(int num[], int n) {//【冒泡排序】 for(int i=0; i < n-1; i++) {// 需要 n-1 次排序 for(int j=0; j < n-1-i; j++) { if(num[j] > num[j+1]) { int temp = num[j]; num[j] = num[j+1]; num[j+1] = temp; } } } } 快速排序 // 快速排序 ======================================= //void quickSort(int num[], int left, int right) {//【快速排序】 // if(left < right) { // int temp = num[left]; // int low = left; // int high = right; // while(low < high) { // while(low < high && num[high] >= temp) { // high--; // } // num[low] = num[high]; // while(low < high && num[low]

下载链接： https://www.yinxiangit.com/710.html python算法和数据结构的深入学习 第一章：当我们在讨论算法的时候，我们在讨论什么？ 1-1 我们究竟为什么要学习算法 1-2 课程介绍 第二章：排序基础 2-1 选择排序法 2-2 使用模板（泛型）编写算法 2-3 随机生成算法测试用例 2-4 测试算法的性能 2-5 插入排序法 2-6 插入排序法的改进 2-7 更多关于O（n*2）排序算法的思考 第三章：高级排序问题 3-1 归并排序法 3-2 归并排序法的实现 3-3 归并排序法的优化 3-4 自底向上的归并排序算法 3-5 快速排序法 3-6 随机化快速排序法 3-7 双路快速排序法 3-8 三路快速排序法 3-9 归并排序和快速排序的衍生问题 第四章：堆和堆排序 4-1 为什么使用堆 4-2 堆的基本存储 4-3 Shift Up 4-4 Shift Down 4-5 基础堆排序和Heapify 4-6 优化的堆排序 4-7 排序算法总结 4-8 索引堆 4-9 索引堆的优化 4-10 和堆相关的其他问题 第五章：二分搜索树 5-1 二分查找法 5-2 二分搜索树基础 5-3 二分搜索树的节点插入 5-4 二分搜索书的查找 5-5 二分搜索树的遍历（深度优先遍历） 5-6 层序遍历（广度优先遍历） 5-7 删除最大值，最小值 5-8

#include<iostream> #include<stdio.h> void my_print(int *arr,int length) { for(int i = 0; i < length; i++) { /* code */ printf("%d ",arr[i]); } printf("\n"); } void heap_adjust(int *arr,int index,int length) { if (arr == NULL) return ; int left_child = 2 * index + 1 ; int right_child = 2 * index + 2; int current_idx = index; if(left_child < length && arr[left_child] > arr[current_idx]) { current_idx = left_child; } if (right_child < length && arr[right_child] > arr[current_idx]) { current_idx = right_child; } if (index != current_idx) { int temp = arr[current_idx]; arr[current_idx] = arr[index]