堆排序（递归写法、非递归写法、从下标0开始计数、从下标1开始计数）

最新推荐文章于 2023-05-04 22:33:53 发布
最新推荐文章于 2023-05-04 22:33:53 发布
阅读量546 收藏 2
点赞数
分类专栏： 数据结构 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43450413/article/details/106600555
版权

下标从1开始计数，非递归写法(1)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
    int dad = start;
    int son = dad * 2;
    while (son <= end) { 
        if (son+1 <= end && arr[son] < arr[son + 1]) {	
        	son++;
		}

        if (arr[dad] > arr[son]) {	
        	return;
		} else {
            std::swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2;
        }
    }
}

void heap_sort(int arr[], int len) {
    for (int i = len / 2; i >= 1; i--) {
    	sift(arr, i, len);
	}
        
    for (int i = len; i >= 2; i--) {
        std::swap(arr[1], arr[i]);
        sift(arr, 1, i - 1);
    }
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n+1];
	
	for (int i = 1; i <= n; i++) {
		scanf("%d", &arr[i]);
	}
	
	int len = n;
    heap_sort(arr, len);
    for (int i = 1; i <= len; i++) {
    	printf("%d%c", arr[i], " \n"[i==len]);
	}

    delete[] arr;
    
    return 0;
}

下标从1开始计数，非递归写法(2)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
	while (start <= end) {
	    int dad = start;
    	int son = dad * 2;
    	
		if (son <= end && arr[son] > arr[dad]) {
			dad = son;
		}
		
		if (son+1 <= end && arr[son+1] > arr[dad]) {
			dad = son + 1;
		}
		
		if (dad != start) {
			std::swap(arr[dad], arr[start]);
			start = dad;
		} else {
			break;
		}
	}
}

void heap_sort(int arr[], int len) {
    for (int i = len / 2; i >= 1; i--) {
    	sift(arr, i, len);
	}
    
    for (int i = len; i >= 2; i--) {
        std::swap(arr[1], arr[i]);
        sift(arr, 1, i - 1);
    }
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n+1];
	
	for (int i = 1; i <= n; i++) {
		scanf("%d", &arr[i]);
	}
	
	int len = n;
    heap_sort(arr, len);
    for (int i = 1; i <= len; i++) {
    	printf("%d%c", arr[i], " \n"[i==len]);
	}

    delete[] arr;
    
    return 0;
}

下标从1开始计数，递归写法(1)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
	int dad = start;
	int son = dad * 2;
		
	if (son <= end) {
		if (son+1 <= end && arr[son] < arr[son + 1]) {
			son++;
		}

		if (arr[dad] < arr[son]) {
			std::swap(arr[dad], arr[son]);
			sift(arr, son, end);
		}
	}
}

void heap_sort(int arr[], int len) {
    for (int i = len / 2; i >= 1; i--) {
    	sift(arr, i, len);
	}
        
    for (int i = len; i >= 2; i--) {
        std::swap(arr[1], arr[i]);
        sift(arr, 1, i - 1);
    }
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n+1];
	
	for (int i = 1; i <= n; i++) {
		scanf("%d", &arr[i]);
	}
	
	int len = n;
    heap_sort(arr, len);
    for (int i = 1; i <= len; i++) {
    	printf("%d%c", arr[i], " \n"[i==len]);
	}

    delete[] arr;
    
    return 0;
}

下标从1开始计数，递归写法(2)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
	if (start <= end) {
	    int dad = start;
    	int son = dad * 2;
    	
		if (son <= end && arr[son] > arr[dad]) {
			dad = son;
		}
		
		if (son+1 <= end && arr[son+1] > arr[dad]) {
			dad = son + 1;
		}
		
		if (dad != start) {
			std::swap(arr[dad], arr[start]);
			sift(arr, dad, end);
		}
	}
}

