在像堆排序或快速排序这样的排序算法中，当标准出版物或研究论文可以简单地分别使用升序或降序时，为什么它们更喜欢术语“非升序”或“非升序”？我的意思是不管怎样，意思都是一样的。
浏览 39提问于2017-02-25得票数 4
回答已采纳
3回答
微堆按什么顺序排序？
、、、、
我一直在阅读关于minHeap和maxHeap的各种定义。我无意中发现了这样的说法：
minHeap用于按降序排序。
maxHeap用于按升序排序。
声明摘自中的“说明”。但是，当我使用默认比较器在Java中使用minHeap实现PriorityQueue<Integer>并轮询()它时，我得到了最小元素。为什么会这样呢？感谢任何想帮忙的人:)。
浏览 8提问于2020-05-31得票数 1
回答已采纳
1回答
数组的最大堆表示形式
、、、、
作为一个作业问题，我必须从一个数组中提取出最大堆。问题是这样的：
请取出存储在以下数组中的最大堆(堆大小为6) A[] = {15,10,8,5,2,7,20,30}
所以，当我尝试这个问题时，我只是按照传统的方法来做，没有考虑到heapSize小于数组大小。
我得到的最大堆是：{30,20,15,10,2,7,8,5}
我的问题是:这是正确的吗？另外，既然heapSize小于数组大小，这对产生的最大堆有何影响？我应该只显示到第6个元素的最大堆数组，还是应该修改我的最大堆？
谢谢!
浏览 3提问于2016-11-04得票数 1
6回答
为什么堆不稳定？
、、
我想弄明白为什么堆不稳定。我搜索过这个，但没有找到一个好的，直观的解释。
我理解稳定排序的重要性--它允许我们根据多个键进行排序，这是非常有益的(例如，进行多个排序，每个排序基于不同的键。因为每种类型都将保持元素的相对顺序，以前的排序可以加起来给出按多个标准排序的元素的最终列表)。然而，为什么堆不保存它呢？
谢谢你的帮忙!
浏览 16提问于2013-10-12得票数 39
回答已采纳
我在网上遇到了一个问题，询问从堆支持的Min优先级队列中获取最大值的平均时间复杂度。
我推断答案是O(n)，因为堆是由数组支持的，迭代数组一次以找到最大值需要进行n比较。
然而，答案是O(nlogn)。有谁能解释一下为什么会这样，为什么我的推理失败？
浏览 6提问于2017-12-11得票数 0
回答已采纳
1回答
我正在实现一个堆排序，我开始想知道堆的不同实现。当您不需要按索引访问元素时(就像在堆排序中一样)，使用数组实现堆或像其他链接数据结构一样实现堆有什么优缺点。
我认为重要的是要考虑到节点和指针所浪费的内存与数组中空格所浪费的内存，以及在必须调整数组大小时添加或删除元素所需的时间。
我应该在什么时候使用每一个，为什么？
浏览 2提问于2011-06-27得票数 0
回答已采纳
2回答
堆排序时间复杂度深入理解
、、、、
当我在大学学习数据结构课程时，我学到了以下公理：
在最坏的情况下，向堆中插入一个新的数字需要O(logn) (取决于它作为叶子插入到树中的高度)
使用从空堆开始的n插入构建一个由n节点组成的堆，并使用摊销分析将其求和为O(n) time
在最坏的情况下，删除最小的O(logn)时间(取决于新的顶节点在与最后一个叶子交换后到达的最低程度)。
将所有最小值逐个移除，直到堆为空，需要O(nlogn)时间复杂度。
提醒：“堆排序”算法的步骤是：
将所有数组值添加到堆中:使用摊销分析技巧将其相加为O(n)时间复杂度
从堆n时间中取出最小值，并将
浏览 4提问于2015-08-20得票数 3
回答已采纳
使用堆排序可以在Θ(log )时间内排序多少个元素？
当我们进行堆排序时，为了构建堆，我们需要Θ(n)复杂性，然后执行堆排序O(nlog n)。我理解这个概念。但是，当谈到这里的问题时，我们甚至不能在Θ(log )时间内构建一个n个元素的堆。那么，答案O(1)是否考虑输入大小n？
我还看到了一种不同的解释，它导出了考虑输入大小logn的Θ(logn/logn n)的复杂性。我也不太遵循这个方法。那么，哪个是正确的答案，为什么呢？
浏览 5提问于2014-01-16得票数 6
回答已采纳
1回答
合并排序将列表划分为最小的单元(1元素)，然后将每个元素与相邻列表进行比较，对两个相邻列表进行排序和合并。最后，对所有元素进行排序和合并。我希望实现合并排序算法，使其将列表划分为两个元素的最小单元，然后对它们进行排序和合并。？我怎样才能实现呢？
合并排序(A，p，r)
如果p<r //检查基本情况，则q=地板(p+ r)/2 //除法步骤合并(A，p，q) //征服步骤。合并(A，Q+ 1，合并(A，p，q，r) //征服步骤。
类似于p< r+1。
浏览 2提问于2012-03-01得票数 0
2回答
在给定范围内的堆排序
、、、、
我试图编写一个Heapsort方法，该方法只在传递给该方法的给定范围内执行排序。传入范围低和高，这些值对应于堆内的值，而不是堆的索引。例如，输入数组可能是: 28 1049 20 59 61 17，如果低= 49和高= 61，则Heap排序后的结果数组将如下所示: 28 10 20 49 59 61 17。范围以外的值保持不变。我已经有了一个有效的Heapsort方法，但是我的问题是如何修改这个方法，使其在传递的范围内进行排序？
public static void heapSort(int[] array, int low, int high)
{
/
浏览 5提问于2016-04-16得票数 0
回答已采纳
当我知道PQ在时间复杂度方面会更好的时候，我什么时候会选择Collections.sort()而不是PriorityQueue呢？
浏览 3提问于2014-03-23得票数 6
回答已采纳
1回答
如果我们使用的是顺序机器(不可能进行并行比较)，并且是按顺序进行比较，并且在对32个随机元素进行排序时，我们希望尽量减少处理器时钟周期的数目，那么我们应该使用排序网络还是自适应排序算法？
对于n=32元素，还没有最优网络。实际上，如果我们要最小化CPU时钟周期的数目，那么最好将32个元素划分为n=8的四个子列表，并在每个子列表上应用最优排序网络，然后将这些列表合并在一起吗？
很明显，我们在这里使用的是“平均性能”，因为如果给出一个已经排序的列表，自适应算法就会很幸运。
计算数字，我们有以下几个数字：
对大小n的列表进行排序：
n=2的最小比较数为1。
n=4的最小比较数为5。
n=
浏览 5提问于2018-04-26得票数 2
3回答
在研究排序算法时，将其称为堆排序用于外部排序。当我们处理外部存储时，我不能弄清楚它在排序技术方面有什么不同？或者，堆排序唯一能被认为对外部排序有用的东西是什么？
有没有人能解释一下？
浏览 6提问于2018-01-06得票数 1
我在读“算法导论”中的堆排序，其中提到(1)以自下而上的方式构建最大堆。(2)然后与最后一个元素交换，并在第一个元素上调用max hepify，然后像这样继续。
让我们以下面的输入为例：
->7 10 20 3 4 49 50
构建最大堆的步骤如下
7 10 50 3 4 49 20
7 10 50 3 4 49 20
50 10 7 3 4 49 20
这是最大堆构建。现在我们与last交换
20 10 7 3 4 49 | 50
现在我们在20上调用max heapify，什么都没有发生，我们会把20放在n-1的位置，这是错误的。
我们以自下而上的方式制作堆，但以自上而下的方式调用h
浏览 1提问于2015-08-21得票数 0
我们得到了一个整数数组：
45, 10, 56, 42, 95, 78.
我们必须找到差异最小的两个元素。我在线性时间复杂度中做到了这一点，但它只在排序的顺序上工作，这总共导致了二次复杂度的运行时间。我们有什么方法可以在对数或线性时间复杂度下做到这一点吗？
提前谢谢。
浏览 0提问于2015-08-02得票数 3
我有一个二维的p_q数组，我想对这个数组按m_n的二维数组进行排序，其中p>m和p=km，q>n和q=kn，以及k是整数。例如，我有一个16*16的数组，我把它划分为4*4的2d数组，现在我想独立地对这4*4数组进行排序。在不需要额外内存的情况下，我可以使用哪种算法在place.means中对这些数据进行排序。
浏览 9提问于2009-08-15得票数 0
2回答
我用的是ArrayPool和C#。我想要创建我自己的池，最大编号为数组5，最大大小为数组1050000。我使用了这个ArrayPool.Create()方法。我无法理解一件事-我试图从池租借10次在下面的片段，虽然我指定最大数组为5，那么它为什么没有显示任何错误。另外，我指定最大长度为1050000。那么，我如何能够在没有任何错误的情况下租用一个4200000数组？
byte[] buffer;
ArrayPool<byte> pool = ArrayPool<byte>.Create(1050000, 5);
for
浏览 0提问于2020-06-25得票数 0
回答已采纳
给定以下代码：
#include "stdafx.h"
#include "string.h"
static char *myStaticArray[] = {"HelloOne", "Two", "Three"};
int _tmain(int argc, _TCHAR* argv[])
{
char * p = strstr(myStaticArray[0],"One");
char hello[10];
memset(hello,0,sizeof(hello));
浏览 0提问于2012-05-01得票数 1
回答已采纳
5回答
堆排序排序算法的最坏情况复杂度似乎为O(nlogn)，排序操作使用O(1)空间。
这似乎比大多数排序算法都要好。那么，为什么不总是使用堆排序作为排序算法(以及为什么人们使用像合并排序或快速排序这样的排序机制)？
此外，我还看到人们将“不稳定性”这一术语与堆排序一起使用。这意味着什么？
浏览 49提问于2011-11-29得票数 71
回答已采纳
2回答
我读到了Java编程中的堆。在我的教科书中，我发现了堆的定义:堆是一个完整的二叉树，具有以下属性: 1)根中的值是树中最小的项；2)每个子树都是堆
但是当我看关于堆的视频时，我发现堆的定义完全不同:在堆中，父键是更大的，然后是子键。
现在，我感到困惑，因为这两个定义不符合彼此。哪个定义是正确的？
谢谢!
浏览 6提问于2015-12-15得票数 0
回答已采纳
8回答
根据题目，如果数组的长度为奇数，并且数组元素的编号为1- 10。
例如，
3 6 8 1 3 7 7 9 4 1
我在考虑使用堆排序？由于它是一个数组，合并排序和插入排序需要移位，因此效率不高。
浏览 108提问于2011-09-29得票数 21
回答已采纳
我希望在用Rust编写的排序算法上运行一些基准测试(基准测试是使用Criterion和cargo bench)。当我将编译后的版本与内置的sort()进行比较时，我发现速度上有一个数量级的差异。 我的问题是:切片上的“开箱即用”排序怎么会比作为库编译的完全相同的代码快这么多。 为了尝试和比较苹果与苹果，我采用了Rust源代码(https://github.com/rust-lang/rust/blob/stable/src/libcore/slice/sort.rs)中的快速排序算法。当我将其与现成提供的sort()函数进行直接比较时，我注意到x16在速度上的差异。我也尝试过在Cargo.t
浏览 9提问于2019-09-13得票数 0
1回答
这是我的快速排序代码，它选择最正确的值作为轴心：
def qsort_right(self, array):
less = []
equal = []
greater = []
last_value = len(array) - 1
if len(array) > 1:
pivot = array[last_value]
for i in array:
if i < pivot:
less.append(i)
if i == piv
浏览 2提问于2014-07-27得票数 0
1回答
我正在为软件开发人员的面试做准备，并且一直在研究算法问题。我的书展示了一个Heapsort算法，它可以按递增的顺序对无序数组进行排序。我试图修改它，这样它就可以与最小堆进行排序。但是，当我遵循代码中的逻辑时，它不能正确地排序数组。我的代码(伪代码)有什么问题？
The array to be sorted: 16, 14, 10, 8, 7, 9, 3, 2, 4, 1
这本书的堆排序算法使用max-heapify：
HEAPSORT(A)
BUILD-MAX-HEAP(A)
for i = A.length down to 2
swap A[1] with A[i]
浏览 2提问于2014-06-30得票数 3
回答已采纳
2回答
在哪种情况下可以使用堆排序？如我们所知，堆排序具有n×lg(n).的复杂性。但是它的使用要比快速合并排序少得多。那么，我们什么时候才能准确地使用这种堆类型?它的缺点是什么？
浏览 2提问于2013-08-10得票数 0
5回答
我不明白为什么堆排序被认为是一个内部排序算法。
我的意思是使用要排序的数组元素填充的额外数据结构，即堆，用于帮助提取最小值和排序过程。
所以我可能误解了这里的定义吗？
但是插入排序--例如，它显然是内部算法，即元素不需要额外的内存。
那为什么要把它放在原地呢？
浏览 0提问于2011-10-29得票数 15
回答已采纳
1回答
堆排序的目的是什么？
、、、、
当我们构建堆时，数组中的元素会按照特定的顺序(升序或降序)排列，这取决于它是最大堆还是最小堆。那么，当构建堆本身以较低的时间复杂度按排序顺序排列元素时，堆排序的用途是什么？
void build_heap (int Arr[ ])
{
for(int i = N/2-1 ; i >= 0; i-- )
{
down_heapify (Arr, i, N);
}
}
void heap_sort(int Arr[], int N)
{
浏览 8提问于2021-09-05得票数 2
回答已采纳
1回答
堆排序空间复杂度
、、、
我正在阅读Skiena的“算法设计手册”，特别是关于堆排序的部分。他说
它是就地排序，这意味着它不对包含要排序的元素的数组使用额外的内存。
书中的算法如下所示：
heapsort(item_type s[], int n)
{
int i;
priority_queue q;
make_heap(&q, s, n);
for (i=0; i<n; i++)
s[i] = extract_min(&q);
}
在我看来，除了条目的输入数组s之外，我们还在priority_queue变量中创建堆数据结构。这不意味着所需的空间复杂度是O(
浏览 3提问于2014-11-22得票数 1
4回答
我有一个关于堆排序的问题。它在一本算法书中说，A.heap-size<= A.length我不明白两者之间的区别。如果数组代表堆，为什么A.heap-size小于A.length。我知道A.heap-size表示堆中元素的数量，那么为什么它不完全等于数组中的项目数呢？
浏览 5提问于2013-09-27得票数 18
回答已采纳
1回答
堆算法时间复杂度
、、、、
有人能告诉我维基百科，中这个堆算法的时间复杂度到底是多少吗？
我搜索了几个网站，答案都很模糊，有些人说时间复杂度是O(N!)有些人说这是O(NlogN)。哪一个是正确的答案？为什么？
谢谢。
浏览 3提问于2017-03-18得票数 5
回答已采纳
当我创建一个整数指针数组时，我尝试了以下操作。
int *arr = new int*[10];
这不起作用，但下面的方法起作用了。
int **arr = new int*[10];
为什么我们需要双指针？当我服从它的时候，我不得不做下面的事情。
cout<<arr[0];
为什么我们不需要*在arr前面？？谢谢!
浏览 5提问于2015-01-22得票数 1
回答已采纳
2回答
在C#中，程序应该通过将它们与数组进行比较来计算输入的有效值和无效值，然后给出正确和不正确的输入，但是当我输入超出if语句界限的数字时，if语句中的代码仍然会运行。我已经回到过去，回顾了视频和教科书，我看不出我的“如果其他声明”是哪里缺少的。
int[] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, };
int count = 0;
Console.WriteLine("Enter a value between 0 and 10");
foreach (int v
浏览 9提问于2022-04-13得票数 0
3回答
我正在为Android开发一个应用程序。在这个应用程序中，您必须使用加密/解密Rijndael算法。
要使用这个算法，我需要安装IVs。在这种情况下，是一个字节数组。到目前一切尚好。
问题是，我必须使用用C #编写的Web服务中的相同的IVs。
因此，C#是：
byte[] bytIV = { 121, 241, 10, 1, 132, 74, 11, 39, 255, 91, 45, 78, 14, 211, 22, 62 };
当我试图在Java中做同样的事情时，会出现一个错误，我建议添加一个强制转换数。是什么使代码是这样的：
byte[] bytIV = { 121, (byte) 24
浏览 4提问于2012-07-23得票数 0
3回答
所以我有这样的代码
// REQUIRES: n >= 1. Elements a[0] ... a[n-1] exist.
// PROMISES
// If n == 1, returns 1.
// Returns 1 if all of a[0] <= a[1] ... a[n-2] <= a[n-1] are true.
// Otherwise, returns 0.
#include <assert.h>
#include "array-utils4F.h"
#define UNIT_TESTS 1
int is
浏览 3提问于2015-10-15得票数 0
回答已采纳
2回答
我知道堆排序中构建最大堆的运行时间是O(n)。但是，如果我们有一个已经按递减顺序排序的数组，为什么我们仍然有用于Build-Max堆运行时间的O(n)呢？
不是应该是类似于O(1)的吗？它已经从最大值排序到最小值，所以我们不需要。
我的理解正确吗？有人能给我解释一下吗？
浏览 1提问于2016-09-25得票数 1
3回答
新的堆数据结构。
试图从列表中创建堆。
li = [5, 7, 9, 1, 3]
heapq.heapify(li)
在堆后，输出是
[1, 3, 9, 7, 5]
为什么要下这个命令？
我认为对于一个最小优先级堆，元素应该从min排序到max，即
heapq.heapify(li)应该与li.sort()相同
有人能帮我理解吗？
浏览 1提问于2018-05-31得票数 1
回答已采纳
我不明白为什么我的代码不起作用，当我逻辑地阅读它时，我觉得它应该工作，但是它所做的是返回3,4,2，而不是3的最高数(即4)。
const array2 = ['a', 3, 4, 2] // should return 4
for(items of array2){
if(items > 0) {
console.log(Math.max(items));
}
我做错了什么？我误解了什么？请不要给我答案，只要告诉我为什么我的逻辑不起作用
浏览 9提问于2022-09-02得票数 0
当有一个从一开始就按降序存储数据的数组时，例如5, 4, 3, 2, 1排序算法(快速排序，合并排序.)是按升序排序这个数组的最佳方法吗？为什么？
浏览 4提问于2021-10-21得票数 0
回答已采纳
我正在尝试实现Cormen中提供的堆排序算法。我的代码如下：
#include<stdio.h>
#include<conio.h>
void max_heapify(int *,int);
void build_max_heap(int *,int);
void heapsort(int *,int);
void swap(int,int);
int heapsize;
int main()
{
int *arr,n,i;
printf("E
浏览 3提问于2013-08-12得票数 2
回答已采纳
当我在.c文件中运行这段代码时，它可以工作，但是当我为它创建一个项目时，我调用的函数将只返回0.00。为什么？为什么它在项目文件中不起作用？
我使用的是DevC++。
#include<stdio.h>
float mean(int total, int max);
int main(){
int i,max, total=0;
int array[max];
printf("Enter max: ");
scanf("%d",&max);
for(i=0; i<max; i++){
浏览 2提问于2017-03-29得票数 0
3回答
堆排序的应用
、、、
Heapsort是一种时间复杂度为O(nlogn)的排序算法，它使用O(1)空间复杂度进行排序。然而，我知道，因为它是不稳定的，它找不到多少应用程序(f.e。(与其他排序算法相比)。
我知道它是用来安排时间的。
堆排序的一些实际应用是什么？
编辑:正如@AProgrammer所指出的，快速排序也不稳定。
浏览 0提问于2013-04-08得票数 4
1回答
2017年DST将于10月15日(午夜)在巴西开始-
当我更改到Windows中的巴西时区并将日期更改为2017年10月15日之前的几天时，我看到系统正确地显示了DST开始日期(显示的信息显示DST将于10月15日开始)。
问题是，当我试图从代码中获取DST开始日期时，它将返回10月22日。我使用c++ mktime和c# TimeZone.GetDaylightChanges进行了尝试。
以下是c#代码：
Console.WriteLine(TimeZone.CurrentTimeZone.GetDaylightChanges(2017).Start.ToString());
结果是：
1
浏览 0提问于2015-01-22得票数 1
回答已采纳
1回答
堆排序的辅助空间与空间复杂度的差异？
我的尝试：
如所解释的
如果我们想比较基于空间的标准排序算法，那么辅助空间将是一个比空间复杂性更好的标准。合并排序使用O(n)辅助空间，插入排序和堆排序使用O(1)辅助空间。然而，所有这些排序算法的空间复杂度都是O(n)。
我搜索了堆排序的空间复杂性，发现空间复杂度是O(1)。
我的问题是：
这个解释正确吗？辅助空间和空间复杂性有什么区别？
浏览 4提问于2017-06-01得票数 3
回答已采纳
我不明白为什么超过9的力量对我不起作用。看起来很简单:我只是试着用10的力量来提高10，但无论出于什么原因，numpy都失败了。有什么问题吗？
import numpy as np
number = 10
arr = [number]
print(np.power(np.array(arr),number)) # [1410065408]
print([n**number for n in arr]) # [10000000000]
浏览 0提问于2018-05-26得票数 1
回答已采纳
1回答
可以说，当大小为n的数组A中的所有元素都相同时，堆排序的运行时间是O(n)吗？
-->如果是这种情况，堆排序的运行时间是O(n)个最佳情况吗
浏览 1提问于2011-11-17得票数 5
回答已采纳
3回答
这是我的excel工作簿的屏幕截图。
我不明白为什么单元格j7中的值是44？
j7公式是=LOOKUP(1,(TRIM($D$2:$D$9)=TRIM(H7))/(TRIM($E$2:$E$9)=TRIM(I7)),$F$2:$F$9)
两个数组除法的结果如下
{TRUE;TRUE;FALSE;FALSE;FALSE;FALSE;FALSE;FALSE}/ {TRUE;FALSE;TRUE;FALSE;FALSE;TRUE;FALSE;FALSE} = {1;#DIV/0!;0;#DIV/0!;#DIV/0!;0;#DIV/0!;#DIV/0!}对吗？
所以我在寻找1，基本上公式变成
浏览 4提问于2014-10-06得票数 1
回答已采纳
在没有索引的理论场景中，带有限制的order必须扫描所有数据，然后应用order，然后应用限制，因为我们只有在排序后才能得到前10行(例如)。
但是postgres在这里并不聪明，下面的计划给出了这个故事。
有限制的命令
learning=# explain (analyze,buffers) select * from temp order by userid limit 10;
QUERY PLAN
--------------------------------------
浏览 6提问于2015-11-26得票数 2
回答已采纳
我不知道这个算法是堆排序还是快速排序.
假设我有一个没有源代码的算法--它是不稳定的，在大型数据集上性能很好，对于有序和无序的集合，运行时间类似。
如果没有更多的信息，是否可以判断这个算法是堆排序还是快速排序？
浏览 5提问于2016-06-21得票数 2
回答已采纳
3回答
我正在编写一个程序，它接受10个输入，并以相反的顺序打印它们。下面是我在c#中的代码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace inverse
{
class Program
{
static void Main(string[] args)
{
int i ;
int[] n = new int[10];
Console.WriteLine("please en
浏览 1提问于2016-10-01得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
腾讯会议活动推荐
腾讯云开发者
