原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换, 这样一趟过去后,最大或最小的数字被交换到了最后一位, 然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子 例子为从小到大排序, 原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 | 第一趟排序(外循环) 第一次两两比较6 > 2交换(内循环) 交换前状态| 6 | 2 | 4 | 1 | 5 | 9 | 交换后状态| 2 | 6 | 4 | 1 | 5 | 9 | 第二次两两比较,6 > 4交换 交换前状态| 2 | 6 | 4 | 1 | 5 | 9 | 交换后状态| 2 | 4 | 6 | 1 | 5 | 9 | 第三次两两比较,6 > 1交换 交换前状态| 2 | 4 | 6 | 1 | 5 | 9 | 交换后状态| 2 | 4 | 1 | 6 | 5 | 9 | 第四次两两比较,6 > 5交换 交换前状态| 2 | 4 | 1 | 6 | 5 | 9 | 交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 第五次两两比较,6 < 9不交换 交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 第二趟排序(外循环) 第一次两两比较2 < 4不交换 交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 交换后状态| 2 | 4 | 1 | 5 | 6 | 9 | 第二次两两比较,4 > 1交换 交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 交换后状态| 2 | 1 | 4 | 5 | 6 | 9 | 第三次两两比较,4 < 5不交换 交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 交换后状态| 2 | 1 | 4 | 5 | 6 | 9 | 第四次两两比较,5 < 6不交换 交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 交换后状态| 2 | 1 | 4 | 5 | 6 | 9 | 第三趟排序(外循环) 第一次两两比较2 > 1交换 交换后状态| 2 | 1 | 4 | 5 | 6 | 9 | 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 第二次两两比较,2 < 4不交换 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 第三次两两比较,4 < 5不交换 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 第四趟排序(外循环)无交换 第五趟排序(外循环)无交换 排序完毕,输出最终结果1 2 4 5 6 9

选择交换机网段，请注意： 交换机的网段必须从属于所属VPC的网段。 交换机的网络掩码为16~29位。 交换机的网段不能与已有的交换机网段相同或互为子集。 交换机的网段不能与VPC中的路由条目的目标网段相同。 交换机的网段不能包含所属VPC中的路由条目的目标网段，但可以是其子集。 详细信息，请参见创建交换机。