void heap_sort(int arr[], int len) {
    for (int i = len / 2; i >= 1; i--) {
    	sift(arr, i, len);
	}
    
    for (int i = len; i >= 2; i--) {
        std::swap(arr[1], arr[i]);
        sift(arr, 1, i - 1);
    }
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n+1];
	
	for (int i = 1; i <= n; i++) {
		scanf("%d", &arr[i]);
	}
	
	int len = n;
    heap_sort(arr, len);
    for (int i = 1; i <= len; i++) {
    	printf("%d%c", arr[i], " \n"[i==len]);
	}

    delete[] arr;
    
    return 0;
}

下标从0开始计数，非递归写法(1)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
    int dad = start;
    int son = dad * 2 + 1;
    while (son <= end) { 
        if (son + 1 <= end && arr[son] < arr[son + 1]) {
        	son++;
		}

        if (arr[dad] > arr[son]) {	 
        	return;
		} else {
            std::swap(arr[dad], arr[son]);
            dad = son;
            son = dad * 2 + 1;
        }
    }
}

void heap_sort(int arr[], int len) {
    for (int i = len / 2 - 1; i >= 0; i--) {
    	sift(arr, i, len - 1);
	}
        
    for (int i = len - 1; i > 0; i--) {
        std::swap(arr[0], arr[i]);
        sift(arr, 0, i - 1);
    }
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}
	
	int len = n;
    heap_sort(arr, len);
    for (int i = 0; i < len; i++) {
    	printf("%d%c", arr[i], " \n"[i==len-1]);
	}

    delete[] arr;
    
    return 0;
}

下标从0开始计数，非递归写法(2)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
	while (start <= end) {
	    int dad = start;
    	int son = dad * 2 + 1;
    	
		if (son <= end && arr[son] > arr[dad]) {
			dad = son;
		}
		
		if (son+1 <= end && arr[son+1] > arr[dad]) {
			dad = son + 1;
		}
		
		if (dad != start) {
			std::swap(arr[dad], arr[start]);
			start = dad;
		} else {
			break;
		}
	}
}

void heap_sort(int arr[], int len) {
    for (int i = len / 2 - 1; i >= 0; i--) {
    	sift(arr, i, len - 1);
	}
    
    for (int i = len - 1; i > 0; i--) {
        std::swap(arr[0], arr[i]);
        sift(arr, 0, i - 1);
    }
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n];
	
	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}
	
	int len = n;
    heap_sort(arr, len);
    for (int i = 0; i < len; i++) {
    	printf("%d%c", arr[i], " \n"[i==len-1]);
	}

    delete[] arr;
    
    return 0;
}

下标从0开始计数，递归写法(1)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
	int dad = start;
	int son = dad * 2 + 1;
		
	if (son <= end) {
		if (son+1 <= end && arr[son] < arr[son + 1]) {
			son++;
		}

		if (arr[dad] < arr[son]) {
			std::swap(arr[dad], arr[son]);
			sift(arr, son, end);
		}
	}
}

void heap_sort(int arr[], int len) {
	for (int i = len / 2 - 1; i >= 0; i--) {
		sift(arr, i, len - 1);
	}

	for (int i = len - 1; i > 0; i--) {
		std::swap(arr[0], arr[i]);
		sift(arr, 0, i - 1);
	}
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n];

	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}

	int len = n;
	heap_sort(arr, len);
	for (int i = 0; i < len; i++) {
		printf("%d%c", arr[i], " \n"[i==len-1]);
	}

	delete[] arr;

	return 0;
}

下标从0开始计数，递归写法(2)

# include <iostream>
# include <algorithm>

void sift(int arr[], int start, int end) {
	if (start <= end) {
		int dad = start;
		int son = dad * 2 + 1;

		if (son <= end && arr[son] > arr[dad]) {
			dad = son;
		}

		if (son+1 <= end && arr[son+1] > arr[dad]) {
			dad = son + 1;
		}

		if (dad != start) {
			std::swap(arr[dad], arr[start]);
			sift(arr, dad, end);
		}
	}
}

