java由一个数组随机产生12个数并排序

实验四一个数组随机产生12个数排序import java.util.Arrays;

public class shu {

public static void main(String[] args) { double a[]=new double[12];

int i;

for(i=0;i

a[i]=Math.random()*100;

}

System.out.println("排序前输出");

for(i=0;i

System.out.printf("%.2f ",a[i]);

}

Arrays.sort(a);

System.out.println();

System.out.println("排序后输出");

for(i=0;i

System.out.printf("%.2f ",a[i]);

}

}

}

java 排序面试题

一道常考的javaSE面试题 上周一,.NET班有四个同学去面试，面试题是一道排序题，不管用什么方式做出结果就行。 就这道题我也想些想法，当时他们和我说完，我在想用什么方法可以实现。毕竟现在javaSE都忘的差不多了，现在主要学的还是javaEE方面。年前学习JSP和SERVLET一片的知识，到了年后主要学习三大框架、ajax、jquery和XML等。不过当时出现脑中的算法只有：java.util包中定义的Arrays类和冒泡法。 下面就拿上面方说的那两种方法具体说说。 在JDK的java.util包中定义的Arrays类提供了多种数据操作方法，实现了对数组元素的排序、填充、转换、增强检索和深度比较等功能，所以的这些方法都是static的，下面介绍对数组元素进行排序的方法。数组元素的排序通常是指一维数值型数组元素按升序排序，偶尔也会涉及一维String数组排序，一般来说，多维和其他引用类型的元素数组排序使用意义不大。 Arrays类中的sort()的格式： public static void sort([] a); 案例1： JDK的java.util包中定义的Arrays类提供了排序方法 一维数组排序： Java代码 1.package cn.z_xiaofei168.sort; 2. 3.import java.util.Arrays; 4. 5.public class TestArraySort { 6. 7./** 8. * @author z_xiaofei168 9. */ 10.public static void main(String[] args) { 11.int[] arr = { -1, -3, 5, 7, 9, 2, 4, 6, 8, 10 }; 12. System.out.print("整数排序前："); 13. displayIntArr(arr); 14. Arrays.sort(arr); 15. System.out.print("整数排序后："); 16. displayIntArr(arr); 17.

排序算法原理与实现(java)

Java程序员必知的8大排序<合肥软件培训> [来源：本站| 日期：2012年12月24日| 浏览173次] 字体:[大中小] 8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例 （3）用java实现 //从小到大 package com.njue;

2 3public class insertSort { 4public insertSort(){ 5 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,34,15,35,25,53,51}; 6int temp=0; 7for(int i=1;i=0&&temp

基础排序总结(冒泡排序、选择排序)

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、效率

四种简单的排序算法

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(T[] array, C comparer) where C:IComparer {

for (int i = 1; i <= array.Length - 1; i++) { //Console.Write("{0}: ", i); int j = i; while (j>=1 && https://www.sodocs.net/doc/de17159698.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(ref T x,ref T y) { // Console.Write("{0}<-->{1} ", x, y); T temp = x; x = y; y = temp; } } 上面Console.WriteLine()方法和AlgorithmHelper.PrintArray()方法仅仅是出于测试方便，PrintArray()方法依次打印了数组的内容。swap()方法则用于交换数组中的两

《Java范例开发大全》

下面是377个Java的例子。如果你是牛人，看看你能做出多少？ 如果有人不相信这些例子都是Java做的，可以看看清华大学的《Java范例开发大全》实例1开发第一个Java程序 实例2自动提升 实例3自动转换 实例4常用基础类型之强制转换 实例5算术运算符 实例6关系运算符 实例7逻辑运算符 实例8位运算符 实例9移位运算符 实例10转型运算符 实例11常量与变量 实例12各种进制的转换 实例13 Java中的进制与移位运算符 实例14判断输入的年份是否为闰年 实例15抽奖活动 实例16xx乘法表 实例17如何列出素数 实例18 Java中的递归 实例19男生女生各多少人

实例20求xx数 实例21求任意一个正数的阶乘 实例22求n的n次方 实例23利用for循环输出几何图形 实例24xx 实例25求1到100之间的和 实例26存上100元需要多少天 实例27输出100之间的所有偶数 实例28如何判断回文数字 实例29输出100之间的所有奇数 实例30求最大的随机数 实例31判断字母分类 实例32优良及差 实例33打印任意一年日历 实例34一年四季的划分 实例35除0发生的算术异常（ArithmeticException） 实例36数组下标越界异常（ArrayIndexOutOfBoundsException）实例37数组元素类型不匹配异常（ArrayStoreException） 实例38强制类型转换异常（ClassCastException） 实例39索引越界异常（IndexOutOfBoundsException） 实例40空指针异常（NullPointerException）

C语言中数组排序算法及函数调用

C语言中数组排序算法及函数调用 一、冒泡法（起泡法） 算法要求：用起泡法对10个整数按升序排序。 算法分析：如果有n个数，则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较，在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后，经过一趟比较后，将最值沉底（换到最后一个元素位置），最大值沉底为升序，最小值沉底为降序。 算法源代码： # include main() { int a[10],i,j,t; printf("Please input 10 numbers: "); /*输入源数据*/ for(i=0;i<10;i++) scanf("%d",&a[i]); /*排序*/ for(j=0;j<9;j++) /*外循环控制排序趟数，n个数排n-1趟*/ for(i=0;i<9-j;i++) /*内循环每趟比较的次数，第j趟比较n-j次*/ if(a[i]>a[i+1]) /*相邻元素比较，逆序则交换*/ { t=a[i]; a[i]=a[i+1]; a[i+1]=t; } /*输出排序结果*/ printf("The sorted numbers: "); for(i=0;i<10;i++) printf("%d ",a[i]); printf("\n"); } 算法特点：相邻元素两两比较，每趟将最值沉底即可确定一个数在结果的位置，确定元素位置的顺序是从后往前，其余元素可能作相对位置的调整。可以进行升序或降序排序。 算法分析：定义n-1次循环，每个数字比较n-j次，比较前一个数和后一个数的大小。然后交换顺序。二、选择法 算法要求：用选择法对10个整数按降序排序。 算法分析：每趟选出一个最值和无序序列的第一个数交换，n个数共选n-1趟。第i趟假设i为最值下标，然后将最值和i+1至最后一个数比较，找出最值的下标，若最值下标不为初设值，则将最值元素和下标为i的元素交换。 算法源代码： # include main() { int a[10],i,j,k,t,n=10; printf("Please input 10 numbers:"); for(i=0;i<10;i++)

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 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上 而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较

Java数组练习题(带答案)

一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length 。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0 。 7)arraycopy()的最后一个参数指明复制元素的个数。 8)向方法传递数组参数时，传递的是数组的引用。 9)数组初始化包括数组的申明，创建和初始化。 10)数组下标访问超出索引范围时抛出数组越界异常 11)浮点型数组的默认值是0.0f 。 12)数组创建后其大小不能改变。 二选择题 1.下面错误的初始化语句是_ABD__ A. char str[]="hello"; B. char str[100]="hello"; C. char str[]={'h','e','l','l','o'}; D. char str[]={'hello'}; 2.定义了一维int型数组a[10]后，下面错误的引用是_B__ A. a[0]=1; B. a[10]=2; C. a[0]=5*2; D. a[1]=a[2]*a[0]; 3.下面的二维数组初始化语句中，正确的是____ A. float b[2][2]={0.1,0.2,0.3,0.4}; B. int a[][]={{1,2},{3,4}}; C. int a[2][]= {{1,2},{3,4}}; D. float a[2][2]={0}; 4.引用数组元素时，数组下标可以是_D___ A. 整型常量 B. 整型变量 C. 整型表达式 D. 以上均可 5.定义了int型二维数组a[6][7]后，数组元素a[3][4]前的数组元素个数为____ A. 24 B. 25 C. 18 D. 17 6.下列初始化字符数组的语句中，正确的是__B__ A. char str[5]="hello"; B. char str[]={'h','e','l','l','o','\0'}; C. char str[5]={"hi"}; D. char str[100]=""; 7.数组在Java中储存在 C 中 A. 栈 B. 队列 C. 堆 D. 链表 8.下面程序的运行结果是____ main() { int a[][]={{1,2,3},{4,5,6}}; System.out.printf("%d", a[1][1]); } A. 3 B. 4 C. 5 D. 6 9.下面程序的运行结果是_C___ main() {

8种排序算法(有代码)

个人对这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=0;j--) //逐个向前寻找插入点 { if(temp>array[j]) //找到,跳出循环 break; else //没找到,将前一个数据后移 array[j+1]=array[j]; } array[j+1]=temp; } return true; } 思想: 逐个取数,插入一个有序数组(从后向前插) 算法平均时间复杂度: O(n^2) 3.自底向上排序 bool bottomupsort(int *array,int n) { int length=1,temp_length,i; //temp_length表示单个合并数组的长度 while(length

