/**
* Sorts the specified sub-array of bytes into ascending order.
*/
private static void sort1(byte x[], int off, int len) {
// Insertion sort on smallest arrays
if (len < 7) {
for (int i=off; i<len+off; i++)
for (int j=i; j>off && x[j-1]>x[j]; j--)
swap(x, j,
浏览 6提问于2011-05-16得票数 11
回答已采纳
2回答
我试图在Java中实现一种高效的排序算法。出于这个原因，我还实现了快速排序，并使用了以下代码：
public class Sorting {
private static Random prng;
private static Random getPrng() {
if (prng == null) {
prng = new Random();
}
return prng;
}
public static void sort(int[] array) {
sortInte
浏览 1提问于2016-04-04得票数 1
回答已采纳
我想要切换到插入排序对较小的数组和快速排序的较大数组。切换到插入排序可以减少递归的次数。我想知道数组的最大大小，在那里我可以切换到插入排序.
以下是快速排序和插入排序的实现。对于数组长度<9，使用插入排序。
即使我们知道双枢轴快速排序使用插入排序数组较小的数组长度< 27
PS - Java使用双枢轴快速排序来排序原语类型。
浏览 3提问于2017-03-22得票数 1
1回答
插入排序算法
、、
我对数据结构和算法很陌生。我刚刚实现了一个插入排序算法。我只想确定我的代码是否正常。
import java.util.Arrays;
public class Main {
public static void main(String[] args) {
int[] test = {40, 1, 5, 0, 9};
for (int i = 0; i < test.length; i++) {
for (int j = i - 1; j >= 0; j--) {
if (t
浏览 0提问于2022-02-05得票数 1
回答已采纳
2回答
我正在进行双枢轴快速排序，我找到了 (幻灯片中的第20页)
比较：
雅罗斯拉夫斯基平均需要量为1.9 n/n。
经典的快速排序需要=2，n，n，n个比较！
全部门办法：
雅罗斯拉夫斯基算法的交换=0.6nln
经典Quicksort=0.3 n ln的交换
结果
数据类型
整数
浮子
双
查
/*注意:-上面的结果是纳秒，在java lang中使用英特尔核心2 duo */
如果我们将交换和比较的成本与经典的快速排序相结合，除了字符串的情况外，我们使用指针数组交换，这需要88 nanosecond.Here，Yaroslavskiy的算法利用了1.9nln的比较，因为在
浏览 13提问于2014-02-16得票数 4
如果数组长度小于某个阈值，Java6在Arrays.java中的合并排序实现将使用插入排序。这个值被硬编码为7。由于算法是递归的，对于大型数组，这种情况最终会发生很多次。规范的并不这样做，只是一直使用merge-sort，直到列表中只有1个元素。
这是一种优化吗？如果是这样，它应该有什么帮助呢？为什么是7？插入排序(甚至是<=7排序)大大增加了对大型数组进行排序所需的比较次数-因此会增加compareTo()调用速度较慢的排序的开销。
(对于不同的INSERTIONSORT_THRESHOLD值，x轴为size of array，y轴为# of comparisons )
浏览 0提问于2011-07-11得票数 22
回答已采纳
4回答
3-快速排序，问题
、、、
我正在尝试理解3向基数快速排序，我不明白为什么那里有截断变量？那插入的方法呢？
public class Quick3string {
private static final int CUTOFF = 15; // cutoff to insertion sort
// sort the array a[] of strings
public static void sort(String[] a) {
// StdRandom.shuffle(a);
sort(a, 0, a.length-1, 0);
as
浏览 1提问于2010-06-11得票数 4
回答已采纳
7回答
对少量元素进行排序
、、、
我经常发现自己处于一种需要对少量元素进行排序的情况。小，我的意思是3或4。我的想法可能是正确的，对于这么小的问题集，我想要使用某种类型的显式或直接方法，而不是调用排序函数。2是微不足道的，3个元素仍然很简单，但超过4个项目，我开始喜欢简单的只是运行插入排序。
编码一个inline void sort_n(int *list)最多能有多少个元素? 4? 5? 6？
在本主题中，提供了对3个元素进行排序的两种解决方案。一个有更多的比较，而另一个最小化比较，但更复杂。在现代架构上，哪一个会在速度上脱颖而出？
浏览 0提问于2011-12-25得票数 4
回答已采纳
大家好，
我是一名CS学生，目前正在进行一个结合MergeSort和InsertionSort的实验。据了解，对于某个阈值，S、InsertionSort将比MergeSort具有更快的执行时间。因此，通过合并这两种排序算法，将优化整个运行时。
然而，在多次运行实验后，使用1000的样本大小和不同的S的大小，实验的结果并不是每次都给出一个明确的答案。以下是所取得的更好结果的图片(请注意，有一半的结果并不确定)：
现在，尝试相同的算法代码，样本大小为3500：
最后，尝试同样的算法代码，样本大小为500,000 (注意y轴以毫秒为单位)：
尽管从逻辑上讲，混合Mer
浏览 6提问于2017-09-29得票数 11
回答已采纳
考虑两个数组，A和B，两者的长度都是N，N相当小。我想对A中的元素进行排序，并将排序后的元素存储在B中。
在A上执行就地插入排序，然后将排序后的值大容量复制到B中是非常简单的，但是，这不能充分利用以下两点：
有N号的划痕空间可供使用和
排序后的值最终必须在B而不是A中结束。
有人能提出不同的方法(可能是修改的插入排序吗？)这将利用其中的一个(或两者)，并最终超过简单的解决方案插入排序+复制？
浏览 5提问于2013-09-12得票数 0
1回答
在递归排序中使用Helper方法
、、、、
我正在尝试用Java语言编写一个版本的timSort，它使用array.length < 10之后的插入，否则使用合并排序。假设我对insertionSort和merge的调用是正确的，是什么使下面的代码不会命中插入、排序和正确的timSorting？ /**
* timSort is a generic sorting method that sorts an array of Comparable data
* using the TimSort algorithm. Make sure this method is public so that we can
* test
浏览 28提问于2019-03-11得票数 0
2回答
插入排序与冒泡排序的比较
、、、、
然而，我发现冒泡排序的执行速度更快。我的代码如下。
冒泡排序
for(int j = 0; j < a.length - 1; j++){
for(int i = 0; i < a.length - 1 - j; i++) {
count++;
if(a[i] > a[i+1]){
temp = a[i];
a[i] = a[i + 1];
a[i + 1] = temp;
}
}
}
插入排序
for(int i = 1; i < a
浏览 1提问于2014-06-02得票数 0
一个人声称他们可以通过以下参数来改进InsertionSort。在InsertionSort的最内部循环中，不要循环遍历已经排序的数组中的所有条目，以插入被观察到的j‘to元素，只需执行BinarySearch，以便将j’to元素夹在列表A1、.、j−1中的正确位置上。这个人声称，在最坏的情况下，它们的插入排序与合并一样好。对还是错?为什么？从下面圈出一个正确答案：
a. True：在这个版本中，while循环将迭代log(n)，但是在列表左侧的每个这样的迭代元素中，必须移动以允许键向下传播到中间元素，因此在最坏的情况下，这种转移仍然需要log(n)。总之，在这种情况下，插入排序将显著改进，以
浏览 3提问于2022-02-27得票数 -3
4回答
我在一些解释和一些库(例如Java )中看到，在这些库中，在指定数量的阈值元素下面使用插入排序和合并排序。其原因是插入排序也是稳定的。然而，泡泡排序或Tim也是稳定的，当然还有其他类型的。我不知道为什么使用插入排序来代替其他的。
浏览 0提问于2018-11-27得票数 1
我有一系列元素。这个数组可以是：
随机洗牌(大约20%的时间)
几乎按升序排序*(大约40%的时间)
几乎按降序排序(大约40%的时间)
但我(事先)不知道这些案件中哪一种适用。我倾向于按照已经接近的顺序对数组进行排序。
不管输出是升序还是降序，但它必须是一个或另一个(因此我可以对它执行二进制搜索)。
这种情况不一定是稳定的。
一些背景信息:这个过程大致如下：
填充数组
对某些属性A进行排序
做一些处理(计算分位数，以及其他一些次要的事情)
对其他属性B进行排序
做更多的处理
属性C的排序
做更多的处理
A和B通常是相互关联的(但可能是
浏览 4提问于2012-11-03得票数 5
回答已采纳
2回答
我对此有疑问；
我有一个这样的班级
class myCLass {
private:
string name;
float value;
public:
float getValue();
};
我有超过1,000,000个对象，我必须根据其值对这些项进行排序。所以我创建了指针列表；
list<myClass *> objectList;
然后用超过1.000.000个对象填充它。现在你可以说向量是最好的方法，如果你的对象小于30-40位，这是绝对正确的，然后我创建了它；
bool ec(myClass *s1, my
浏览 1提问于2013-10-14得票数 1
1回答
优化器选择在计划中插入排序操作符(以满足流聚合或合并连接等)的原因是什么。而不是进行散列匹配或散列连接？
我现在已经看到了几个例子，在这些例子中，它显然犯了一个错误，并且暗示查询会使它变得更快。
我看到的例子来自Server 2016。
浏览 0提问于2023-02-02得票数 0
回答已采纳
2回答
我正在努力实现一个快速排序算法，这个算法必须很好地工作，数组大小可达100,000。一旦我尝试排序的大小为1,000,000，我会得到一个堆栈溢出错误(由于我的算法的递归功能，这发生在我最好的理解中)。我知道以前有人问过这个问题，但这些答案对我一点帮助都没有。我仔细研究了我的代码，甚至把它建模在Java教科书上，只是为了反复检查，仍然没有修复。我已经在这里阅读了至少一个小时试图解决这个问题，我读到调用堆栈可以容纳8MB左右，取决于系统。我想知道是否：
我的算法错了
1,000,000个元素太大，不能用于快速排序(与此编译器一起使用)。
编辑:对于任何感兴趣的人:我发现将随机间隔
浏览 0提问于2018-02-25得票数 3
回答已采纳
3回答
插入排序与气泡排序与快速排序算法
、、、、
我正在研究我测试过的气泡排序和插入排序和快速排序，我做了随机数的测试。结果表明，插入排序比气泡排序更快，而快速排序是最慢的。
所以我在时间上有下面的排名
插入排序(最快)
气泡排序(二分)
快速排序(最慢的)
考虑到插入和气泡排序具有O(n2)的复杂性，而快速排序O(n log )和O (n log )应该更快！
有人能和我分享解释吗？
谢谢
(NSMutableArray *)quickSort:(NSMutableArray *)a
{
// Log the contents of the incoming array
NSLog(@"%@
浏览 1提问于2012-10-16得票数 1
回答已采纳
我正在测量排序所需的步骤数，无论出于什么原因，气泡排序似乎总是比插入排序要快一些，从我所读到的情况来看，应该是相反的。
不打算发布我的完整代码，但我相信问题可能在于我的计数在哪里。
气泡排序：
public void sort()
{
for (out = nElems-1 ; out >= 1 ; out--)
{
count = count+1;
for (in = 0 ; in < out ; in++)
{
if ((a.get(in)) > (a.get(in+1)))
浏览 0提问于2015-02-06得票数 0
回答已采纳
我使用与heapify算法相同的逻辑实现了一个排序算法。然而，我不相信这是堆排序。它的逻辑是，我将数组的两部分(最初将是一个双向链表，但如果不创建自己的类，java不允许我这样做)与它旁边的部分进行比较。如果它更大，则交换。很像冒泡排序。但是，当交换完成时，我会对第二个元素进行反向冒泡排序，以保持数组的顺序。 我不能完全确定最坏情况下的时间复杂度，但我认为它是O(n^2)。它的时间复杂度是多少，而且它最像的排序算法是什么？ import java.util.Arrays;
/**
* firstNum and secondNum trade places.
* Whenever a s
浏览 15提问于2021-01-06得票数 1
回答已采纳
对于CS作业，我将在java中创建大小越来越大的随机数组，并在一个图上绘制它们的运行时。但是，当使用相同的输入运行时，插入、合并和快速排序的实现似乎具有相同的运行时间。我已经用不同的方式实现了很多次，并且仍然得到了相同的结果。这是我的代码：
import java.util.*; import java.util.Random;
public class Complexity {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner input= new Sca
浏览 1提问于2018-03-10得票数 0
回答已采纳
不是插入排序 O(n^2) > Quicksort O(n log n)...so对于一个小n，关系不是相同吗？
浏览 0提问于2011-11-12得票数 34
我知道它们之间的区别，并且我理解LinkedHashMap和LinkedHashSet提供了插入排序。我明白LinkedHashMap extends HashMap和LinkedHashSet extends HashSet。
为什么我们不总是使用LinkedHashMap而不是HashMap，为什么我们不总是使用LinkedHashSet而不是HashSet
浏览 2提问于2014-06-20得票数 4
回答已采纳
1回答
并行化小网络排序
、、、、
我正在研究网络排序(对于小于8的数组)，并注意到所有的算法都集中在它允许并行操作的能力上。下面是大小为5的数组的一个这样的集合。
#define SWAP(x,y) if (data[y] < data[x]) { int tmp = data[x]; data[x] = data[y]; data[y] = tmp; }
//Parallelizable
SWAP(1, 2);
SWAP(4, 5);
//Parallelizable
SWAP(0, 2);
SWAP(3, 5);
//Parallelizable
浏览 3提问于2015-07-12得票数 4
回答已采纳
从插入排序的wiki页面：
一些分治算法，如快速排序和合并排序，递归地将列表划分为较小的子列表，然后排序。在实践中，这些算法的一个有用的优化是使用插入排序来排序小的子列表，其中插入排序优于这些更复杂的算法。插入排序具有优势的列表的大小因环境和实现的不同而不同，但通常在8-20个元素之间。
wiki的引用有一个原因，那就是合并排序中的小列表并不是插入排序的更糟糕的情况。
我只想忽略这个原因。
我知道，如果数组大小很小，插入排序O(n^2)就有可能击败合并排序O(n log )。
我认为(不确定)这与T(n)中的常数有关。
插入排序: T(n) = c1n^2 +c2n+c3
合并排序: T(n
浏览 3提问于2011-11-30得票数 0
回答已采纳
6回答
关于，我不完全理解这个是如何击败像这样的算法的。
在这个问题中，下面是完成排序所需的CPU周期数的比较：
Linux 32位，gcc 4.4.1，Intel Core 2 Quad Q8300，-O2
插入排序(Daniel Stutzbach)：1425
排序网络(Daniel Stutzbach)：1080
所使用的代码如下：
插入排序(Daniel Stutzbach)
static inline void sort6_insertion_sort_v2(int *d){
int i, j;
for (i = 1; i < 6; i+
浏览 16提问于2010-10-10得票数 15
回答已采纳
我只是做了一个数组问题，那里的解决方案使用了快速排序，但是我使用了Arrays.sort() method.Now，我认为Arrays.sort()使用了带基本类型的快速排序，对于对象类型使用了mergesort。那么，使用
Arrays.sort()
方法直接在java中执行，而不是为Quick sort.Or执行整个实现，如果两者相同，为什么不使用Arrays.sort()方法执行冗长的实现？
浏览 0提问于2016-04-17得票数 1
回答已采纳
1回答
优化少量数据的插入排序
、、、
我正在构建一个混合排序，为此，我需要一个快速和自适应的排序理想的小规模(< 65个元素)。
插入排序立即浮现在脑海中，我一直在修补不同的实现。我的要求是按照C++标准接受迭代器。
线性插入排序
template <typename Iter>
void lin_sort(Iter begin, Iter end) {
for (auto cur = begin; cur != end; ++cur) {
auto key = *cur;
auto ins = cur - 1;
for (; begin <= ins
浏览 0提问于2014-11-28得票数 4
回答已采纳
所以我知道线性的O(N)是n，插入是n**2，二进制是log(n)，合并是nlogn
因此，合并排序是大型列表的最佳搜索。上面的哪一个是最适合小列表的，比如有多小？谢谢
浏览 1提问于2014-02-19得票数 0
2回答
只是为了练习和提高我的编程技能，我决定解决InterviewStreet上的问题。我决定开始使用简单的InsertionSort (我希望它会很简单)。我能够得到正确的答案。然而，运行时是一个问题。测试用例允许的最大运行时间是5s。然而，我有点过火了。我使用了一些技巧(比如从代码中删除一些东西。存储str.lenght()等的结果。然而，我还是有点过火了。
这十个测试用例的当前运行时是：
%1成功通过0.160537
2成功通过0.182606
3通过成功0.172744
4成功通过0.186676
5超过失败时间限制。5.19279
6超过失败时间限制。5.16129
7通过成功2.9122
浏览 1提问于2012-11-11得票数 0
3回答
插入排序算法的以下Java实现出现在Noel Markham公开的Java编程访谈的第28页：
public static List<Integer> insertSort(final List<Integer> numbers) {
final List<Integer> sortedList = new LinkedList<>();
originalList: for (Integer number : numbers) {
for (int i = 0; i < sortedList.size();
浏览 0提问于2015-04-04得票数 4
然而，TreeMap具有O(log n)性能(最好的情况)，因为我需要高效地使用以下operations：
得到最高的元素
得到XY最高元素
插入
其他可能的方法是使用以下内容制作PriorityQueue：
使用"index“元素作为PriorityQueue的顺序
等于实现只检查"index“元素相等，但这将是一个黑客，因为”等于“方法很容易出错(如果在PriorityQueue之外使用)。
有更好的结构吗？
下面的更多细节，您可以跳过，因为第一个答案为这个细节提供了很好的答案，然而，我保持活跃的理论讨论。
注意:我可以使用非标准的数据结
浏览 0提问于2014-11-07得票数 0
2回答
我刚刚开始学习排序算法，并在网上找到了一个。起初我认为它是shell排序，但它缺少"k“的明显间隔和数组的一半，所以我不确定它是否是。我的第二个猜测是插入排序，但我只是在这里仔细检查：
for(n = 1; n < num; n++)
{
key = A[n];
k = n;
while((k > 0) && (A[k-1] > key))
{
A[k] = A[k-1];
k = k-1;
}
A[k] = key;
}
另外，如果你能解释为什么这也是有帮助的
浏览 2提问于2011-11-04得票数 4
3回答
我在插入排序时遇到了一些问题，从结构中传入数据。返回错误：|98|无法在赋值中将'store‘转换为'int’。
struct store{
char tag[5];
int cost;
long int volume;
};
void costSort(store storedEntries[], int count);
void volumeSort(store storedEntries[], int count);
int main(){
store record[100];
ifstream fin;
char
浏览 2提问于2015-03-26得票数 1
1回答
合并排序中的阈值是什么？
、、、
我不能理解合并排序中的阈值以及如何确定它。我用谷歌搜索了一下，但没有结果。有人能给我解释一下吗？我想使用合并排序对array50000进行排序，当阈值交叉时使用插入排序。
private int[] MergeSort(int[] lst)
{
int hl = lst.Length - 0;
if (hl < 5 || hl < 10 || hl < 15 || hl < 20 || hl < 25 || hl < 30 || hl < 35 || hl < 40 || hl < 45 || hl
浏览 0提问于2013-04-30得票数 0
2回答
我读到过关于排序的预排序列表，其中很少有数字是未排序的，有人说cooks kim算法最适合这种情况，我在谷歌上搜索了一下，但没有相关的链接。
如果有人知道这件事，请告诉我
谢谢
浏览 21提问于2010-11-30得票数 2
回答已采纳
我见过很多地方，它谈到插入排序对小数据集有什么好处。不过，我找不到“小”的数字。我的猜测是，没有绝对答案，这取决于运行代码的机器的类型。
然而，当插入排序是一个好主意时，哪些因素会决定什么是阈值？“小”的大概数字是多少? 5? 10? 50? 100？
谢谢!
站点说插入排序对小数据集很好：
浏览 0提问于2018-12-16得票数 0
回答已采纳
我刚刚写了下面的代码，我不确定它是否是Java中插入排序的正确实现(它看起来与冒泡排序太相似了，我不敢肯定)。 public static void insertionsort (int[] arr){
int temp;
for (int i = 0; i<arr.length; i++){
for (int j = i+1; j>=0; j--){
if (arr[j]<arr[j-1]){
temp = arr[j];
浏览 18提问于2020-12-21得票数 0
有人可以一步一步地解释一下，当我们找到插入排序的最坏情况分析时，我们是如何得到O(N^2)的吗？我目前正在阅读科尔门算法入门一书中对它的解释，但解释有点令人困惑。
浏览 1提问于2014-01-19得票数 0
2回答
如何找到数组中的倒数个数？
、、、、
基本上，我正在尝试用Java编写一个算法来确定数组中乱序的对的数量。所以如果我们取i和j，并且j在数组中的位置比i更高，但是Ai > Aj，那么它把这两个数算作反转。目前，我所拥有的是：
for(int i = 0; i<n-1; i++){
if (A[i] > A[i+1]){
k++;
我知道如何做这样的事情，但我希望运行时是(n+k)，其中n是数组的长度，k是数组中的反转次数。
编辑:这是我实现插入排序的尝试：
int k = 0;
int [] A = {5, 4, 3, 2, 1};
int n = A.length;
for(int i
浏览 0提问于2015-10-14得票数 2
3回答
这些排序算法在实际应用中有什么用处吗？
还是仅仅是n^2复杂度排序算法的一个基本例子？
有人能举个例子说明一下它的用法吗？
浏览 6提问于2016-02-05得票数 2
回答已采纳
1回答
我一直在比较选择和插入排序。据我所知，插入排序作用于倒置计数，而不是依赖于它。但在最坏的情况下，总的反转计数将是最大的，并且在插入排序中，交换的数目将是最大/大于选择排序，因为在选择排序中，总交换总是输入大小'n‘的顺序，并且不大于该顺序，并且它将比插入排序中小得多。
在最坏的情况下，时间复杂度将取决于比较的数量(在选择排序的情况下等于或更少)和交换的数量(在插入排序中更多)。因此，如果交换/写入更快，我可以使用插入排序，但如果与比较相比写入成本较高，则我将使用选择排序。那么，哪种排序算法在最坏的情况下会更好，如果我使用数组作为数据结构，如何决定比较速度更快或复制速度更快。
浏览 0提问于2018-01-03得票数 0
3回答
我很难找到一个好答案。出于某种原因，我认为STL排序应该使用交换来实现，以更好地支持复杂的类型，但是当我最后对代码进行了一点深入研究时，它看起来实际上是在执行二进制副本。有人能确认一下吗？我想二进制拷贝实际上是首选的交换。
附带问题:是否有任何STL算法或容器操作使用交换来实现？(显然是在std::swap之外。)我想知道什么时候为复杂的类型实现我自己的交换是谨慎的。
编辑:我问的原因是你是否有这样的东西：
class MyClass {
vector<int> vec_data;
int a;
int b;
}
vector<MyClass> my_vec
浏览 0提问于2011-11-21得票数 10
回答已采纳
2回答
PHP插入排序函数性能
、、、
我正在学习关于排序的知识，我做了一个插入排序函数()：
<?php
set_time_limit(null);
function insertSort(array &$array)
{
$array_size = count($array);
$tmp = null;
for ($i = 0; $i < $array_size; $i++)
{
$j = $i + 1;
if ($j == $array_size)
{
break;
}
浏览 1提问于2011-04-22得票数 0
2回答
矢量与Deque插入时间
、、、、
我读过不错的实验，特别是比较了在vector和deque容器上调用deque的性能。该实验(实验4)的结果是，deque在这一操作中具有极大的优越性。
我使用我编写的一个简短的排序函数实现了我自己的测试，我应该注意到它与其他成员函数一起使用了[]操作符，并发现了截然不同的结果。例如，插入10万个元素时，vector花费24.88秒，而deque花费374.35秒。
我该怎么解释呢？我想这与我的排序功能有关，但我想要的是细节！
我使用的是g++ 4.6，没有优化。
下面是节目：
#include <iostream>
#include <vector>
#include
浏览 4提问于2014-02-04得票数 0
回答已采纳
我必须回答以下问题:你能想出一个场景，在这个场景中，SelectionSort (就结果的发展而言)比InsertionSort更好吗？
我的想法是，如果你只需要一个非常大的列表中的前10名，你可以在第10步之后结束排序。这是这个问题的有效答案吗？你能想出其他的场景吗？
浏览 0提问于2011-11-06得票数 0
回答已采纳
1回答
问题；
您必须按日期对一系列银行交易进行排序。他们中的大多数人(到目前为止)都井井有条，只有少数人出了问题。
您将在插入排序、选择排序和合并排序之间使用哪种排序算法来利用数组几乎已排序的事实？
我的回答(不确定是否正确)
假设N >= 5，我将从它的avg开始使用合并排序。时间复杂度为O(n * log n)，比插入排序O(n^2)更有效。但是，由于多个事务在相同的日期上，插入排序将是一种很好的稳定排序方法。
在这种情况下哪一种更好？合并还是插入排序？我朝正确的方向走了吗？
浏览 3提问于2016-10-09得票数 0
回答已采纳
通过理解插入排序算法，我编写了这段代码。我的老师说它是冒泡排序，但我的朋友说它是插入的。有没有人可以检查一下并向我简要介绍一下。
#include <stdio.h>
void sort(int n) {
int i, j;
float arr[n], k;
for (i = 0; i <= n - 1; i++) {
printf("Enter the number");
scanf("%f", &arr[i]);
}
for (i = 1; i <= n - 1; i++) {
j
浏览 0提问于2017-08-16得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
即时通信 IM
实时音视频活动推荐
腾讯云开发者
