18.2.2 冒泡排序
“冒泡”是什么意思？湖底有时会冒出一个气泡，气泡刚在湖底时，是很小的，在向上浮的过程中，才一点地慢慢变大。学过高中的物理的人，应该不难解释这一现象。冒泡排序的过程有点类似这个过程，每前进一步，值就大一点。
排序当然有两个方向，一种是从小排到大，一种是从大排到小。大多数教科书里都讲第一种，我们也如此。这样一来，冒泡排序法就改为“沉泡法”了，较大值一点点跑到数组中的末尾。
一般教科书里也会说，冒泡排序法是人们最熟悉，及最直观的排序法，我可不这样认为。或许老外在生活中用的是这种最笨的排序法？我猜想，大家在生活中99%使用后面要讲的“选择”排序法。
冒泡排序是这么一个过程(从小到大):
1、比较相邻的两个元素，如果后面的比前面小，就对调二者。反复比较，到最后两个元素。结果，最大值就跑到了最末位置。
2、反复第一步，直到所有较大值都跑到靠后的位置。
看一眼例子：
2，5，1，4，3
第一遍：
·比较第一对相邻元素：2，5，发现后面的5并不比2小，所以不做处理。序列保持不变：2，5，1，4，3
·继续比较后两对元素：5，1，发现后面的1比前面的5小，所以对调二者。现在，序列变为：2，1，5，4，3
·继续比较后两对元素：5，4……对调，于是：2，1，4，5，3
·继续比较后两对元素：5，3……对调，于是：2，1，4，3，5 <----- OK,现在最大值5跑到最尾处了。
大泡泡“5”浮出来了，但前面的2,1,4,3,还是没有排好，没事，再来一遍，不过，由于最后一个元素肯定是最大值了，所以我们这回只排到倒数第二个即可。
第二遍：
·比较第一对相邻元素：2，1，发现1比2小，所以对调：1,2,4,3,5
·继续比较后两对元素：2，4，不用处理，因为后面的数比较大。序列还是：1,2,4,3,5 ·继续 4，3，对调：1,2,3,4,5。
前面说，5 不用再参加比较了。现在的序列是1，2，3，4，5。接下来，我们再来一遍：
第三遍：
·比较第一对相邻元素：1，2：不用对调。
……等等……
有人说，现在已经是1，2，3，4，5了，完全是排好序了啊，何必再来进行呢？我们确实是看出前面1，2，3也井然有序了，但对于程序来说，它只能明确地知道自己已经排好了两个数：4，5，并不知道的1，2，3凑巧也排好了。所以它必须再排两次，直到确认把3和2都已推到合适的位置上。最后剩一个数是1，因为只有一个数，没得比，所以这才宣告排序结束。
那么到底要排几遍？看一看前面的“第一遍”、“第二遍”的过程你可发现，每进行一遍，可以明确地将一个当前的最大值推到末尾，所以如果排 Count 个数，则应排 Count 遍。当然，最后一遍是空走，因为仅剩一个元素，没得比较。
下面就动手写冒泡排序法的函数。写成函数是因为我们希望这个排序法可处理任意个元素的数组。
//冒泡排序(从小到大)：
//num: 要接受排序的数组
//count : 该数组的元素个数
void bubble(int num[],int count)
{
int tmp;
//要排Count个数，则应排Count遍：
for (int i = 0; i < count; i++)
{
for(int j = 0; j < count - i - 1; j++)
{
//比较相邻的两个数：
if(num[j+1] < num[j])
{
//对调两个数，需要有"第三者"参以
tmp = num[j+1];
num[j+1] = num[j];
num[j] = tmp;
}
}
}
}
注意在内层循环中j的结束值是 count - i - 1。要理解这段代码，明白为什么结束在count - i -1？如果你忘了如何在CB进行代码调试，如果设置断点，如何单步运行，如何观察变量的值，那么你需要“严重”复习前面有关“调试”的章节；如果你一直是高度着每一章的程序到现在，那么你可以继续下面的内容。
排序函数写出一个了，如何调试这个函数？在CB里新建一空白控制台程序，然后在主函数里，让我们写一些代码来调用这个函数，并且观察排序结果。
#include
……
void bubble(int num[],int count)
{
……
}
int main() //我实在有些懒得写main里两个参数，反正它们暂时对我们都没有用，
//反正CB会为你自动生成，所以从此刻起，我不写了,除非有必要。
{
int values[] = {2,5,1,4,3};
int count = sizeof(values[]) / sizeof(values[0]);
bubble(value,sizeof);
}
你要做的工作是单步跟踪上面的代码，看看整个流程是不是像我前面不厌其烦的写的“第一遍第二遍第三遍”所描述的。
完成上面的工作了吗？全部过程下来，只花20分钟应该算是速度快或者不认真的了（天知道你是哪一种？天知道你到底是不是没有完成就来骗我？）。现在让这个程序有点输出。我们加一个小小的函数：
//输出数组的元素值
//num :待输出的数组
//count:元素个数
void printArray(int num[],int count)
for(int i = 0; i < count; i++)
{
count << num[i] << ",";
}
cout << endl;
}
把这个函数加到main()函数头之前，然后我们用它来输出：
int main() //我实在有些懒得写main里两个参数，反正它们暂时对我们都没有用， //反正CB会为你自动生成，所以从此刻起，我不写了,除非有必要。{
int values[] = {2,5,1,4,3};
int count = sizeof(values[]) / sizeof(values[0]);
cout << "排序之前：" << endl;
printArray(values,count);
//冒泡排序：
bubble(value,sizeof);
cout << "排序之后:" << endl;
printArray(values,count);
system("PAUSE");
}
后面要讲的其它排序法也将用这个printArray()来作输出。
冒泡排序是效率最差劲的方法（速度慢），不过若论起不另外占用内存，则它当属第一。在交换元素中使用了一个临时变量（第三者），还有两个循环因子i和j，这些都属于必须品，其它的它一个变量也没多占。
我们现在讲讲如何避免数据其实已经排好，程序仍然空转的的局面。
首先要肯定一点，至少一遍的空转是不可避免的，这包括让人来排，因为你要发现结果已是1，2，3，4，5了，你也是用眼睛从头到尾抄了一遍（如果你视力不好，说不定还要扫两遍呢）。
接下来一点，我们来看看除了第一遍空转，后面的是否可以避免。冒泡排序法的空转意味着什么？因为算法是拿相邻的两个比较，一发现次序不合“从小到大”的目的（小的在大的后头），就进行对调。所以如果这个对调一次也没有进行，那就说明后面的元素必然是已经完全有序了，可以放心地结束。
让我们来加个变量，用于标志刚刚完成的这一遍是否空转，如果是空转，就让代码跳出循环。
//冒泡排序(从小到大，且加了空转判断)：
void bubble(int num[],int count)
{
int tmp;
bool swapped; //有交换吗？
//要排Count个数，则应排Count遍：
for (int i = 0; i < count; i++)
{
//第一遍开始之前，我们都假充本遍可能没有交换（空转）：
swapped = false;
for(int j = 0; j < count - i - 1; j++)
{
//比较相邻的两个数：
if(num[j+1] < num[j]) //后面的数小于前面的数
{
swapped = true; //还是有交换
//对调两个数，需要有"第三者"参以
tmp = num[j+1];
num[j+1] = num[j];
num[j] = tmp;
}
}
if (!swapped)
break;
}
}
加了swapped标志，这个算法也快不了多少，甚至会慢也有可能。冒泡排序还有一些其它的改进的可能，但同样作用不大，并且会让其丧失仅有优点“代码简单直观”。所以我个人认为真有需要使用冒泡排序时，仅用最原汁原味的“泡”就好。必竟，你选择了冒泡算法，就说明你对本次排序的速度并无多高的要求。
对于n个元素，原汁原味的“冒泡排序”算法要做的比较次数是固定的：（n - 1）* n/2 次的比较。
交换次数呢？如果一开始就是排好序的数据，则交换次数为0。
一般情况下为 3 * (n - 1) * n / 4;最惨时（逆序）为3 * (n - 1) * n / 2。
冒完泡以后——情不自禁看一眼窗台罐头瓶里那只胖金鱼——让我们开始中国人最直观的选择排序法吧。对了，补一句，如果你看到有人在说“上推排序”，那么你要知道，“上推排序”是“冒泡排序”的另一种叫法，惟一的区别是：它不会让我们联想到金鱼。
18.2.3 选择排序
本章前头我们讲了“求最值”的算法，包括最大值和最小值。其实，有了求最值的算法，排序不也完成了一半？想像一下桌子上摊开着牌，第一次我们从中换挑出大王放在手上，第二次我们挑出小王，然后是黑桃老K……黑桃Q，如此下去直到小A，手中的牌不也就已经排好次序了？
每次从中选出最大值或最小值，依此排成序，这就是选择排序法的过程描述。
不过，上述的过程有一点不合要求。我们说过手中只能过一张牌。因此，在程序实现时，我们找出一个最大值之后，就要把它放到数组中最末。那数组中最末位置原来的值？当然是把它放到最大值原来所在位置了。
为了再稍稍直观点，我们改为：每次找的是最小值，找出后改为放到数组前头。
//选择排序（从小到大）
void select(int num[], int count)
{
int tmp;
int minIndex; //用于记住最小值的下标
for (int i = 0; i < count; i++)
{
minIndex = i; //每次都假设i所在位置的元素是最小的
for (int j = i + 1; j < count; j++) //j 从i+1开始，i之前的都已排好,而
i是本次的第一个元素
{
if (num[minIndex] < num[j])
minIndex = j;
}
//把当前最小元素和前面第i个元素交换：
if(minIndex != i)
{
tmp = num[i];
num[i] = num[minIndex];
num[minIndex] = tmp;
}
}
}
同样是两层循环，内层循环非常类似于前面讲的求最值的的方法，重要的区别在于求最小值时，可以直接用N记下最小值，而我们这里是记下最小值元素的下标（位置）。最后把这个位
置上的元素值和前面第i个元素交换。这就完成把挑出的最小值放到前面的过程。
关于如何调试，如何输出，和“冒泡”那一节一样。大家一会儿再动手吧。我先在纸上简要模拟一番，这样大家调试起来会更加心中有数。
2，5，1，4，3
第一遍：找出最小值1（下标为2），将它和第一个元素（下标为0）进行交换，结果：1,5,2,4,3 第二遍：找出最小值2（下标为2），将它和第二个元素进行交换，结果：1,2,5,4,3 第三遍：1,2,3,4,5
同样，我们发现现在已经排好了，但程序的循环过程还得继续。只是后面将是白忙活，什么也没变。最后一遍是剩下一个1，没得比较，外层循环结束，选择排序完成。
但是，由于选择排序中内层循环完成的工作仅是找出其中的最小值，如果它空转了，只是意味着这些剩下元素中中的第一个元素正好就是最小值，并不意味剩下的元素已经有序。所以我们也不就费心去加什么空转标志了。
同冒泡排序一样，选择排序的外层循环要进行 n-1次，而内层为 n / 2 次，所以总比较次数为： (n-1) * n / 2。
交换次数最好时为： 3 * (n-1)，最坏时为 n^2 /4 + 3 *(n-1)。
18.2.4 快速排序（选修）
排序的算法还有不少。譬如“插入排序法”和“希尔排序法”。前者有点像我们抓牌，抓到新牌，往手中已有牌的合适位置插入，最终牌都到手时，也排好序。，后者是以它的创造者的名字命名。它们都不是最快的算法。我们不去说它了。还是来说说（一般说来是）号称最快的算法吧。
“最快”是有代价的。一个是其算法复杂，不直观，根本不是人脑所擅长的思维方式，因为它要求使用“递归”，我想就算是爱因斯坦在整理扑克时，估计也不爱用这种算法。
快速排序的基本思想是分割排序对象。先选择一个值，作为“分割值”。将所有大于该值的元素放到数组的一头，而所有小于该值的元素，放到数组的另一头。这样就把数组按这个分割值划为两段。接下来的事情是对这两段分别再进行前述的操作（找分割值，再划两段）……就这样一划二、二划四、四划八进行下去。直到最每一段都只剩一个元素，排序完成。
在分段的过程中，每一个数组又是如何被归到某一段中去呢？采用的也是巧妙的交换方法。
假设我们仍然是要进行“从小到大”的排序，那么当有了一个分割值以后，就应该把比分割值大的数扔到数组后头，而比分割值小的数扔到数组前头。在快速排序法中，这个扔的过程是一种“对扔”。即：先找好前面的有哪个数需要扔到后面；再找好后面有哪个数需要扔到前头。两个数都找好了，就把这两个数互相“扔”过去，其实还是交换两个数。知道的人明白我是在说“快速排序”，不知道的人还当我是在说小布和老萨扔板砖哪？
所以，每一遍的分割过程是：
1、指定一个“分割值”。
2、从当前分段的数组前头开始往后找，找到下一个大于分割值的元素（准备扔到后头去）；
3、从当前分段的数组后头开始往前找，找到下一个小于分割值的元素（准备扔到前头去）；
4、交换2，3步找到两个元素
5、反复执行2，3，4，步；直到两端都已找不到要扔的元素。
这样，就把数组在逻辑上分为两段，前头的所有小于分割值是一段，后头所有大于分割值的是段，程序接下来递归调用快速排序的函数，分别把这两段都再次进行分割。
函数的递归调用也是我们曾经的“选修课”，如果你有些遗忘，可以回头加以复习。
每次的分割值是什么并没有太死的限定，但得在当前段数组元素最小值和最大值（含二者）之间，否则，比如元素是： 5，4，3，而分割值取的是6，就会分不出两段了。我们下面做法比较通用：就取当前段最中间那个元素的值，比如5，4，3中的4。
我们按照书写顺序，把数组前端称为“左端”，后端称为“右”端。下面的代码中,left 和L 用来表示数组前端，而right 和 R 表示后端。
void quick(int arr, int left, int right)
{
int tmp;
int L = left, R = right;
int V; //分割值。
V = arr[ (L + R) / 2]; //分割值取中间那个元素的值。
do
{
//找前端下一个小于分割值的元素：
while (L < right && arr[L] < V)
L++;
//找后端下一个大于分割值的元素：
while (R > left && arr[R] > V)
R++;
if （L > R) //跑出当前段了，结束本段的“互扔”过程
break;
//开始互换，但 L == R 的情况说明是同一个元素，不用交换。 if ( L < R)
{
tmp = arr[L];
arr[L] = arr[R];
arr[R] = tmp;
}
L++；
R--；
}
while (true);
//前面还可以分段，继续划分
//由于前面是在 L > R 情况下break出循环，所以R此时已经比L靠前,所以拿它 //来和是前头的left比较，以确定前面的元素是否超过1个。
if (left < R)
quick(left, R); //递归调用quick()
//后面还可以分段，继续划分
//同理，L此时其实比较靠后。
if (L > right)
quick(L, right); //递归调用quick()
}
快速排序的比较和交换的次数分别为：n * log(n) 和 n * log(n) / 6。远远少于前面的两种排序方法。
各种排序算法的总结和比较 1 快速排序（QuickSort） 快速排序是一个就地排序，分而治之，大规模递归的算法。从本质上来说，它是归并排序的就地版本。快速排序可以由下面四步组成。 （1）如果不多于1个数据，直接返回。 （2）一般选择序列最左边的值作为支点数据。（3）将序列分成2部分，一部分都大于支点数据，另外一部分都小于支点数据。 （4）对两边利用递归排序数列。 快速排序比大部分排序算法都要快。尽管我们可以在某些特殊的情况下写出比快速排序快的算法，但是就通常情况而言，没有比它更快的了。快速排序是递归的，对于内存非常有限的机器来说，它不是一个好的选择。 2 归并排序（MergeSort）
归并排序先分解要排序的序列，从1分成2，2分成4，依次分解，当分解到只有1个一组的时候，就可以排序这些分组，然后依次合并回原来的序列中，这样就可以排序所有数据。合并排序比堆排序稍微快一点，但是需要比堆排序多一倍的内存空间，因为它需要一个额外的数组。 3 堆排序（HeapSort） 堆排序适合于数据量非常大的场合（百万数据）。 堆排序不需要大量的递归或者多维的暂存数组。这对于数据量非常巨大的序列是合适的。比如超过数百万条记录，因为快速排序，归并排序都使用递归来设计算法，在数据量非常大的时候，可能会发生堆栈溢出错误。 堆排序会将所有的数据建成一个堆，最大的数据在堆顶，然后将堆顶数据和序列的最后一个数据交换。接下来再次重建堆，交换数据，依次下去，就可以排序所有的数据。
Shell排序通过将数据分成不同的组，先对每一组进行排序，然后再对所有的元素进行一次插入排序，以减少数据交换和移动的次数。平均效率是O(nlogn)。其中分组的合理性会对算法产生重要的影响。现在多用D.E.Knuth的分组方法。 Shell排序比冒泡排序快5倍，比插入排序大致快2倍。Shell排序比起QuickSort，MergeSort，HeapSort慢很多。但是它相对比较简单，它适合于数据量在5000以下并且速度并不是特别重要的场合。它对于数据量较小的数列重复排序是非常好的。 5 插入排序（InsertSort） 插入排序通过把序列中的值插入一个已经排序好的序列中，直到该序列的结束。插入排序是对冒泡排序的改进。它比冒泡排序快2倍。一般不用在数据大于1000的场合下使用插入排序，或者重复排序超过200数据项的序列。
C语言几种常见的排序方法 2009-04-2219:55 插入排序是这样实现的： 首先新建一个空列表，用于保存已排序的有序数列（我们称之为"有序列表"）。 从原数列中取出一个数，将其插入"有序列表"中，使其仍旧保持有序状态。 重复2号步骤，直至原数列为空。 插入排序的平均时间复杂度为平方级的，效率不高，但是容易实现。它借助了"逐步扩大成果"的思想，使有序列表的长度逐渐增加，直至其长度等于原列表的长度。 冒泡排序 冒泡排序是这样实现的： 首先将所有待排序的数字放入工作列表中。 从列表的第一个数字到倒数第二个数字，逐个检查：若某一位上的数字大于他的下一位，则将它与它的下一位交换。 重复2号步骤，直至再也不能交换。 冒泡排序的平均时间复杂度与插入排序相同，也是平方级的，但也是非常容易实现的算法。 选择排序 选择排序是这样实现的： 设数组内存放了n个待排数字，数组下标从1开始，到n结束。 i=1 从数组的第i个元素开始到第n个元素，寻找最小的元素。 将上一步找到的最小元素和第i位元素交换。 如果i=n－1算法结束，否则回到第3步 选择排序的平均时间复杂度也是O(n²)的。 快速排序 现在开始，我们要接触高效排序算法了。实践证明，快速排序是所有排序算法中最高效的一种。它采用了分治的思想：先保证列表的前半部分都小于后半部分，然后分别对前半部分和后半部分排序，这样整个列表就有序了。这是一种先进的思想，也是它高效的原因。因为在排序算法中，算法的高效与否与列表中数字间的比较次数有直接的关系，而"保证列表的前半部分都小于后半部分"就使得前半部分的任何一个数从此以后都不再跟后半部分的数进行比较了，大大减少了数字间不必要的比较。但查找数据得另当别论了。 堆排序 堆排序与前面的算法都不同，它是这样的： 首先新建一个空列表，作用与插入排序中的"有序列表"相同。 找到数列中最大的数字，将其加在"有序列表"的末尾，并将其从原数列中删除。 重复2号步骤，直至原数列为空。 堆排序的平均时间复杂度为nlogn,效率高（因为有堆这种数据结构以及它奇妙的特征，使得"找到数列中最大的数字"这样的操作只需要O(1)的时间复杂度，维护需要logn的时间复杂度），但是实现相对复杂（可以说是这里7种算法中比较难实现的）。
LabVIEW的基本控件与基本函数 LabVIEW基本控件：数值、布尔、字符串与路径、数组与簇、图形、枚举1、数值：数值输入控件与数值显示控件（数值输入控件有增量/减量按钮；输入为白色背 景，输出为灰色背景） 默认数据类型为：双精度，橙色。 2、布尔：值默认为False，图标为绿色。 布尔控件的机械动作属性 单击时转换：按下按钮时改变状态，再次单击后恢复原状态。与VI是否读取控件无关。（可赋值恢复）类似开关按钮 释放时转换：按下按钮时保持当前状态，直到释放按钮，再次单击后恢复原状态。与VI是否读取控件无关。（可赋值恢复）类似开关按钮 保持转换直到释放：按下按钮时改变状态，直到释放按钮，，再次单击后恢复原状态。与VI 是否读取控件无关。（可赋值恢复）。类似开关按钮 单击时触发：按下按钮时改变状态，LabVIEW再次读取控件值后返回原状态。 释放时触发：：按下按钮时保持当前状态，释放时改变状态，LabVIEW再次读取控件值后返回原状态。 保持触发直到释放：按下按钮时改变状态，直到释放按钮，LabVIEW再次读取控件值后返回原状态。
3、字符串与路径：（字符串输入控件与字符串显示控件），粉色。 4种显示方式（正常显示、’\’代码显示、密码显示、十六进制显示） 4、数组：依据加入的控件类型同样分为输入控件与显示控件 LabVIEW的数组以索引号0表示数组的首个数据。 增加数组维度的方法：（1）索引框的快捷菜单中->增加维度 （2）直接向下拖动索引框 （3)属性对话框->外观选项卡->维 数组中的元素为同类型的控件，可以是各种类型的控件，但不能是数组的数组。数组的多态性： 5、簇：依据加入的控件类型同样分为输入控件与显示控件 簇本身的属性：重新排序簇中控件、自动调整大小（无、调整为匹配大小、水平排列、垂直排列） 使用簇结构时，尽可能的使用：严格自定义类型。 错误簇：状态（布尔）、代码（数值输入）、源（字符串输入）
一、设计思想 插入排序：首先，我们定义我们需要排序的数组，得到数组的长度。如果数组只有一个数字，那么我们直接认为它已经是排好序的，就不需要再进行调整，直接就得到了我们的结果。否则，我们从数组中的第二个元素开始遍历。然后，启动主索引，我们用curr当做我们遍历的主索引，每次主索引的开始，我们都使得要插入的位置（insertIndex）等于-1，即我们认为主索引之前的元素没有比主索引指向的元素值大的元素，那么自然主索引位置的元素不需要挪动位置。然后，开始副索引，副索引遍历所有主索引之前的排好的元素，当发现主索引之前的某个元素比主索引指向的元素的值大时，我们就将要插入的位置（insertIndex）记为第一个比主索引指向元素的位置，跳出副索引；否则，等待副索引自然完成。副索引遍历结束后，我们判断当前要插入的位置（insertIndex）是否等于-1，如果等于-1，说明主索引之前元素的值没有一个比主索引指向的元素的值大，那么主索引位置的元素不要挪动位置，回到主索引，主索引向后走一位，进行下一次主索引的遍历；否则，说明主索引之前insertIndex位置元素的值比主索引指向的元素的值大，那么，我们记录当前主索引指向的元素的值，然后将主索引之前从insertIndex位置开始的所有元素依次向后挪一位，这里注意，要从后向前一位一位挪，否则，会使得数组成为一串相同的数字。最后，将记录下的当前索引指向的元素的值放在要插入的位置（insertIndex）处，进行下一次主索引的遍历。继续上面的工作，最终我们就可以得到我们的排序结果。插入排序的特点在于，我们每次遍历，主索引之前的元素都是已经排好序的，我们找到比主索引指向元素的值大的第一个元素的位置，然后将主索引指向位置的元素插入到该位置，将该位置之后一直到主索引位置的元素依次向后挪动。这样的方法，使得挪动的次数相对较多，如果对于排序数据量较大，挪动成本较高的情况时，这种排序算法显然成本较高，时间复杂度相对较差，是初等通用排序算法中的一种。 选择排序：选择排序相对插入排序，是插入排序的一个优化，优化的前提是我们认为数据是比较大的，挪动数据的代价比数据比较的代价大很多，所以我们选择排序是追求少挪动，以比较次数换取挪动次数。首先，我们定义我们需要排序的数组，得到数组的长度，定义一个结果数组，用来存放排好序的数组，定义一个最小值，定义一个最小值的位置。然后，进入我们的遍历，每次进入遍历的时候我们都使得当前的最小值为9999，即认为每次最小值都是最大的数，用来进行和其他元素比较得到最小值，每次认为最小值的位置都是0，用来重新记录最小值的位置。然后，进入第二层循环，进行数值的比较，如果数组中的某个元素的值比最小值小，那么将当前的最小值设为元素的值，然后记录下来元素的位置，这样，当跳出循环体的时候，我们会得到要排序数组中的最小值，然后将最小值位置的数值设置为9999，即我们得到了最小值之后，就让数组中的这个数成为最大值，然后将结果数组result[]第主索引值位置上的元素赋值为最小值，进行下一次外层循环重复上面的工作。最终我们就得到了排好序的结果数组result[]。选择排序的优势在于，我们挪动元素的次数很少，只是每次对要排序的数组进行整体遍历，找到其中的最小的元素，然后将改元素的值放到一个新的结果数组中去，这样大大减少了挪动的次序，即我们要排序的数组有多少元素，我们就挪动多少次，而因为每次都要对数组的所有元素进行遍历，那么比较的次数就比较多，达到了n2次，所以，我们使用选择排序的前提是，认为挪动元素要比比较元素的成本高出很多的时候。他相对与插入排序，他的比较次数大于插入排序的次数，而挪动次数就很少，元素有多少个，挪动次数就是多少个。 希尔排序：首先，我们定义一个要排序的数组，然后定义一个步长的数组，该步长数组是由一组特定的数字组成的，步长数组具体得到过程我们不去考虑，是由科学家经过很长时间计算得到的，已经根据时间复杂度的要求，得到了最适合希尔排序的一组步长值以及计算
L a b V I E W中的数组操作 函数 Company Document number：WTUT-WT88Y-W8BBGB-BWYTT-19998
LabVIEW中的数组操作函数 现在我们已经了解了中的的一些基本概念（包括了前面这几篇文章、、）。在这篇文章里面我们接着讨论一下如何操作数组了。在的Functions(函数)工具框的Programming>>Array子工具框中有很多操作数组的函数。（我们在使用数组的时候要记住中的数组元素的索引是从0开始的，也就是说它的第一个元素的索引为0，第二个元素的索引为1，以此类推。）我们将在这里讲解常用的数组操作函数，LabVIEW中数组函数的工具框如下图所示： ?初始化数组函数将创建并按照你设定的值来初始化N维数组。通过将光标置于该函数最下方边框，出现拖动光标后向下拖动就可以为该数组增加维数。该函数适用于为已知大小的数组分配内存或者是初始化数组类型数据的。 该函数如下图所示： ?数组大小函数会返回输入数组的元素的个数。如果输入的数组为N维的多维数组，该函数就会返回有N个元素的一维数组，每个元素按顺序对应每维的元素的个数。该函数如下图所示： ? ?创建数组函数（BuildArray）可以根据你的设置来将两个数组连接或合成为一个数组以及为现有数组添加新的元素。当第一次将该函数放到LabVIEW的框图中的时候，该函数可能像下图左侧所示是个非常简单的图标。你可以通过拖动该函数下边框的图标或者是通过在该函数上点击右键从右键菜单中选择AddInput来为该函数增加输入参数的个数，如下图右侧所示。该函数可以有两种类型的输入：数组以及数组元素，该函数可以从数组以及单值的输入来组装一个新的数组。 ? 创建数组函数的输入会根据你连接到输入端点的数据类型自动调整为元素类型或数组类型的输入。在更高级的应用中，该函数还可以创建多维数组或者是为多维数组增加新的数组元素。为多维数组增加元素时，该元素必须是比要增加的数组小一维的数组。例如，为二维数组添加的新元素必须是一个一维数组。也可以将多个一维数组作为元素连接到这个函数的输入端点上来创建一个新的二维数组，每个一维数组就成为这个二维数组的一行。如果你只是将这些一维数组接续为一个新的一维数组的话，就需要在该函数上点击鼠标右键并从右键菜单中选择ConcatenateInputs选项。?子数组函数会按照该函数输入的起始索引以及长度返回输入数组的一部分。该函数如下图所示： ? 在使用这个函数的时候一定要记住LabVIEW中数组的索引是从0开始的，第一个数组元素的索引是0，而不是1。?获取数组元素函数（IndexArray）可以用来访问数组中的某个特定元素。该函数如下图所示。 ? 对于一维数组来说，只要输入要访问的元素的索引就可以在对应的输出得到该元素的值；不过对于二维数组来说，通过输入特定元素的行号、列号就可以访问到该元素的值，如果你想获得某行或某列的全部值，那么在输入端只输入行号或列号即可。 ?删除部分数组函数（DeleteFromArray）可以删除数组中从某一索引号开始某设定长度的部分并返回删除该部分后的数组以及被删除的部分数组。该函数如下图所示：
1.插入排序 算法思想 插入排序使用了两层嵌套循环，逐个处理待排序的记录。每个记录与前面已经排好序的记录序列进行比较，并将其插入到合适的位置。假设数组长度为n，外层循环控制变量i 由1至n-1依次递进，用于选择当前处理哪条记录；里层循环控制变量j，初始值为i，并由i至1递减，与上一记录进行对比，决定将该元素插入到哪一个位置。这里的关键思想是，当处理第i条记录时，前面i-1条记录已经是有序的了。需要注意的是，因为是将当前记录与相邻的上一记录相比较，所以循环控制变量的起始值为1（数组下标），如果为0的话，上一记录为-1，则数组越界。 现在我们考察一下第i条记录的处理情况：假设外层循环递进到第i条记录，设其关键码的值为X，那么此时有可能有两种情况： 1.如果上一记录比X大，那么就交换 它们，直到上一记录的关键码比X 小或者相等为止。 2.如果上一记录比X小或者相等，那 么之前的所有记录一定是有序的， 且都比X小，此时退出里层循环。 外层循环向前递进，处理下一条记 录。 算法实现(C#) public class SortAlgorithm { // 插入排序 public static void InsertSort
for (int i = 1; i <= array.Length - 1; i++) { //Console.Write("{0}: ", i); int j = i; while (j>=1 && https://www.doczj.com/doc/ed10872744.html,pare(array[j], array[j - 1]) < 0) { swap(ref array[j], ref array[j-1]); j--; } //Console.WriteLine(); //AlgorithmHelper.PrintArray(arr ay); } } // 交换数组array中第i个元素和第j个元素 private static void swap
LabVIEW课程设计 报告书 班级 学号 姓名 一、基础题
1、用labview的基本运算函数编写以下算式的程序代码： 首先在前面板创建一个数值输出控件，然后在程序框图中按照上图连接线路，点击运行，程序结果。 2、利用摄氏温度与华氏温度的关系C = 5(F ?32) / 9编写一个程序，求华氏温度 （F）为32, 64, 4, 98.6 , 104, 212时的摄氏温度。
在程序前面板创建一个数值输入控件和一个数值显示控件，在程序框图中添加一个公式节点，添加一个输出和一个输入分别输入和显示控件项链，在公式节点框图中输入温度转换公式，然后在面前扮输入相应的温度点击运行，得到相应的结果。 3、创建一个2行3列的二维数组控制件，为数组成员赋值如下： 00 .600.500.400.300.200.1 在前面板创建一个数组显示控件，然后将1、2、3创建成数组第一行，4、5、6创建成数组第二行，再将两行创建成一个两行三列的二位数组，点击运行显示输 出结果。 4、用数组创建函数创建一个二维数组显示件，成员为：
1 2 3 4 5 6 2 3 4 5 6 1 3 4 5 6 1 2 4 5 6 1 2 3 编程将上述创建的数组转置为： 1 2 3 4 2 3 4 5 3 4 5 6 4 5 6 1 5 6 1 2 6 1 2 3 先在面前板上创建一个上图这样的数组。再创建两个显示数组（一个为显示数组，另一个为转换后数组），在程序框图上面按照下图连线，在原数组和转换后数组之间接一个“二维数组转制”， 点击运行后显示为：
5、创建一个簇控制件，成员分别为字符型控制件姓名，数值型控制件学号，布 尔型控制件注册。从这个簇控制件中提取出簇成员注册，显示在前面板上。 在面板上添加一个簇，在族里分别添加一字符显示控件，数值显示控件，布尔型 显示控件，程序框图连接如图： 先解除捆绑然后再捆绑，输入姓名、学号点击运行在输出簇里显示。 6、创建一个字符串显示件，程序运行后显示当前系统日期、时间和自己的班级、姓名。
C语言中数组排序算法及函数调用 一、冒泡法（起泡法） 算法要求：用起泡法对10个整数按升序排序。 算法分析：如果有n个数，则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较，在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后，经过一趟比较后，将最值沉底（换到最后一个元素位置），最大值沉底为升序，最小值沉底为降序。 算法源代码： # include
几种常见的排序算法之比较 2010-06-20 14:04 数据结构课程 摘要： 排序的基本概念以及其算法的种类，介绍几种常见的排序算法的算法：冒泡排序、选择排序、插入排序、归并排序、快速排序、希尔排序的算法和分析它们各自的复杂度，然后以表格的形式，清晰直观的表现出它们的复杂度的不同。在研究学习了之前几种排序算法的基础上，讨论发现一种新的排序算法，并通过了进一步的探索，找到了新的排序算法较之前几种算法的优势与不足。 关键词：排序算法复杂度创新算法 一、引言 排序算法，是计算机编程中的一个常见问题。在日常的数据处理中，面对纷繁的数据，我们也许有成百上千种要求，因此只有当数据经过恰当的排序后，才能更符合用户的要求。因此，在过去的数十载里，程序员们为我们留下了几种经典的排序算法，他们都是智慧的结晶。本文将带领读者探索这些有趣的排序算法，其中包括介绍排序算法的某些基本概念以及几种常见算法，分析这些算法的时间复杂度，同时在最后将介绍我们独创的一种排序方法，以供读者参考评判。 二、几种常见算法的介绍及复杂度分析 1.基本概念 1.1稳定排序(stable sort)和非稳定排序 稳定排序是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，。反之，就是非稳定的排序。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为 a1,a2,a4,a3,a5， 则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4,a2,a3,a5就不是稳定的了。 1.2内排序( internal sorting )和外排序( external sorting) 在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。
要读取的txt文档为两列，第一列为x坐标，第二列为y坐标，两列之间用制表符隔开，格式如下： -4.000000E+1 8.583130E-6 -3.990000E+1 9.536800E-6 -3.980000E+1 1.001360E-5 -3.970000E+1 1.049050E-5 -3.960000E+1 1.001360E-5 -3.950000E+1 1.096730E-5 -3.940000E+1 1.096730E-5 -3.930000E+1 1.096730E-5 -3.920000E+1 1.096730E-5 -3.910000E+1 1.192100E-5 -3.900000E+1 1.192100E-5 -3.890000E+1 1.096730E-5 -3.880000E+1 1.192100E-5 -3.870000E+1 1.192100E-5 -3.860000E+1 1.192100E-5 -3.850000E+1 1.192100E-5 -3.840000E+1 1.239780E-5 -3.830000E+1 1.192100E-5 -3.820000E+1 1.239780E-5 -3.810000E+1 1.192100E-5 -3.800000E+1 1.239780E-5 -3.790000E+1 1.192100E-5 -3.780000E+1 1.192100E-5 -3.770000E+1 1.144420E-5 -3.760000E+1 1.192100E-5 -3.750000E+1 1.096730E-5 -3.740000E+1 1.192100E-5 -3.730000E+1 1.096730E-5 -3.720000E+1 1.144420E-5 -3.710000E+1 1.096730E-5 -3.700000E+1 1.096730E-5 -3.690000E+1 1.096730E-5 -3.680000E+1 1.096730E-5 读取坐标数据后画图，效果如下： 1.读取直接使用函数：文件I/0——》读取电子表格文件
常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序 一.希尔（Shell）排序法（又称宿小增量排序，是1959年由D.L.Shell提出来的） /* Shell 排序法 */ #include
v[j]=v[j+gap]; v[j+gap]=temp; } } } } 二.二分插入法 /* 二分插入法 */ void HalfInsertSort(int a[], int len) { int i, j,temp; int low, high, mid; for (i=1; i
创建多维数组首先要在一维数组基础上修改维数。修改数组维数通常有以下几种方法。 （1）改变索引框大小来增减维数。将光标移至索引号四周，出现改变大小的箭头，单击鼠标拖动箭头改变索引号框的大小和索引号的个数。索引号的个数就代表数组的维数，如图1所示为拖出了两个索引号，成为二维数组，然后再改变元素区域大小以显示出二维数组。 图1 改变索引号大小以创建二维数组 （2）通过索引号的右键快捷菜单选项“添加维度”来增加数组的维数，通过选项“删除维度”来减少数组的维数，如图2所示。 （3）选择数组的右键快捷菜单选项“属性”，在弹出的属性对话框中改变数组的维数，如图3所示，在对话框“外观〃选项卡左下方的“维”数字框中即可设置维数。
图2 通过索引号的右键快捷菜单选项增减维数
图3 数组属性对话框 在前面板窗口中，可以创建上述输入控件数组，也可以创建显示控件数组。在添加元素时选择添加显示控件即可创建显示控件数组。 在程序框图窗口中可以创建数组常量。在程序框图函数选板中选择“编程－数组→数组常量”置于程序框图窗口中，出现如图4所示数组常量框架。数组常量框架类似于前面板数组框架，包括索引号和元素区域。 创建数组常量的过程与创建输入控件数组类似，设置显示的元素和增减维数的方法也相同。首先在数组常量框架中然后设置数组元素，操作过程如图5 所示。
图4 数组常量框架 图5创建数值型数组常量 首先要说明一下，LabVIEW中其实并没有明确的赋值的概念，他和传统的文本编程语言的思路不一样，是数据流驱动的编程。在一般的文本编程语言里，定义二维数组变量的时候只是开辟了一块内存空间，里面是空的，所以要有赋值的过程；而LabVIEW中内存不需要手动分配，其后台有自动管理内存的机制，出现新的二维数组的时候，不需要变量定义，直接分配内存空间，然后就把数据存进去了。如果硬要说有什么“赋值”的概念的话，LabVIEW中倒是有几种常见的类似于“赋值”的操作。 1.在二维数组控件的前面板里直接填入数值 这个最简单，不用多说想必你也明白，手动填数。 2.创建单一元素的数组 需要用到初始化数组，见下图
个人对这8种排序算法的理解,希望对大家有点帮助. 趁自修时间,自己将这8种排序的代码写了一下....... 1.简单的选择排序 bool selectionsort(int *array,int n) //array为存储数据的数组,n为数组元素个数 { int k,temp; //k用来存储,临时最小数据的位置 for(int i=0;i for(int i=1;i 数据排序的几种方法(c语言实现) /* 功能：用以下几种方法实现c语言中的常用排序 选择排序 冒泡排序 插入排序 快速排序 堆排序 归并排序 基数排序 希尔排序 */ #include <stdio.h> void select_Sort1(int a[],int n); void select_Sort2(int a[],int n); void bubble_Sort(int a[],int n); void insert_Sort(int a[],int n); void quick_Sort(int a[],int low,int high); int findpos(int a[],int low,int high); int main() { int a[10]; int i; printf("please enter ten int number:\n"); for(i=0;i<10;i++) { scanf("%d",&a[i]); } //select_Sort2(a,10); //bubble_Sort(a,10); //insert_Sort(a,10); quick_Sort(a,0,9); printf("after sorted:\n"); for(i=0;i<10;i++) { printf("%5d",a[i]); } return 0; } //===========================第一种方法：选择排序法======================================= //用一种较为容易理解的方法实现选择排序 void select_Sort1(int a[],int n) { int i,j,k; //外部循环从小到大，依次找出各位置上的值（最后一个位置上的值除外，因为在循环的过程中各个位置上的值逐渐确定下来，最后一个值自然就确定了） for(i=0;i<n-1;i++) { //内部循环从外部循环指针的下一个位置开始，将后续位置上取到的值逐渐与外部循环所对应的指针上的值进行比较 for(j=i+1;j<n;j++) { if(a[j]<a[i]) { // 找到比该位置上的值小的值就进行一次交换 k=a[i]; a[i]=a[j]; a[j]=k; } } } } //以下方法实现起来效率更高，之所以效率高是因为找到一个比外循环指针所对应值更小的值时没有马上交换而是把位置先记录下来，内循环结束后再交换 void select_Sort2(int a[],int n) { int i,j,k,t; //外部循环从小到大，依次找出各位置上的值（最后一个位置上的值除外，因为在循环的过程中各个位置上的值逐渐确定下来，最后一个值自然就确定了） for(i=0;i<n-1;i++) { //内部循环从外部循环指针的下一个位置开始，将后续位置上取到的值逐渐与外部循环所对应的指针上的值进行比较 k=i;//k的作用是记录内部指针一趟比较下来，哪个位置所对应的值比外指针所对应的值小，将该位置存放到k中，默认情况下k的值是外指针对应位置 for(j=i+1;j<n;j++) { 数据结构实训报告 实验名称：数据结构 题目：内部排序比较 专业：班级：姓名：学号：实验日期： 一、实验目的：通过随机数据比较各内部排序算法的关键字比较次数和关键字移动的次数，以取得直观感受。训练学生综合设计算法能力。 二、实验要求：待排序长度不小于100，数据可有随机函数产生，用五组不同输入数据做比较，比较的指标为关键字参加比较的次数和关键字移动的次数；对结果做简单的分析，包括各组数据得出结果的解释；设计程序用顺序存储。 三、实验内容 1、待排序表的表长不小于100；至少要用5组不同的输入数据作比较；排序算法不少于3种； 2 、待排序的元素的关键字为整数； 3 、比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换以3次计)。 4、演示程序以人机对话的形式进行。每次测试完毕显示各种比较指标的列表，以便比较各种排序的优劣。 5、最后要对结果作简单的分析。 6、测试数据：用伪随机数产生程序产生。 四、实验编程结果或过程： 1. 数据定义 typedef struct { KeyType key; }RedType; typedef struct { RedType r[MAXSIZE+1]; int length; }SqList; 2. 函数如下，代码详见文件“排序比较.cpp” int Create_Sq(SqList &L) void Bubble_sort(SqList &L)//冒泡排序void InsertSort(SqList &L)//插入排序 void SelectSort(SqList &L) //简单选择排序int Partition(SqList &L,int low,int high) void QSort(SqList &L,int low,int high)//递归形式的快速排序算法 void QuickSort(SqList &L) void ShellInsert(SqList &L,int dk)//希尔排序 void ShellSort(SqList &L,int dlta[ ]) 3. 运行测试结果，运行结果无误，如下图语速个数为20 算法名称：选择排序 算法定义：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。算法类型：不稳定排序 算法时间复杂度：O(n2)--[n的平方] 最少移动次数：0 最多移动次数：3(n-1) 算法适用场景：这个算法时间复杂度偏高，一般不选择使用。 算法代码： void select_sort(int *x, int n) { int i, j, min, t; for (i=0; i 算法定义：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。 算法类型：稳定排序 算法时间复杂度：O(n2)--[n的平方] 算法适用场景：这个算法时间复杂度偏高，一般不选择使用。 算法代码： void insert_sort(int *x, int n) { int i, j, t; for (i=1; i 数据类型：数组、簇和波形 ．１概述 数组是同类型元素的集合。一个数组可以是一维或者多维，如果必要，每维最多可有231－1个元素。可以通过数组索引访问其中的每个元素。索引的范围是0到n – 1，其中n是数组中元素的个数。图３－１所显示的是由数值构成的一维数组。注意第一个元素的索引号为0，第二个是1，依此类推。数组的元素可以是数据、字符串等，但所有元素的数据类型必须一致。 图３－１数组示意图 簇（Cluster）是另一种数据类型，它的元素可以是不同类 型的数据。它类似于C语言中的stuct。使用簇可以把分布在流 程图中各个位置的数据元素组合起来，这样可以减少连线的拥挤 程度。减少子VI的连接端子的数量。 波形（Waveform）可以理解为一种簇的变形，它不能算是一种有普遍意义的数据类型，但非常实用。 ３．２数组的创建及自动索引 ３．２．１创建数组 一般说来，创建一个数组有两件事要做，首先要建一个数组的“壳”（shell），然后在这个壳中置入数组元素（如果需要用一个数组作为程序的数据源，可以选择Functions?Array?Array Constant，将它放置在流程图中。然后再在数组框中放置数值常量、布尔数还是字符串常量。下图显示了在数组框放入字符串常量数组的例子。左边是一个数组壳，中间的图上已经置入了字符串元素，右边的图反映了数组的第０个元素为：”ABC”，后两个元素均为空。 图３－１数组的创建 在前面板中创建数组的方法是，从Controls模板中选择 Array & Cluster，把数组放置在前面板中，然后选择一个对象 （例如数值常量）插入到数组框中。这样就创建了一个数值数组。 也可以直接在前面板中创建数组和相应的控制对象，然它们 各种排序方法复杂度总结归纳 一、冒泡排序 主要思路是： 通过交换相邻的两个数变成小数在前大数在后，这样每次遍历后，最大的数就“沉”到最后面了。重复N次即可以使数组有序。 代码实现 void buadfdsle_sort（int arr[]，int len） { for （int i = 0; i { for （int j = len —1; j >= i; j——） { if （arr[j] { int temp = arr[j]; arr[j] = arr[j —1]; arr[j —1] = temp; } } } } 冒泡排序改进1： 在某次遍历中，如果没有数据交换，说明整个数组已经有序，因 此通过设置标志位来记录此次遍历有无数据交换就可以判断是否要继续循环。 冒泡排序改进2： 记录某次遍历时最后发生数据交换的位置，这个位置之后的数据显然已经有序。因此设置标志位记录每次遍历中最后发生数据交换的位置可以确定下次循环的范围。 二、直接插入排序 主要思路是： 每次将一个待排序的数组元素，插入到前面已排序的序列中这个元素应该在的位置，直到全部数据插入完成。类似扑克牌洗牌过程。 代码实现 void _sort（int arr[]，int len） { for （int i = 1; i { int j = i —1; int k = arr[i]; while （j > —1 && k { arr[j + 1] = arr[j]; j ——; } arr[j + 1] = k; } } 三、直接选择排序 主要思路是： 数组分成有序区和无序区，初始时整个数组都是无序区，每次遍历都从无序区选择一个最小的元素直接放在有序区最后，直到排序完成。 代码实现 void select_sort（int arr[]，int len） { for （int i = 0; i { int index = i; for （int j = i + 1; j { if （arr[j] index = j; } if （index ！= i） { int temp = arr[i]; arr[i] = arr[index]; arr[index] = temp; } } }数据排序的几种方法c语言实现
数据结构内部排序比较分析
数据结构经典七种排序方法
lABVIEW关于数据类型的编辑：数组、簇和波形
各种排序方法复杂度总结归纳
相关主题
文本预览