java中的各种排序案例

一、插入排序 1、基本思想 插入排序（以升序为例）的基本操作是将一个数插入到一个已经排好序的数据序列中，插入后的数据序列是有序的并且元素个数加一。插入排序的主要思想是： 假设要排序的数组为A[]元素个数为n，将这个数组分为两个部分前n-1个元素和最后一个元素，将最后一个元素插入到已经排好序的n-1个元素中的合适的位置。 InsertSort(A[n]) //对A[n]进行插入排序 { for i=1 to n divide(A[i-1],a[i]) //将A[i]分为两部分，前i-1个元素和最后一个元素 Insert(a[i],A[i-1])//将最后一个元素插入到排好序的前i-1个元素中 } 2、算法复杂度分析 插入排序存在着最好情况和最坏情况，最好的情况是已经是排好序的了，这时只需比较n-1次即可；最坏的情况是序列是降序的需要排成升序的，那么此时就需要比较n(n-1)/2。插入排序的赋值操作是比较操作的次数加上n-1次。平均来说插入排序的算法复杂度为O(n2)。 3、编程实现 public static void InsertSort(int[] A){ for(int i=1;i0&&A[j-1]>=temp){ A[j]=A[j-1]; j--; } A[j]=temp; } } 二、冒泡排序 1、基本思想 冒泡排序（以升序为例）的基本思想是：依次比较相邻的两个数，将小数放在前面，大数放在后面，第一轮比较后，最大的数便被放到了最后；第二轮操作前n-1个数据（假设有n个数据），依然是依次比较相邻的两个数，将小数放在前面，大数放在后面，倒数第二个数便是第二大的数；同理第i轮操作前n-i+1的数据（假设i取值是从1开始的），则n-i+i位置上的数据为第i大的数据。一共有n-1轮，第i轮比较中共比较n-i次比较。 BubbleSort(A[n]) { for(i=1;iA[j+1]) A[j]?A[j+1];//交换次序 } 2、算法复杂度分析

