VB NET实现选择排序与冒泡排序
Public Class Form1 Dim arr(5) As Integer Dim a(5, 5) As TextBox Private Sub delaytime() Dim i, j As Long For i = 1 To 20000 For j = 1 To 20000 i = i + 1 i = i - 1 Next j Next i End Sub Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load Label1.Text = "数oy组á¨|元a素?值|ì:êo" Label2.Text = "第ì¨2一°?轮?:êo" Label3.Text = "第ì¨2二t轮?:êo" Label4.Text = "第ì¨2三¨y轮?:êo" Label5.Text = "第ì¨2四?轮?:êo" Label6.Text = "第ì¨2五?轮?:êo" Button1.Text = "产¨2生|¨2数oy组á¨|" Button2.Text = "选?择?法¤?§演Y示o?" Button3.Text = "冒??泡Y法¤?§演Y示o?" Button4.Text = "重?新?开a始o?" Button5.Text = "退a?出?" Dim i, j As Integer Dim leftlen, toplen As Integer leftlen = 120 : toplen = 32 Randomize() For i = 0 To 5 For j = 0 To 5 a(i, j) = New TextBox a(i, j).Width = 30 : a(i, j).Height = 30 a(i, j).Left = leftlen + j * 40 : a(i, j).Top = toplen + i * 32 a(i, j).Parent = Me : a(i, j).Visible = True Next j Next i End Sub Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click Dim i, j As Integer For i = 0 To 5 arr(i) = Int(10 + 89 * Rnd()) + 1 a(0, i).Text = arr(i) Next i End Sub Private Sub Button2_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button2.Click Dim i, j As Integer Dim min, min_i As Integer Dim t As Integer For i = 0 To 5 - 1 min = arr(i) : min_i = i For j = i + 1 To 5 If min > arr(j) Then
c语言程序设计(排序算法)
《高级语言程序设计》 课程设计报告 题目: 排序算法 专业: 班级: 姓名: 指导教师: 成绩: 计算机与信息工程系 2015年3月26日 2014-2015学年 第2学期
目录 引言 (1) 需求分析 (1) 第一章程序内容及要求 (1) 1.1 冒泡排序 (1) 1.2 选择排序 (2) 1.3 插入排序 (3) 第二章概要设计 (4) 2.1冒泡排序 (4) 2.2选择排序 (5) 2.3插入排序 (6) 第三章程序的比较及其应用 (7) 3.1时间复杂度 (7) 3.2空间复杂度 (7) 3.3稳定程度 (7) 3.4应用及其改进 (8) 第四章程序设计结果 (8) 附录 (9) 参考文献 (12)
引言 伴随着社会的发展,数据也变得越来越庞大。如何将庞大的数据进行很好的排序,使用户更加方便的查找资料,成了一件越来越重要的问题。对于程序员来说,这将是一个挑战。 经常查找资料的朋友都会知道,面对海量的资料,如果其查找资料没有进行排序,那么其查找资料将会是一家非常痛苦的事情。针对这一问题,我们自此通过一个课程设计来解决它。 理论上排序算法有很多种,不过本课程设计只涉及到三种算法。这三种算法包括:冒泡排序,选择排序,直接插入排序。 本课程设计通过对这三种算法的运行情况进行对比,选择最优秀的算法出来。希望通过我的努力能解决一些问题,带来一些方便。 需求分析 本课程题目是排序算法的实现,由于各方面的原因,本科程设计一共需要设计三种排序算法。这三种算法包括:冒泡排序,选择排序,直接插入排序。三种排序算法各有独到之处,因此我们要通过各种调试分析来比较其优劣长短。 由于使用的调试软件及操作系统不一样。因此个别程序在不同的软件上可能会报错。 本课程软件运行的的操作系统为Windows7 64位操作系统。所使用的软件为Microsoft Visual C++6.0以及Turbo C2.0 第一章程序内容及要求 1.1 冒泡排序 冒泡排序(Bubble Sort,台湾译为:泡沫排序或气泡排序)是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端,故名。
冒泡排序 交换排序
选择排序和冒泡排序都是基于元素交换的,因此你的分类错误 冒泡排序基本思想:每次将最重的一个沉入海底 选择排序基本思想:每次扫描最重的一个与第一个交换 并且,选择和冒泡的时间复杂度是一样的(都是O(N^2)) 应用交换排序基本思想的主要排序方法有:冒泡排序(Bubble sort)和快速排序(Quick sort)。交换排序 所谓交换,就是根据序列中两个记录键值的比较结果来对换这两个记录在序列中的位置,交换排序的特点是:将键值较大的记录向序列的尾部移动,键值较小的记录向序列的前部移动。下面是java语言实现一个交换排序的函数: public class BubbleSort { public static int[] BubbleSort(int[] array){ for(int i = 0; i < array.length - 1; i++){ for(int j = 0; j < array.length - 1 - i; j++){ // 内部循环的边界要比长度小一 if(array[j] > array[j + 1]){ //相邻的两个元素比较,将大的放到最右边 int temp = array[j]; array[j] = array[j + 1]; array[j + 1] = temp; } } } return array; } public static void main(String[] args) { int[] array = { 25, 36, 21, 45, 98, 13}; System.out.println(Arrays.toString(array)); BubbleSort.bubbleSort(array);// 调用快速排序的方法 System.out.println(Arrays.toString(array));// 打印排序后的数组元素 }
C (++)内部排序汇总(快速排序&冒泡排序&堆排序&选择排序&插入排序&归并排序)
#include #include #include #include #define M 30001 random(int a[30001]) { int i; for(i=1;i<30001;i++) a[i]=rand()%30001; }//随机生成30000个数函数 int change1(char a[81]) { int b=0,n,i; for(i=0;a[i]!=0;i++); n=i-1; for(;i>1;i--) b+=((int)pow(10,n+1-i))*(a[i-1]-48); if(a[0]=='-') b=b*(-1); else b+=((int)pow(10,n))*(a[0]-48); return b; }//字符转化成整型 insort(int a[30001]) { int i,j,temp,temp1,n; int count=0; n=30001; for(i=1;i=0;j--)/* 每次循环完毕数组的0到i-1项为一个有序的序列*/ { count=0;/*这里count是标记位,可以减少比较次数*/ if(a[j]>temp) { temp1=a[j+1]; a[j+1]=a[j]; a[j]=temp1;
count++; }//满足条件,前移 if(count==0) break;//位置恰当,退出 } } }//insort插入排序函数 selsort(int a[30001]) { int i,j,temp; for(i=1;i<30000;i++) for(j=i+1;j<30001;j++) if(a[i]>a[j]) { temp=a[j]; a[j]=a[i]; a[i]=temp; } }//选择排序 bubsort(int a[30001]) { int i,j,temp; for(i=1;i<30001;i++) for(j=30000;j>i;j--) { if(a[j-1]>a[j]) { temp=a[j-1]; a[j-1]=a[j]; a[j]=temp; } } }//冒泡排序 int partition(int a[30001],int low,int high)
C语言冒泡排序及流程图(思路解析)
1、功能:冒泡排序 输入:数组名称(也就是数组首地址)、数组中元素个数 ================================================ */ /* ==================================================== 算法思想简单描述: 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上 而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较 小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要 求相反时,就将它们互换。 下面是一种改进的冒泡算法,它记录了每一遍扫描后最后下沉数的 位置k,这样可以减少外层循环扫描的次数。 冒泡排序是稳定的。算法时间复杂度O(n2)--[n的平方] ===================================================== */ void bubble_sort(int *x, int n) { int j, k, h, t; for (h=n-1; h>0; h=k) /*循环到没有比较范围*/ { for (j=0, k=0; j *(x+j+1)) /*大的放在后面,小的放到前面*/ { t = *(x+j); *(x+j) = *(x+j+1); *(x+j+1) = t; /*完成交换*/ k = j; /*保存最后下沉的位置。这样k后面的都是排序排好了的。*/ } } } } 2 在要排序的一组数中,对当前还未排好序的范围内的全部数,自上 而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较
基础排序总结(冒泡排序、选择排序)
1、冒泡排序 1.1、简介与原理 冒泡排序算法运行起来非常慢,但在概念上它是排序算法中最简单的,因此冒泡排序算法在刚开始研究排序技术时是一个非常好的算法。 冒泡排序原理即:从数组下标为0的位置开始,比较下标位置为0和1的数据,如果0号位置的大,则交换位置,如果1号位置大,则什么也不做,然后右移一个位置,比较1号和2号的数据,和刚才的一样,如果1号的大,则交换位置,以此类推直至最后一个位置结束,到此数组中最大的元素就被排到了最后,之后再根据之前的步骤开始排前面的数据,直至全部数据都排序完成。 1.2、代码实现 public class ArraySort { public static void main(String[] args) { int[] array = {1, 7, 3, 9, 8, 5, 4, 6}; array = sort(array); for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } } public static int[] sort(int[] array) { for (int i = 1; i < array.length; i++) { for (int j = 0; j < array.length-i; j++) { if (array[j] > array[j+1]) { int temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } return array; } } 1.3、效率
c语言冒泡法详解
最简单的排序方法是冒泡排序方法。 这种方法的基本思想是,将待排序的元素看作是竖着排列的“气泡”,较小的元素比较轻,从而要往上浮。在冒泡排序算法中我们要对这个“气泡”序列处理若干遍。所谓一遍处理,就是自底向上检查一遍这个序列,并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对,即“轻”的元素在下面,就交换它们的位置。显然,处理一遍之后,“最轻”的元素就浮到了最高位置;处理二遍之后,“次轻”的元素就浮到了次高位置。在作第二遍处理时,由于最高位置上的元素已是“最轻”元素,所以不必检查。一般地,第i 遍处理时,不必检查第i高位置以上的元素,因为经过前面i-1遍的处理,它们已正确地排好序。 void doit(float* in,int count) { int x; int y; float temp; for(y=0;y(*(in+x-1))) { temp=(*(in+x-1)); (*(in+x-1))=(*(in+x)); (*(in+x))=temp; } } } } 冒泡排序的算法分析与改进 交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。 应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序。 冒泡排序 1、排序方法 将被排序的记录数组R[1..n]垂直排列,每个记录R[i]看作是重量为R[i].key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。(1)初始 R[1..n]为无序区。
冒泡排序教学设计
高一冒泡排序教学设计 一、设计思想 算法与程序设计具有高度的抽象性和严密的逻辑性,教师难教、学生难学成为一个突出的现象。如何消除学生畏惧心理,充分调动学生的积极性,正是我设计该课的主要目标。程序设计的基本方法是自顶向下地逐步求精和模块化。自顶向下地逐步求精是指首先要对所设计的系统有一个全面的理解,其次从顶层开始连续地逐层向下分解,直到系统的所有模块都被分解为一条条的详细指令时为止。模块化是指把一个大的程序按照一定的原则划分为若干个相对独立但又相关的小程序(模块)的方法。依据这个基本方法,在教师的引导下,从简单到复杂,从粗到精,各个难点分解,最后师生共同完成总流程图的设计。在整个过程中,教师要积极引发学生的思考,让他们真正参与进来。 二、教材分析 本节内容选自浙江教育出版社《算法与程序设计》第二章第三节和第五章第三节。以第二章内容为主,下节课让学生进行第五章编写程序及上机实践。 《课程标准》指出《算法与程序设计》模块教学主要目的是“使学生进一步体验算法思想,了解算法和程序设计在解决问题过程中的地位和作用;能从简单问题出发,设计解决问题的算法,并能初步使用一种程序设计语言编制程序实现算法解决问题。”冒泡排序的算法及程序实现就很好地较全面地体现了这点。 排序算法是使用频率最高的算法之一,而冒泡排序是其中一种很典型而且相对简单的方法。它的学习同时为后面的选择排序做了铺垫。通过冒泡实例的学习,可以提高学生的程序设计能力,为今后在算法与程序设计方面的进一步研究和学习打下基础。 三、学情分析 我是先上第一、三、四章,再上第二和第五章。通过前面三章的学习,同学们已经了解了算法设计的基本知识,学会了利用自然语言和流程图描述解决问题的算法,对排序中碰到的循环结构的流程图和循环语句以及数组变量的使用方法都已有基础。但由于实践比较少,对以前知识的遗忘率比较高,画流程图还不太熟练,程序设计思想比较弱。因此由浅入深,逐步引导比较适合学生的口味。 四、教学目标 知识目标:掌握冒泡排序的原理;理解冒泡排序的流程图;编写冒泡排序的主要代码; 能力目标:学会使用冒泡排序思想设计解决简单排序问题的算法;进一步理解程序设计的基本方法,体会程序设计在现实中的作用; 情感目标:培养学生分析问题、发现规律的能力,激发学生学习热情;培养良好的程序书写习惯; 五、重点难点 重点:理解冒泡排序原理及它的流程图 难点:理解冒泡排序中的遍、次等概念(即对变量使用的理解) 六、教学策略与手段 采用讲解法、演示法、讨论合作、分析归纳法引导学生参与思考,用逐步求精的方式降低学生的理解难度,化抽象为具体,由特殊到一般,有效地突出重点突破难点。 七、课前准备
C语言常用排序算法
/* ===================================================================== ======== 相关知识介绍(所有定义只为帮助读者理解相关概念,并非严格定义): 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后,仍能保持它们在排序之前的相对次序,我们就 说这种排序方法是稳定的。反之,就是非稳定的。 比如:一组数排序前是a1,a2,a3,a4,a5,其中a2=a4,经过某种排序后为 a1,a2,a4,a3,a5, 则我们说这种排序是稳定的,因为a2排序前在a4的前面,排序后它还是在a4的前面。假如变成a1,a4, a2,a3,a5就不是稳定的了。 2、内排序和外排序 在排序过程中,所有需要排序的数都在内存,并在内存中调整它们的存储顺序,称为内排序; 在排序过程中,只有部分数被调入内存,并借助内存调整数在外存中的存放顺序排序方法称为外排序。 3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度,是指执行算法所需要的计算工作量。 一个算法的空间复杂度,一般是指执行这个算法所需要的内存空间。 ===================================================================== =========== */ /* ================================================ 功能:选择排序 输入:数组名称(也就是数组首地址)、数组中元素个数 ================================================ */ /* ==================================================== 算法思想简单描述:
习题16(排序)
习题16(排序) 一、选择题 1、对n个不同的关键字由小到大进行冒泡排序,在下列()情况下比较的次数最多。 A)从小到大排列好的 B)从大到小排列好的 C)元素无序 D)元素基本有序 2、堆是一种()排序。 A)插入 B)选择 C)交换 D)归并 3、堆的形状是一棵()。 A)二叉排序树 B)满二叉树 C)完全二叉树 D)平衡二叉树 4、在含有n个关键字的小根堆(堆顶元素最小)中,关键字最大的记录有可能存储在()位置上。 A)?n/2? B)?n/2? -1 C)1 D)?n/2? +2 5、以下序列不是堆的是( )。 A)(100,85,98,77,80,60,82,40,20,10,66) B)(100,98,85,82,80,77,66,60,40,20,10) C)(10,20,40,60,66,77,80,82,85,98,100) D)(100,85,40,77,80,60,66,98,82,10,20) 6、下列四个序列中,哪一个是堆()。 A)75,65,30,15,25,45,20,10 B)75,65,45,10,30,25,20,15 C)75,45,65,30,15,25,20,10 D)75,45,65,10,25,30,20,15 7、在对n个元素的序列进行排序时,堆排序所需要的附加存储空间是()。 A)O(log2n) B)O(1) C)O(n) D)O(nlog2n) 8、有一组数据(15,9,7,8,20,-1,7,4),用堆排序的筛选方法建立的初始堆为() A)-1,4,8,9,20,7,15,7 B)-1,7,15,7,4,8,20,9 C)-1,4,7,8,20,15,7,9 D)A,B,C均不对 9、对一组记录的关键码{46,79,56,38,40,84}采用堆排序,则初始化堆后最后一个元素是()。 A)84 B)46 C)56 D)38 10、用二分法插入排序方法进行排序,被排序的表(或序列)应采用的数据结构是()。 A)单链表 B)数组 C)双向链表 D)散列表 11、在所有排序方法中,关键码比较的次数与记录的初始排序次序无关的是( ) A)希尔排序 B)冒泡排序 C)直接插入排序 D)直接选择排序 12、用归并排序方法,最坏情况下,所需时间为( ) A)O(n) B)O(n2) C)O(nlog2n) D)O(nlog2n) 13、具有12个记录的序列,采用冒泡排序最少的比较次数是( ) A)1 B)144 C)11 D)66 14、用冒泡排序对序列18,14,6,27,8,12,16,52,10,26,47,29,41,24进行排序,共进行( )次比较。 A)33 B)45 C)70 D)91 15、当初始序列已经按键值有序时,用直接插入算法进行排序,需要比较的次数为( ) A)n2 B)n logan C) log2n D)n-1 16、下面四种内排序方法中,要求内存容量最大的是( ) A)插入排序 B)选择排序 C)快速排序 D)归并排序 17、在文件局部有序或文件长度较小的情况下,最佳的排序方法是( ) A)直接插入排序 B)冒泡排序 C)简单选择排序 D)都不对 18、若待排序列已基本有序,要使它完全有序,从关键码比较次数和移动次数考虑,应当使用 ( )。 A)归并排序 B)直接插入排序 C)直接选择排序 D)快速排序 19、设有1000个无序的元素,希望用最快的速度挑选出其中10个最大的元素,最好的方法是()。 A)起泡排序 B)快速排序 C)堆排序 D)基数排序 20、在待排序的元素序列基本有序的前提下,效率最高的排序方法是()。 A)插入排序 B)选择排序 C)快速排序 D)归并排序
浙江高中信息技术选考复习选择排序冒泡排序习题
命题:杜宗飞 1 排序专题练习 1、某书店在5所学校流动售书量(单位:本)分别是8 2、11 3、46、69、35。采用冒泡排序对其进行排序,若完成第一遍时的结果是35、82、113、46、69,则完成第二遍时的结果是 ( ) A .35、82、113、46、69 B .35、46、82、69、113 C .35、46、82、113、69 D .35、46、69、82、113 2、(2009 年10月高考题)下表记录了6个数据的排序过程。分析表中数据可知,该排序采 (A )冒泡排序,降序 (B )选择排序,降序 (C )冒泡排序,升序 (D )选择排序,升序 3、用冒泡排序对4,5,6,3,2,1进行从小到大排序,第三趟排序后的状态为: A 、4 5 3 2 1 6 B 、4 3 2 1 5 6 C 、3 2 1 4 5 6 D 、1 2 3 4 5 6 4、用冒泡排序法对数据7,6,3,9,2从小到大排序,共需经过( )趟排序已可以得到正确结果?。 A.2 B.3 C.4 D.5 5、有一组数,顺序是“4,7,8,1,9”,用冒泡排序法将这组数从小到大排序,第二趟第二次对比的数据两个数是:( )。 A . 1、4 B . 4、7 C . 1、7 D . 7、8 6、篮球联赛中,有5个班级的比赛积分依次为14,11,13,8,9。若采用冒泡排序算法对其进行从大到小排序,需要排几遍交换几次 (A )1 2 (B )4 2 (C )1 8 (D )4 8 7、(2011年统考题)某书店在5所学校流动售书量(单位:本)分别是88,110,48,64,35。采用冒泡排序对其进行排序,若完成第一遍时的结果是:35,88,110,48,64,则完成第二遍时的结果是 (A )35,88,110,48,64 (B )35,48,88,64,110 (C )35,48,88,110,64 (D )35,48,64,88,110 8、(2012年3月高考题)实现某排序算法的部分VB 程序如下: For i = 1 To 4 For j = 5 To i + 1 Step -1 If a(j) < a(j - 1) Then t = a(j) : a(j) = a(j - 1) : a(j - 1) = t Next j Next i
数据结构(C语言版)实验报告-(内部排序算法比较)
数据结构与算法》实验报告 一、需求分析 问题描述:在教科书中,各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶,或大概执行时间。试通过随机数据比较各算法的关键字比较次数和关键字移动次数,以取得直观感受。 基本要求: (l )对以下 6 种常用的内部排序算法进行比较:起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。 (2 )待排序表的表长不小于100000 ;其中的数据要用伪随机数程序产生;至少要用 5 组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为 3 次移动)。 ( 3 )最后要对结果作简单分析,包括对各组数据得出结果波动大小的解释。数据测试:二.概要设计 1. 程序所需的抽象数据类型的定义: typedef int BOOL; typedef struct StudentData { } Data; typedef struct LinkList { Data Record[MAXSIZE]; int num; // 存放关键字 int Length; // 数组长度// 用数组存放所有的随机数 // 说明BOOL 是int 的别名 } LinkList int RandArray[MAXSIZE]; // 定义长度为MAXSIZE 的随机数组 void RandomNum() // 随机生成函数
void InitLinkList(LinkList* L) // 初始化链表 // 比较所有排序 2 . 各程序模块之间的层次(调用)关系: BOOL LT(int i, int j,int* CmpNum) // 比较 i 和 j 的大小 void Display(LinkList* L) // 显示输出函数 void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) void QuickSort (LinkList* L, // 快速排序 void HeapSort (LinkList* L, // 堆排序 void BubbleSort(LinkList* L, // 冒泡排序 void SelSort(LinkList* L, // 选择排序 int* CmpNum, int* ChgNum) int* CmpNum, int* ChgNum) int* CmpNum, int* ChgNum) * CmpNum, int* ChgNum) void Compare(LinkList* L,int* CmpNum, int* ChgNum) // 希尔排序
冒泡排序和选择排序算法的动态演示程序
//选择排序算法 #include #include using namespace std; void main() { void select_sort(int array[],int n); int a[10],i; cout<<"input 10 numbers:"<>a[i]; cout<for(j=i+1;j>b; if(b=='n') break; } if (i==n) { cout<<"the sorted arry:"<【IT专家】蛮力算法: 选择排序 冒泡排序(详解)
蛮力算法:选择排序冒泡排序(详解) 2015/10/26 1 蛮力法:蛮力法(brute force)是一种简单直接地解决问题的方法,常常直接基于问题的描述和所涉及的概念定义。虽然巧妙而高效的算法很少来自于蛮力法,但它还是具有重要地位。因为它能解决几乎任何问题,如果要解决的问题的规模不大,或者对性能没有很高的要求,那么花大工夫涉及复杂的算法显然是不值得的。下面就来介绍一下2大蛮力排序算法,然后是它们的分析。 ?框架介绍:在介绍算法之前,有必要介绍一些以后会用到的方法。使用前2个方法,我们就可以生成随机数组,然后方便地判断数列是否被正确排序了,以此验证排序算法的正确性。第3个方法从标准输入中读取数据(通过重定向),进行大规模排序,以此比较不同算法的性能。 ?/** * 生成一个长度为0~600的数组,每个元素的值为0~99999的整数。* * @return */ public static Integer[] randomArray() { Integer[] r = new Integer[(int) (600 * Math.random())]; for (int i = 0; i r.length; i++) r[i] = (int) (99999 * Math.random()); return r; } /** * 返回一个数组是否是有序的。* @param r * @return */ public static boolean isSorted(Integer[] r) { for (int i = 1; i r.length; i++) if (r[i]pareTo(r[i - 1]) 0) return false; return true; } /** * 从标准输入中读取1000000个整数的数组。* @return */ public static Integer[] arrayIn(){ Scanner in = new Scanner(System.in); Integer[] r = new Integer[1000000]; for(int i=0;i 1000000;i++) r[i] = in.nextInt(); return r; }选择排序:选择排序开始的时候,我们扫描整个列表,找到它的最小元素,然后和第一个元素交换(如果第一个元素就是最小元素,那么它就和自己交换。)。再次,在剩下的元素中找到最小元素,将它和数组的第二个元素交换位置,以此往复,直到整个数组有序。这种算法叫做选择排序,因为它每次都选择剩余元素之中最小的元素放在正确位置。 public static void selection(Integer[] r) { int N = r.length; for (int i = 0; i N - 1; i++) { int min = i;//已知最小元素的索引for (int j = i + 1; j j++) if (r[min] r[j])//如果找到更小的元素,更新索引min = j; int temp = r[i];//交换位置r[i] = r[min]; r[min] = temp; } }
C语言冒泡排序法
main() { int i,j,temp; int a[10]; for(i=0;i<10;i++) scanf ("%d,",&a[i]); for(j=0;j<=9;j++) { for (i=0;i<10-j;i++) if (a[i]>a[i+1]) { temp=a[i]; a[i]=a[i+1]; a[i+1]=temp;} } for(i=1;i<11;i++) printf("%5d,",a[i] ); printf("\n"); } -------------- 冒泡算法 冒泡排序的算法分析与改进 交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。 应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序。 冒泡排序 1、排序方法 将被排序的记录数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。 (1)初始 R[1..n]为无序区。 (2)第一趟扫描 从无序区底部向上依次比较相邻的两个气泡的重量,若发现轻者在下、重者在上,则交换二者的位置。即依次比较(R[n],R[n-1]),(R[n-1],R[n-2]),…,(R[2],R[1]);对于每对气泡(R[j+1],R[j]),若R[j+1].key