关于swap交换分区的设置：一种流行的、以讹传讹的说法是，安装Linux系统时，交换分区swap的大小应该是内存的两倍。也就是说，如果内存是2G，那么就应该分出4G的硬盘空间作为交换空间。其实这是严重的浪费。真实的情况是：可以根据你系统内存的大小，以及所使用的程序，自行决定交换分区的大小，甚至可以完全不用交换分区！首先解释一下什么是交换分区。交换分区，英文的说法是swap，意思是“交换”、“实物交易”。它的功能就是在内存不够的情况下，操作系统先把内存中暂时不用的数据，存到硬盘的交换空间，腾出内存来让别的程序运行，和Windows的虚拟内存（pagefile.sys）的作用是一样的。做一个假设：如果你的内存足够大，极少出现内存不足的情况，那么你就不需要交换分区。事实上，这种可能性是完全存在的。现在的1G内存的电脑不算什么了。动辄4G内存的电脑也日益普遍。日常使用的话，很少能用完全部的内存。在用不完内存容量的情况下，还要划出它两倍的硬盘空间用于内存交换，这不是浪费吗？可以说，在你内存基本够用的情况下，完全可以不要交换空间。在Windows下也是一样，在系统属性中，把虚拟内存设置为0，系统依然运行的很好。当然，如果你用的是服务器，还是要有专门的虚拟内存，有备无患。但是虚拟内存的大小不一定非要内存的两倍。那么怎么知道你的系统有没有用到交换空间呢？只需要在root用户下，运行下面的命令就可以知道了。free -m在日常应用中，通过上述命令看到交换空间的使用情况为0，那么你就不需要很大的虚拟内存，甚至可以完全不需要另辟硬盘空间作为虚拟内存。那么，万一有一天你需要了呢，难道要重装系统？大可不必，在Linux下虚拟内存不单可以放在单独的交换分区，也可以是一个在正常分区下的交换文件。1 查看swap 空间大小(总计)： # free -m 默认单位为k, -m 单位为M　　 total used free shared buffers cached 　　Mem: 377 180 197 0 19 110 　　-/+ buffers/cache: 50 327 　　Swap: 572 0 5722 查看swap 空间(file(s)/partition(s))： 包括 文件 和 分区 的详细信息　　# swapon -s　　等价于　　# cat /proc/swaps3 添加交换空间　　两种选择：添加一个交换分区或添加一个交换文件。推荐你添加一个交换分区；不过，若你没有多少空闲空间可用，则添加交换文件。3.1 添加一个交换分区　　步骤如下： a 使用fdisk来创建交换分区（假设 /dev/sdb2 是创建的交换分区） b 使用 mkswap 命令来设置交换分区：　　 # mkswap /dev/sdb2 c 启用交换分区：　　 # swapon /dev/sdb2 d 写入/etc/fstab,以便在引导时启用：　　 /dev/sdb2 swap swap defaults 0 03.2 添加一个交换文件　　a 创建大小为512M的交换文件：　　 # dd if=/dev/zero of=/swapfile1 bs=1024k count=512　　b 使用 mkswap 命令来设置交换文件：　　 # mkswap /swapfile1　　c 启用交换分区：　　 # swapon /swapfile1　　d 写入/etc/fstab,以便在引导时启用：　　 /swapfile1 swap swap defaults 0 0　　新添了交换分区并启用它之后，请查看cat /proc/swaps 或 free 命令的输出来确保交换分区已被启用了。4 删除交换空间：　　a 禁用交换分区：　　 # swapoff /dev/sdb2　　b 从 /etc/fstab 中删除项目；　　c 使用fdisk或yast工具删除分区。　　删除交换文件步骤同上。-------------------------------------------------------------------------------- 　　# free -m 　　 total used free shared buffers cached 　　Mem: 377 180 197 0 19 110 　　-/+ buffers/cache: 50 327 　　Swap: 572 0 572Mem 行显示了从系统角度看来内存使用的情况, total是系统可用的内存大小, 数量上等于系统物理内存减去内核保留的内存.buffers和cached是系统用做缓冲的内存. buffers与某个块设备关联, 包含了文件系统元数据, 并且跟踪了块的变化. cache只包含了文件本身.-/+ buffers/cache 行则从用户角度显示内存信息, 可用内存从数量上等于mem行used列值减去buffers和cached内存的大小.因为buffers和cached是操作系统为加快系统运行而设置的, 当用户需要时, 可以只接为用户使用.top 显示系统运行时的各进程动态、实时的状态(cpu、内存)top 中有3个列 VIRT RES SHR, 标示了进程使用的内存情况.VIRT 标识这个进程可以使用的内存总大小, 包括这个进程真实使用的内存, 映射过的文件, 和别的进程共享的内存等.RES 标识这个这个进程真实占用内存的大小.SHR 标识可以和别的进程共享的内存和库大小.vmstat 显示内存的使用情况这些命令都是从/proc/meminfo中读取内存信息.关于/proc/meminfo中各行的含意, 在内核源代码的Documentation/filesystems/proc.txt文件中有叙述系统的真实内存大小可以用 dmesg | grep mM[mM]看到/proc/pid/status显示一个进程的详细状态# cat /proc/5346/status Name: bash State: S (sleeping) SleepAVG: 98% Tgid: 5346 Pid: 5346 PPid: 5343 TracerPid: 0 Uid: 1000 1000 1000 1000 Gid: 104 104 104 104 FDSize: 256 Groups: 6 24 29 44 104 113 1000 1001 VmPeak: 6528 kB VmSize: 6528 kB VmLck: 0 kB VmHWM: 1976 kB VmRSS: 1976 kB VmData: 752 kB VmStk: 84 kB VmExe: 644 kB VmLib: 1788 kB VmPTE: 16 kB Threads: 1 SigQ: 0/4294967295 SigPnd: 0000000000000000 ShdPnd: 0000000000000000 SigBlk: 0000000000000000 SigIgn: 0000000000384004 SigCgt: 000000004b813efb CapInh: 0000000000000000 CapPrm: 0000000000000000 CapEff: 0000000000000000VmSize即为该进程内存总大小, 和top输出中的VIRT一致.