数据结构内部排序比较分析

数据结构实训报告 实验名称：数据结构 题目：内部排序比较 专业：班级：姓名：学号：实验日期： 一、实验目的：通过随机数据比较各内部排序算法的关键字比较次数和关键字移动的次数，以取得直观感受。训练学生综合设计算法能力。 二、实验要求：待排序长度不小于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

Java程序员必知的8大排序(上)

Java程序员必知的8大排序(上) 本文主要详解了Java语言的8大排序的基本思想以及实例解读，详细请看下文 AD：8种排序之间的关系: 1，直接插入排序 （1）基本思想：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。 （2）实例

（3）用java实现 1package com.njue; 2 3public class insertSort { 4public insertSort(){ 5 inta[]={49,38,65,97,76,13,27,49,78,34,12,64,5,4,62,99,98,54,56,17,18,23,3 4,15,35,25,53,51}; 6int temp=0; 7for(int i=1;i=0&&temp

Java数组测习题(带答案)

精心整理一填空题 1)数组的元素通过下标来访问，数组Array的长度为Array.length。 2)数组复制时，"="将一个数组的引用传递给另一个数组。 3)JVM将数组存储在栈(堆或栈)中。 4)数组的二分查找法运用的前提条件是数组已经排序。 5)Java中数组的下标的数据类型是整型。 6)数组最小的下标是0。 7) 8) 9) 10) 11) 12) 1. 2. 3. 4. 5. 6. 7. 8.A. 9. 10. 11.A 12.C.charstr[5]={"hi"}; D.charstr[100]=""; 13.数组在Java中储存在C中 14.A.栈 B.队列 C.堆 D.链表 15.下面程序的运行结果是____ main(){ inta[][]={{1,2,3},{4,5,6}}; }