void heap_sort(int arr[], int len) {
	for (int i = len / 2 - 1; i >= 0; i--) {
		sift(arr, i, len - 1);
	}

	for (int i = len - 1; i > 0; i--) {
		std::swap(arr[0], arr[i]);
		sift(arr, 0, i - 1);
	}
}

int main() {
	int n;
	std::cin >> n;

	int* arr = new int[n];

	for (int i = 0; i < n; i++) {
		scanf("%d", &arr[i]);
	}

	int len = n;
	heap_sort(arr, len);
	for (int i = 0; i < len; i++) {
		printf("%d%c", arr[i], " \n"[i==len-1]);
	}

	delete[] arr;

	return 0;
}

测试OJ：（需登录）
https://pintia.cn/problem-sets/15/problems/720

星宇康
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
堆排序递归和非递归的实现
08-07
该源码主要在winform中实现的堆的构造，大顶堆和小顶堆的构造，在构造过程中有递归和非递归两种方式实现，当然必不可少的是堆排序了
堆排序-递归实现和非递归实现
最新发布
冯宝宝
07-04 123
【代码】堆排序-递归实现和非递归实现。
UCB CS61a Lab03 递归、树形递归(Python)
Epoch101的博客
05-04 429
UCB CS61a Lab03 递归、树形递归(Python)
python从零开始－－16 函数之递归
Pansc2004的博客
05-09 184
　　如果一个函数体直接或间接调用自己，那么这个函数就称为递归函数。可以将“递归函数计算”理解为“建立金字塔”，每次调用递归，相当于创建一层金字塔，并同时触发创建下一层金字塔，直到最高层创建完毕后，因为没有地方累积新的一层，整个创建过程才结束。 　　写递归函数有一个关键点： 递归函数必需有条件让“递归”走向终结，否则就成了无限循环。我们看下面几个例子： def sum(stop_num): ...
c++从零开始---递归
BUSHUAID的博客
12-03 115
函数可以调用自身，这种功能称为递归。递归可以有只包含一个递归的递归，也可以包含多个递归。也就是在运行一次函数时，调用一次自身或是多次。 1、包含一个递归调用的递归 通常的格式是将递归调用放在 if 语句中，这样递归才可以判断是否结束递归循环调用： void recurs(arguments) { statements1 if (test) recurs(arguments) statements2 } test 最终为 FALSE，调用链断开。 在以上程序格式中，递归调用将导致执行 n 次 s
堆排序思想和案例图解
Peter_Changyb的博客
09-09 7998
堆排序的基本思想是：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了 步骤一 构造初始堆。将给定无序序列构造成一个大顶堆（一般升序采用大顶堆，降序采用小顶堆)。 　　a.假设给定无序序列结构如下 2.此时我们从最后一个非...
数据结构六——堆
约定的博客
07-03 282
1 堆定义 1.1 定义和结构 1.2 操作和存储结构 1.2.1 插入元素 1.2.2 删除堆顶元素 2 堆排序 2.1建堆 2.2 排序 2.3 时间复杂度 2.4 为什么使用快排而不是堆排序 3 思考 堆除了排序还有什么用处？ ...
从零开始认识堆排序
WindWant
06-27 273
一、什么是堆？ 维基百科的解释是：堆是一种特别的树状数据结构，它需要满足任意的子节点必须都大于等于（最大堆）或者小于等于（最小堆）其父节点。 二、堆排序 堆排序是通过二叉堆数据结构实现，二叉堆满足一下两个特性： 1、满足对的基本特性 2、完全二叉树，除了最底层外，其它层都已填充满，且是从左到右填充。 二叉堆的高度即为根节点到叶子节点的最长简单路径长度，即为θ(lgn)。 二叉堆上的操作时间复杂度为O(lgn)。 1、二叉堆中的元素个数 根据二叉堆的特性2，我们知道高度为h的二叉堆重元素个数
非递归堆排序改进，从下标0开始排序
yudingding6197的专栏
07-21 942
网上堆排序用到的数组，很多都是从1开始进行排序。我做了改进，可以从0开始。希望能够帮助大家，如果有错误，非常感激能够指出 #include void print_arr3(int arr[], int count) { int i; printf("\n_____ current list:\n"); for(i=0; i<count; i++) { printf("%d ",
C++索引从0开始的堆排序算法实现
Fudanqqqqq的博客
04-16 351
最近算法群里有人问堆排序的问题，我一想没想出来，就又看看算法导论堆排那章，跟着敲了一遍，感觉印象算是深刻了一些。 堆排序的几个函数： 1.maxheap(nums[ ]，int i) 首先我们数组从1开始编号，为了方便。即i为父节点，nums[i]的左右孩子分别为2i和2i+1，算算对不？这个函数假设i的左右子树都已经为最大堆，只有nums[i]这个根节点可能有问题，下面上代码： void max...
bag_0-1背包问题递归非递归动态规划_
10-01
实现了计算随机生成的背包容量和物品价值，重量的0-1背包问题的动态规划算法
Lua中的递归函数写法实例
09-22
主要介绍了Lua中的递归函数写法实例,本文直接给出代码实例,并作了简洁注释,需要的朋友可以参考下
归并排序的递归实现与非递归实现代码
09-05
以下是对归并排序的递归实现与非递归实现代码进行了详细的介绍，需要的朋友可以过来参考下
javascript中递归的两种写法
11-28
话不多说，请看代码 function addd(n){ if(n==1){ return 1; } return n*addd(n-1); } function add(n){ var num=1; for(var i=1;i<n;i++){ num=num*i; } return num; }
常用排序算法递归篇之堆排序
知猪侠的专栏
08-24 2826
在讲堆排序之前，我们先来了解一下什么是堆，堆的定义如下：       n个关键字序列array[0...n-1]称为（Heap），当且仅当该序列满足如下性质：       array[i] =号。array[i]相当于二叉树的非叶结点，array[2i + 1]则是左孩子，array[2i + 2]是右孩子。       若将此序列array[0...n-1]看做是一棵完全二叉树，则堆实
java递归实现堆排序
leadseczgw01的博客
10-18 528
java递归实现堆排序
堆排序下标从零开始
06-22 1182
下标从0开始好像也影响不大，就是把树的cengc
堆排序详解
码农笔记
10-29 166
上一篇博文大概讲述了优先级队列的实现，这一篇来谈一下堆和堆排序，优先级队列参考如下博文。详解二叉堆，及优先级队列实现​​​​​​ 上述博文中介绍了完全二叉树，满二叉树，堆及堆的存储，以及介绍了优先级队列的一些实现，这一篇博文来介绍下堆排序相关的内容。 上文中提供了一些常用的方法，如插入一个元素时，为了维持堆的特性需要执行上浮（swim）方法，以及删除一个元素时为了维持堆的性质而执行的下沉（sink）方法。以及一些如求左孩子left方法，和求右孩子right......
快速排序的非递归写法
05-27
快速排序的非递归写法可以使用栈来实现。具体步骤如下： 1. 定义一个栈，将整个序列的起始和结束位置入栈。 2. 从栈中取出一个区间，将区间分为左右两部分，选取一个基准值将左右两部分分别进行排序。 3. 将排序后的左右两部分的区间起始和结束位置依次入栈。 4. 重复第2、3步，直到栈为空。 下面是 Python 实现代码： ```python def quick_sort_no_recursion(arr): stack = [(0, len(arr) - 1)] while stack: left, right = stack.pop() if left >= right: continue pivot = partition(arr, left, right) stack.append((left, pivot - 1)) stack.append((pivot + 1, right)) def partition(arr, left, right): pivot = arr[right] i = left - 1 for j in range(left, right): if arr[j] <= pivot: i += 1 arr[i], arr[j] = arr[j], arr[i] arr[i+1], arr[right] = arr[right], arr[i+1] return i+1 ``` 其中 partition 函数是快速排序的核心，用于将序列分成左右两部分并返回基准值的位置。快速排序的时间复杂度为 O(nlogn)。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值