arp是数据链路层的协议，只用二层交换机。二层交换机就是接入交换机，接二层交换机的终端通过mac地址通信，arp协议就是终端必须将广播过来的相邻主机的mac地址ip写入自己的arp表，二层交换机和所接的主机都有一张arp表。 数据包传到数据链路层后再组合成比特流。 传输层及以下是用来传输数据的，网络层的包到到数据链路层组合成帧再组合成字节，到物理层组合成比特流，比特发送给交换机，交换机看掩码是不是该网段的主机，如果是则搜寻arp表，里面是否有该主机，如果有，则发送给该主机，如果没有，则发送一个广播，如果交换机发现掩码不是该网段的，则交换机再向上发送数据给三层交换机。 所以说，接在二层交换机上的主机互相通信是用mac的，用arp广播就是获取mac和ip的，如果该主机的包发送到其他网络中，那么就要经过路由器了， 答案来源网络，供参考，希望能帮助到您

Re阿里云centor6.3的，增加文件型交换分区后，重启系统交换分区没有了 我刚又重新设置了一下，手动创建交换文件，重启后也是没有，不是那个脚 本的问题。 dd if=/dev/zero of=/var/swap_file bs=1024 count=1M mkswap /var/swap_file swapon /var/swap_file vi /etc/fstab /var/swap_file   swap    swap defaults 0 0 这是我手动创建交换文件的命令，重启后交换分区就又没有了。 ------------------------- Re阿里云centor6.3的，增加文件型交换分区后，重启系统交换分区没有了 又仔细排查了一下，系统和脚本没有问题，估计可能是某个服务启动时出现了问题，暂定可能是wdcp服务，因为检查在他启动前还有交换分区，wdcp启动起来后交换分区就没有了。希望对wdcp精通的朋友给些指点。谢谢