A.3 B.4 C.5 D.6 16.下面程序的运行结果是_C___ 17.m ain(){ intx=30; int[]numbers=newint[x]; x=60; (numbers.length); } A.60 B.20 C.30 D.50 18. 19.m 20.c 21.i 22.w 23. 24.A 25.C 26. A. C.用 27. 28. A. 29. 30. A.char--'"u0000' B.Boolean--true C.float--0.0f D.int--0 31.关于数组作为方法的参数时，向方法传递的是A A.数组的引用 B.数组的栈地址 C.数组自身 D.数组的元素 32.关于数组复制，下列说法错误的是AC A."="可以实现数组复制 B.运用循环语句进行数组复制必须两个数组长度相同 C.arraycopy()方法没有给目标数组分配内存空间 D.数组复制是数组引用的传递

各种排序方法复杂度总结归纳

各种排序方法复杂度总结归纳 一、冒泡排序 主要思路是： 通过交换相邻的两个数变成小数在前大数在后，这样每次遍历后，最大的数就“沉”到最后面了。重复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; } } }

JAVA数组的排序方法实例

冒泡排序法 1.public class SortArray_01 { 2. public static void main(String args[]) { 3. int[] array = { 14, 5, 86, 4, 12, 3, 21, 13, 11, 2, 55 }; // 创建一个初始化的一维数组array 4. System.out.println("未排序的数组:"); 5. for (int i = 0; i < array.length; i++) { // 遍历array数组中的元素 6. System.out.print(" " + array[i]); // 输出数组元素 7. if ((i + 1) % 5 == 0) // 每5个元素一行 8. System.out.println(); 9. } 10. int mid; // 定义一个中间变量， 起到临时存储数据的作用 11. for (int i = 0; i < array.length; i++) { // 执行冒 泡排序法 12. for (int j = i; j < array.length; j++) { 13. if (array[j] < array[i]) { 14. mid = array[i]; 15. array[i] = array[j]; 16. array[j] = mid; 17. } 18. } 19. } 20. System.out.println("\n使用冒泡法排序后的数组:"); 21. for (int i = 0; i < array.length; i++) { // 遍历排好序的array数组中的元素 22. System.out.print(" " + array[i]); // 输出数组元素 23. if ((i + 1) % 5 == 0) 24. System.out.println(); // 每5 个元素一行 25. } 26. } 27.} 数组递增排序

冒泡排序专题

一、例题回顾 例1、某书店在5所学校流动售书量（单位：本）分别是82、113、46、69、35。 例2、有一组原始数据：23、25、18、63、84、77、65、9、33、17。利用冒泡排序算法进行从小到大排序，最多需要进行（）次加工，（）次比较，才可以完成整个数据的排序。 有一组数据，采用冒泡排序第一遍排序以后数据为 4，10，5，32，6，7，9，17， 24 那么该数组原来顺序不可能的是（） A.10，5，32，6，7，9，17，24，4 B.10，5，32，6，7，9，17，24，4 C.10，5，32，4，6，7，9，17，24 D. 4，10，5，32，9，17，24，6，7 3、在某年市机器人投篮比赛中，共有5支队伍参加，各队的最终成绩如下：82、7 4、66、9 5、70（单位：个/分钟），现用冒泡排序算法来实现这些数据的排序操 A.1次 B.2次 C.3次 D.4次 4、某书店在5所学校流动售书量（单位：本）分别是82、113、46、69、35。采用冒泡排序对其进行排序，若完成第一遍时的结果是3 5、82、113、4 6、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 5、实现某排序算法的部分VB程序如下： For i = 1 To 4 For j = n 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 在经过某一遍排序“加工”后，数组元素a(1)到a(5)的数据依次为“25、77、 51、59、32”。则下一遍排序“加工”后数组元素a(1)到a(5)的数据应该是 （） A. 25、32、77、51、59 B. 25、32、51、59、77 C. 25、32、59、51、77 D.25、32、51、77、59

java二分法查找案例与数组排序案例

一、一个int类型数组按升序排序案例 public class ArrayTest { private static int[] arrayAesc; public static void main(String[] args) { ArrayTest a = new ArrayTest(); arrayAesc = new int[]{5,2,1,4,6,3}; arrayAesc = a.sortArrayAesc(arrayAesc); for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]); } System.out.println("success"); } public int[] sortArrayAesc(int[] temps){ for (int i = 0; i < temps.length; i++) { for (int j = i+1; j < temps.length; j++) { if (temps[i] > temps[j]) { int temp; temp = temps[i]; temps[i] = temps[j]; temps[j] = temp; } } } return temps; } } 二、一个int类型数组按降序排序案例 public class ArrayTest { private static int[] arrayAesc; public static void main(String[] args) { ArrayTest a = new ArrayTest(); arrayAesc = new int[]{5,2,1,4,6,3}; arrayAesc = a.sortArrayDesc(arrayAesc); for (int i = 0; i < arrayAesc.length; i++) { System.out.println(arrayAesc[i]); } System.out.println("success"); }

C++一维数组的排序

第三节数值型一维数组的应用 一、数值型一维数组在递推中的应用 【例5-3】斐波拉契数列：前两项为0和1，从第三项开始，各项均为前相邻两项之和：0，1，1，2，3，5，8，11，19，……。写C程序，输出该数列前N项。 【简要分析】显然这是一个典型的递推问题，结合数组，从第三个数开始，其递推公式是： x[i]=x[i-1]+x[i-2]，其中i=2,3, …,N-1。 利用循环结构，用N-S流程图描述的程序逻辑如图5-2所示。 参考源代码： /* 例5-3，5-3.cpp */ #include #define N 20 void main() { long i, x[N]; x[0] = x[1] = 0; /* 赋初值*/

for ( i = 2; i < N; i++ ) /* 尚剩18项*/ x[i] = x[i - 1] + x[i - 2]; /* 产生各项*/ for ( i = 0; i < N; i++ ) /* 输出数列*/ cout<< "\t" << x[i]; system(“pause”); } 【思考验证】如果将x数组定义为整型int，程序是否能正常运行？ 【模仿训练】某数列前三项为0、1、1，以后各项均为前相邻三项之和，输出该数列前N项。 二、排序 【例5-4】键盘输入N个战士的身高，将其升序排列。 【简要分析】排序是数组的经典应用，现实生活中用得太多，请读者务必掌握。排序的方法很多，《数据结构》中有详细介绍，请读者自己查阅，本例用比较法。 具体实现逻辑是：将数组元素a[i]（i=0,1,2…,N-2）与它后边的每一个元素a[j]（j=i+1,…,N-1）逐个比较，凡有a[j]