一、简单排序算法 　　由于程序比较简单，所以没有加什么注释。所有的程序都给出了完整的运行代码，并在我的VC环境 　　下运行通过。因为没有涉及MFC和WINDOWS的内容，所以在BORLAND C++的平台上应该也不会有什么 　　问题的。在代码的后面给出了运行过程示意，希望对理解有帮助。 1.冒泡法： 　　这是最原始，也是众所周知的最慢的算法了。他的名字的由来因为它的工作看来象是冒泡： 　　#include <iostream> 　　using namespace std; 　　void BubbleSort(int * pData, int Count) 　　{ 　　int iTemp; 　　for (int i=0; i<Count; i++) 　　{ 　　for (int j=Count-1; j>i; j--) 　　{ 　　if (pData[j]<pData[j-1]) 　　{ 　　iTemp = pData[j-1]; 　　pData[j-1] = pData[j]; 　　pData[j] = iTemp; 　　} 　　} 　　} 　　} 　　void main() 　　{ 　　int data[7] = {10,9,8,7,6,5,4}; 　　BubbleSort(data,7); 　　for (int i=0; i<7; i++) 　　{ 　　cout<<data[i]<<" "; 　　} 　　cout<<endl; 　　system("PAUSE"); 　　} 　　倒序(最糟情况) 　　第一轮：10，9，8，7->10，9，7，8->10，7，9，8->7，10，9，8(交换3次) 　　第二轮：7，10，9，8->7，10，8，9->7，8，10，9(交换2次) 　　第一轮：7，8，10，9->7，8，9，10(交换1次) 　　循环次数：6次 　　交换次数：6次 　　其他： 　　第一轮：8，10，7，9->8，10，7，9->8，7，10，9->7，8，10，9(交换2次) 　　第二轮：7，8，10，9->7，8，10，9->7，8，10，9(交换0次) 　　第一轮：7，8，10，9->7，8，9，10(交换1次) 　　循环次数：6次 　　交换次数：3次 　　上面我们给出了程序段，现在我们分析它：这里，影响我们算法性能的主要部分是循环和交换， 　　显然，次数越多，性能就越差。从上面的程序我们可以看出循环的次数是固定的，为1+2+...+n-1。 　　写成公式就是1/2*(n-1)*n。 　　现在注意，我们给出O方法的定义： 　　若存在一常量K和起点n0，使当n>=n0时，有f(n)<=K*g(n)，则f(n) = O(g(n))。（呵呵，不要说没学好数学呀，对于编程数学是非常重要的。。。） 　　现在我们来看1/2*(n-1)*n，当K=1/2，n0=1，g(n)=n*n时，1/2*(n-1)*n<=1/2*n*n=K*g(n)。所以f(n) 　　=O(g(n))=O(n*n)。所以我们程序循环的复杂度为O(n*n)。 　　再看交换。从程序后面所跟的表可以看到，两种情况的循环相同，交换不同。其实交换本身同数据源的 　　有序程度有极大的关系，当数据处于倒序的情况时，交换次数同循环一样（每次循环判断都会交换）， 　　复杂度为O(n*n)。当数据为正序，将不会有交换。复杂度为O(0)。乱序时处于中间状态。正是由于这样的 　　原因，我们通常都是通过循环次数来对比算法。 2.交换法： 　　交换法的程序最清晰简单，每次用当前的元素一一的同其后的元素比较并交换。 　　#include <iostream.h> 　　void ExchangeSort(int* pData，int Count) 　　{ 　　int iTemp; 　　for(int i=0;i<Count-1;i++) 　　{ //共（count-1)轮，每轮得到一个最小值 　　for(int j=i+1;j<Count;j++) 　　{ //每次从剩下的数字中寻找最小值，于当前最小值相比，如果小则交换 　　if(pData[j]9，10，8，7->8，10，9，7->7，10，9，8(交换3次) 　　第二轮：7，10，9，8->7，9，10，8->7，8，10，9(交换2次) 　　第一轮：7，8，10，9->7，8，9，10(交换1次) 　　循环次数：6次 　　交换次数：6次 　　其他： 　　第一轮：8，10，7，9->8，10，7，9->7，10，8，9->7，10，8，9(交换1次) 　　第二轮：7，10，8，9->7，8，10，9->7，8，10，9(交换1次) 　　第一轮：7，8，10，9->7，8，9，10(交换1次) 　　循环次数：6次 　　交换次数：3次 　　从运行的表格来看，交换几乎和冒泡一样糟。事实确实如此。循环次数和冒泡一样 　　也是1/2*(n-1)*n，所以算法的复杂度仍然是O(n*n)。由于我们无法给出所有的情况，所以 　　只能直接告诉大家他们在交换上面也是一样的糟糕（在某些情况下稍好，在某些情况下稍差）。 3.选择法： 　　现在我们终于可以看到一点希望：选择法，这种方法提高了一点性能（某些情况下） 　　这种方法类似我们人为的排序习惯：从数据中选择最小的同第一个值交换，在从省下的部分中 　　选择最小的与第二个交换，这样往复下去。 　　#include <iostream.h> 　　void SelectSort(int* pData，int Count) 　　{ 　　int iTemp; 　　int iPos; 　　for(int i=0;i<Count-1;i++) 　　{ 　　iTemp = pData; 　　iPos = i; 　　for(int j=i+1;j<Count;j++) 　　{ 　　if(pData[j]<iTemp) 　　{ 　　iTemp = pData[j]; 　　iPos = j; 　　} 　　} 　　pData[iPos] = pData; 　　pData = iTemp; 　　} 　　} 　　void main() 　　{ 　　int data[] = {10，9，8，7，6，5，4}; 　　SelectSort(data，7); 　　for (int i=0;i<7;i++) 　　cout<<data<<" "; 　　cout<<"\n"; 　　} 　　倒序(最糟情况) 　　第一轮：10，9，8，7->(iTemp=9)10，9，8，7->(iTemp=8)10，9，8，7->(iTemp=7)7，9，8，10(交换1次) 　　第二轮：7，9，8，10->7，9，8，10(iTemp=8)->(iTemp=8)7，8，9，10(交换1次) 　　第一轮：7，8，9，10->(iTemp=9)7，8，9，10(交换0次) 　　循环次数：6次 　　交换次数：2次 　　其他： 　　第一轮：8，10，7，9->(iTemp=8)8，10，7，9->(iTemp=7)8，10，7，9->(iTemp=7)7，10，8，9(交换1次) 　　第二轮：7，10，8，9->(iTemp=8)7，10，8，9->(iTemp=8)7，8，10，9(交换1次) 　　第一轮：7，8，10，9->(iTemp=9)7，8，9，10(交换1次) 　　循环次数：6次 　　交换次数：3次 　　遗憾的是算法需要的循环次数依然是1/2*(n-1)*n。所以算法复杂度为O(n*n)。 　　我们来看他的交换。由于每次外层循环只产生一次交换（只有一个最小值）。所以f(n)<=n 　　所以我们有f(n)=O(n)。所以，在数据较乱的时候，可以减少一定的交换次数。 4.插入法： 　　插入法较为复杂，它的基本工作原理是抽出牌，在前面的牌中寻找相应的位置插入，然后继续下一张 　　#include <iostream.h> 　　void InsertSort(int* pData，int Count) 　　{ 　　int iTemp; 　　int iPos; 　　for(int i=1;i<Count;i++) 　　{ 　　iTemp = pData[i]; //保存要插入的数 　　iPos = i-1; //被插入的数组数字个数 　　while((iPos>=0) && (iTemp9，10，8，7(交换1次)(循环1次) 　　第二轮：9，10，8，7->8，9，10，7(交换1次)(循环2次) 　　第一轮：8，9，10，7->7，8，9，10(交换1次)(循环3次) 　　循环次数：6次 　　交换次数：3次 　　其他： 　　第一轮：8，10，7，9->8，10，7，9(交换0次)(循环1次) 　　第二轮：8，10，7，9->7，8，10，9(交换1次)(循环2次) 　　第一轮：7，8，10，9->7，8，9，10(交换1次)(循环1次) 　　循环次数：4次 　　交换次数：2次 　　上面结尾的行为分析事实上造成了一种假象，让我们认为这种算法是简单算法中最好的，其实不是， 　　因为其循环次数虽然并不固定，我们仍可以使用O方法。从上面的结果可以看出，循环的次数f(n)<= 　　1/2*n*(n-1)<=1/2*n*n。所以其复杂度仍为O(n*n)（这里说明一下，其实如果不是为了展示这些简单 　　排序的不同，交换次数仍然可以这样推导）。现在看交换，从外观上看，交换次数是O(n)（推导类似 　　选择法），但我们每次要进行与内层循环相同次数的‘=’操作。正常的一次交换我们需要三次‘=’ 　　而这里显然多了一些，所以我们浪费了时间。 　　最终，我个人认为，在简单排序算法中，选择法是最好的。 二、高级排序算法 　　高级排序算法中我们将只介绍这一种，同时也是目前我所知道（我看过的资料中）的最快的。 　　它的工作看起来仍然象一个二叉树。首先我们选择一个中间值middle程序中我们使用数组中间值，然后 　　把比它小的放在左边，大的放在右边（具体的实现是从两边找，找到一对后交换）。然后对两边分别使 　　用这个过程（最容易的方法——递归）。 　　1.快速排序： 　　#include <iostream.h> 　　void run(int* pData，int left，int right) 　　{ 　　int i，j; 　　int middle，iTemp; 　　i = left; 　　j = right; 　　middle = pData[left]; 　　do{ 　　while((pData[i]<middle) && (i<right))//从左扫描大于中值的数 　　i++;　 　　while((pData[j]>middle) && (j>left))//从右扫描大于中值的数 　　j--; 　　if(i<=j)//找到了一对值 　　{ 　　//交换 　　iTemp = pData[i]; 　　pData[i] = pData[j]; 　　pData[j] = iTemp; 　　i++; 　　j--; 　　} 　　}while(i<=j);//如果两边扫描的下标交错，就停止（完成一次） 　　//当左边部分有值(left<j)，递归左半边 　　if(left<j) 　　run(pData，left，j); 　　//当右边部分有值(right>i)，递归右半边 　　if(right>i) 　　run(pData，i，right); 　　} 　　void QuickSort(int* pData，int Count) 　　{ 　　run(pData，0，Count-1); 　　} 　　void main() 　　{ 　　int data[] = {10，9，8，7，6，5，4}; 　　QuickSort(data，7); 　　for (int i=0;i<7;i++) 　　cout<<data<<" "; 　　cout<<"\n"; 　　} 　　这里我没有给出行为的分析，因为这个很简单，我们直接来分析算法：首先我们考虑最理想的情况 　　1.数组的大小是2的幂，这样分下去始终可以被2整除。假设为2的k次方，即k=log2(n)。 　　2.每次我们选择的值刚好是中间值，这样，数组才可以被等分。 　　第一层递归，循环n次，第二层循环2*(n/2)...... 　　所以共有n+2(n/2)+4(n/4)+...+n*(n/n) = n+n+n+...+n=k*n=log2(n)*n 　　所以算法复杂度为O(log2(n)*n) 　　其他的情况只会比这种情况差，最差的情况是每次选择到的middle都是最小值或最大值，那么他将变 　　成交换法（由于使用了递归，情况更糟）。但是你认为这种情况发生的几率有多大。。呵呵，你完全 　　不必担心这个问题。实践证明，大多数的情况，快速排序总是最好的。 　　如果你担心这个问题，你可以使用堆排序，这是一种稳定的O(log2(n)*n)算法，但是通常情况下速度要慢

# -*- coding: UTF-8 -*- # Filename : test.py # author by : www.runoob.com # 用户输入 x = input('输入 x 值: ') y = input('输入 y 值: ') # 创建临时变量，并交换 temp = x x = y y = temp print('交换后 x 的值为: {}'.format(x)) print('交换后 y 的值为: {}'.format(y)) 执行以上代码输出结果为： 输入 x 值: 2 输入 y 值: 3 交换后 x 的值为: 3 交换后 y 的值为: 2 以上实例中，我们创建了临时变量 temp ，并将 x 的值存储在 temp 变量中，接着将 y 值赋给 x，最后将 temp 赋值给 y 变量。 不使用临时变量 我们也可以不创建临时变量，用一个非常优雅的方式来交换变量： x,y = y,x 所以以上实例就可以修改为： 实例 # -*- coding: UTF-8 -*- # Filename : test.py # author by : www.runoob.com # 用户输入 x = input('输入 x 值: ') y = input('输入 y 值: ') # 不使用临时变量 x,y = y,x print('交换后 x 的值为: {}'.format(x)) print('交换后 y 的值为: {}'.format(y)) 执行以上代码输出结果为： 输入 x 值: 1 输入 y 值: 2 交换后 x 的值为: 2 交换后 y 的值为: 1