JAVA中运用数组的四种排序方法

JAVA中在运用数组进行排序功能时，一般有四种方法：快速排序法、冒泡法、选择排序法、插入排序法。 快速排序法主要是运用了Arrays中的一个方法Arrays.sort（）实现。 冒泡法是运用遍历数组进行比较，通过不断的比较将最小值或者最大值一个一个的遍历出来。 选择排序法是将数组的第一个数据作为最大或者最小的值，然后通过比较循环，输出有序的数组。 插入排序是选择一个数组中的数据，通过不断的插入比较最后进行排序。下面我就将他们的实现方法一一详解供大家参考。 <1>利用Arrays带有的排序方法快速排序 import java.util.Arrays; publicclass Test2{ publicstaticvoid main(String[] args){ int[] a={5,4,2,4,9,1}; Arrays.sort(a); //进行排序 for(int i: a){ System.out.print(i); } } } <2>冒泡排序算法 publicstaticint[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;iargs[j]){ int temp=args[i]; args[i]=args[j]; args[j]=temp; } } } return args; } <3>选择排序算法 publicstaticint[] selectSort(int[] args){//选择排序算法 for (int i=0;i

java的七种经典排序

此文中的七种排序算法为个人总结，程序均在eclipse中验证成功，可供参考 package sort; /* * 各种排序方法总结 */ public class Sort { public static void main(String[] args) { int[] array={4,9,6,7,2,3,1,5,8,0}; Sort.heapSort(array); for(int i=0;i array[index]) { index = j; } } int temp = array[array.length - i - 1]; array[array.length - i - 1] = array[index]; array[index] = temp; } return array; } public static int[] selectSort1(int[] array) { for (int i = 0; i < array.length; i++) { int minIndex = i; for (int j = i + 1; j < array.length; j++) {

冒泡排序的三种实现

冒泡排序是非常容易理解和实现，以从小到大排序举例： 设数组长度为N。 1．比较相邻的前后二个数据，如果前面数据大于后面的数据，就将二个数据交换。 2．这样对数组的第0个数据到N-1个数据进行一次遍历后，最大的一个数据就“沉”到数组第N-1个位置。 3．N=N-1，如果N不为0就重复前面二步，否则排序完成。 按照定义很容易写出代码： //冒泡排序1 void BubbleSort1(int a[], int n) { int i, j; for (i = 0; i < n; i++) for (j = 1; j < n - i; j++) if (a[j - 1] > a[j]) Swap(a[j - 1], a[j]); } 下面对其进行优化，设置一个标志，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。 //冒泡排序2 void BubbleSort2(int a[], int n) { int j, k; bool flag; k = n; flag = true; while (flag) { flag = false; for (j = 1; j < k; j++) if (a[j - 1] > a[j]) { Swap(a[j - 1], a[j]); flag = true; } k--; } } 再做进一步的优化。如果有100个数的数组，仅前面10个无序，后面90个都已排好序且都大于前面10个数字，那么在第一趟遍历后，最后发生交换的位置必

定小于10，且这个位置之后的数据必定已经有序了，记录下这位置，第二次只要从数组头部遍历到这个位置就可以了。 //冒泡排序3 void BubbleSort3(int a[], int n) { int j, k; int flag; flag = n; while (flag > 0) { k = flag; flag = 0; for (j = 1; j < k; j++) if (a[j - 1] > a[j]) { Swap(a[j - 1], a[j]); flag = j; } } } 冒泡排序毕竟是一种效率低下的排序方法，在数据规模很小时，可以采用。数据规模比较大时，最好用其它排序方法。 我的java代码实现 package com.bjsxt.sort; import java.util.Arrays; public class BubbleSort { public static void main(String[] args) { int[] a = { 2, 4, 5, 6, 7, 8, 23, 9, 76, 45, 34 }; int len = a.length; BubbleSort sort = new BubbleSort(); // 冒泡排序升序 //System.out.println(Arrays.toString(sort.bubbleSort1(a, len)));//原始冒泡排序 //System.out.println(Arrays.toString(sort.bubbleSort2(a, len)));//第一步优化 System.out.println(Arrays.toString(sort.bubbleSort3(a, len)));//第二部优化 //System.out.println(Arrays.toString(sort.bubbleSort4(a,