冒泡排序每一趟排序把最大的放在最右边。 比如： 87 12 56 45 78 87和12交换：12 87 56 45 78 87和56交换： 56 87 45 78 87和45交换： 45 87 78 87和78交换： 78 87 到此第一趟排序结束，接下来的每一趟排序都是这样。

选择排序的基本思想是：每一趟在n-i+1（i=1，2，…n-1）个记录中选取关键字最小的记录作为有序序列中第i个记录。基于此思想的算法主要有简单选择排序、树型选择排序和堆排序。简单选择排序的基本思想：第1趟，在待排序记录r[1]~r[n]中选出最小的记录，将它与r[1]交换；第2趟，在待排序记录r[2]~r[n]中选出最小的记录，将它与r[2]交换；以此类推，第i趟在待排序记录r[i]~r[n]中选出最小的记录，将它与r[i]交换，使有序序列不断增长直到全部排序完毕。以下为简单选择排序的存储状态，其中大括号内为无序区，大括号外为有序序列：初始序列：{ 49 27 65 97 76 12 38 }第1趟：12与49交换：12 { 27 65 97 76 49 38 }第2趟：27不动　：12 27 { 65 97 76 49 38 }第3趟：65与38交换：12 27 38 { 97 76 65 49}第4趟：97与49交换：12 27 38 49 { 97 76 65 }第5趟：76与65交换：12 27 38 49 65 { 97 76 }第6趟：97与76交换：12 27 38 49 65 76 97 完成简单选择排序的算法具体描述如下：void SelectSort(RecordType r[], int length)　/*对记录数组r做简单选择排序，length为待排序记录的个数*/{int temp;for ( i=0 ; i< length-1 ; i++) //n-1趟排序{int index=i；　//假设index处对应的数组元素是最小的for ( j=i+1 ; j < length ; j++) 　//查找最小记录的位置if (r[j].key < r[index].key )index=j；if ( index!=i) 　//若无序区第一个元素不是无序区中最小元素，则进行交换{ temp= r[i]； r[i]= r[index]； r[index]=temp; }　//利用temp作为临时空间，两个值交换的桥梁}}

当然是稳定的好。。 稳定意思是说原本键值一样的元素排序后相对位置不变 学习的时候，可能编的程序里面要排序的元素都是简单类型，实际上真正使用的时候，可能是对一个复杂类型的数组排序，而排序的键实际上只是这个元素中的一个属性，对于一个简单类型，数字值就是其全部意义，即使交换了也看不出什么不同。。。但是对于复杂的类型，交换的话可能就会使原本不应该交换的元素交换了。。 比如，一个“学生”数组，按照年龄排序，“学生”这个对象不仅含有“年龄”，还有其他很多属性，稳定的排序会保证比较时，如果两个学生年龄相同，一定不交换。

当然是稳定的好。。 稳定意思是说原本键值一样的元素排序后相对位置不变 学习的时候，可能编的程序里面要排序的元素都是简单类型，实际上真正使用的时候，可能是对一个复杂类型的数组排序，而排序的键实际上只是这个元素中的一个属性，对于一个简单类型，数字值就是其全部意义，即使交换了也看不出什么不同。。。但是对于复杂的类型，交换的话可能就会使原本不应该交换的元素交换了。。 比如，一个“学生”数组，按照年龄排序，“学生”这个对象不仅含有“年龄”，还有其他很多属性，稳定的排序会保证比较时，如果两个学生年龄相同，一定不交换。

详细解答可以参考官方帮助文档默认情况下，VPC内的不同交换机下的ECS实例可以通过系统路由相互访问。您可以通过配置安全组规则，使其互相隔离。 本操作以网段为172.16.0.0/12的VPC为例，在该VPC下有三个交换机分别为VS1（172.16.1.0/24）、VS2（172.16.2.0/24）和VS3（172.16.3.0/24）。 每个交换机下分别创建一个云服务器ECS实例，如下图所示。这三个ECS实例都加入了默认安全组2内，出方向允许所有访问，入方向只开放TCP协议的22和3389端口，以及ICMP协议所有端口。 默认情况下，这三个ECS实例可以私网互通。您可以通过将这三个ECS实例加入到不同的安全组内实现VPC内私网隔离。 操作步骤 登录云服务器ECS管理控制台。 在左侧导航栏，单击网络和安全 > 安全组，然后单击创建安全组。 在创建安全组对话框，输入安全组名称，网络类型选择专有网络，然后指定ECS实例所在的专有网络。单击确定。 单击立即设置规则，分别添加如下三条入方向授权规则： 规则1：开放ICMP协议所有端口。优先级可以设置100。数字越大，优先级越低。 规则2：拒绝全部来自交换机2（网段为172.16.2.0/24）的访问，优先级设为1。 规则3：拒绝全部来自交换机3（网段为172.16.3.0/24）的访问，优先级设为1。 在ECS实例列表页面，找到位于交换机1（网段为172.16.1.0/24）中的ECS实例，然后单击实例ID链接，进入详情页面。 在左侧导航栏，单击本实例安全组。 该实例目前只关联了一个VPC内的默认安全组。 单击加入安全组，然后在ECS实例加入安全组对话框中选择刚创建的安全组S1，单击确定。 单击默认安全组对应的移出，将该ECS实例从默认安全组中移出。 此时其它两个ECS实例（交换机1和交换机2中的ECS实例）已经无法通过私网访问这个ECS实例了。 重复上述步骤为另外两个交换机下的ECS实例分别创建两个安全组，然后将它们从默认安全组内移出，使三个交换机内的ECS实例两两不能互访。

详细解答可以参考官方帮助文档默认情况下，VPC内的不同交换机下的ECS实例可以通过系统路由相互访问。您可以通过配置安全组规则，使其互相隔离。 本操作以网段为172.16.0.0/12的VPC为例，在该VPC下有三个交换机分别为VS1（172.16.1.0/24）、VS2（172.16.2.0/24）和VS3（172.16.3.0/24）。 每个交换机下分别创建一个云服务器ECS实例，如下图所示。这三个ECS实例都加入了默认安全组2内，出方向允许所有访问，入方向只开放TCP协议的22和3389端口，以及ICMP协议所有端口。 默认情况下，这三个ECS实例可以私网互通。您可以通过将这三个ECS实例加入到不同的安全组内实现VPC内私网隔离。 操作步骤 登录云服务器ECS管理控制台。 在左侧导航栏，单击网络和安全 > 安全组，然后单击创建安全组。 在创建安全组对话框，输入安全组名称，网络类型选择专有网络，然后指定ECS实例所在的专有网络。单击确定。 单击立即设置规则，分别添加如下三条入方向授权规则： 规则1：开放ICMP协议所有端口。优先级可以设置100。数字越大，优先级越低。 规则2：拒绝全部来自交换机2（网段为172.16.2.0/24）的访问，优先级设为1。 规则3：拒绝全部来自交换机3（网段为172.16.3.0/24）的访问，优先级设为1。 在ECS实例列表页面，找到位于交换机1（网段为172.16.1.0/24）中的ECS实例，然后单击实例ID链接，进入详情页面。 在左侧导航栏，单击本实例安全组。 该实例目前只关联了一个VPC内的默认安全组。 单击加入安全组，然后在ECS实例加入安全组对话框中选择刚创建的安全组S1，单击确定。 单击默认安全组对应的移出，将该ECS实例从默认安全组中移出。 此时其它两个ECS实例（交换机1和交换机2中的ECS实例）已经无法通过私网访问这个ECS实例了。 重复上述步骤为另外两个交换机下的ECS实例分别创建两个安全组，然后将它们从默认安全组内移出，使三个交换机内的ECS实例两两不能互访。

冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较，交换也发生在这两个元素之间。所以，如果两个元素相等，我想你是不会再无聊地把他们俩交换一下的；如果两个相等的元素没有相邻，那么即使通过前面的两两交换把两个相邻起来，这时候也不会交换，所以相同元素的前后顺序并没有改变，所以冒泡排序是一种稳定排序算法。