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.import java.util.Arrays;

2.import java.util.Random;

3.

4.public class SortArray_02 {

5. public static void main(String[] args) {

6. Random rd = new Random();

7. int[] array = new int[15]; // 声明数组

8. System.out.println("没有使用sort方法前的数组：");

9. for (int i = 0; i < array.length; i++) { // 利用随

机数随意产生15个0～20之间的随机数

10. array[i] = rd.nextInt(20); // 给array数组

赋值

11. System.out.print(" " + array[i]);

12. if ((i + 1) % 5 == 0)

13. System.out.println();

14. }

15. Arrays.sort(array); // 对array数组进行

升序排序

16. System.out.println("\n使用sort方法后的数组：");

17. for (int i = 0; i < array.length; i++) { // 将

array数组中的数据输出

18. System.out.print(" " + array[i]);

19. if ((i + 1) % 5 == 0)

20. System.out.println();

21. }

22. }

23.}

部分数组递增排序

1.import java.util.Arrays;

2.import java.util.Random;

3.

4.public class SortArray_03 {

5. public static void main(String[] args) {

6. Random rd = new Random();

7. int[] array = new int[15]; // 声明数组

8. System.out.println("没有使用sort方法前的数组：");

9. for (int i = 0; i < array.length; i++) { // 利用随

机数随意产生15个0～20之间的随机数

10. array[i] = rd.nextInt(20); // 给array数组

赋值

11. System.out.print(" " + array[i]);

12. if ((i + 1) % 5 == 0)

13. System.out.println();

14. }

15. Arrays.sort(array,5,14); // 对array数组中的

第5个元素～第13个元素之间进行升序排序

16. System.out.println("\n使用sort方法后的数组：");

17. for (int i = 0; i < array.length; i++) { // 将array数

组中的数据输出

18. System.out.print(" " + array[i]);

19. if ((i + 1) % 5 == 0)

20. System.out.println();

21. }

22. }

23.}

选择排序法

1.public class SortArray_04 {

2. public static void main(String args[]) {

3. int[] array = { 14, 5, 86, 4, 12, 3, 51, 13, 11, 2, 32,

6 }; // 创建一个初始化的一维数组array

4. int keyValue; // 表示最小的元素

值

5. int index; // 表示最小的元素值

的下标

6. int temp; // 中间变量

7. System.out.println("未排序的数组:");

8. for (int i = 0; i < array.length; i++) { // 遍历

array数组中的元素

9. System.out.print(" " + array[i]); // 输出数组

元素

10. if ((i + 1) % 5 == 0) // 每5个元素一

行

11. System.out.println();

12. }

13. for (int i = 0; i < array.length; i++) { // 使用选

择排序法的核心

14. index = i;

15. keyValue = array[i];

16. for (int j = i; j < array.length; j++)

17. if (array[j] < keyValue) {

18. index = j;

19. keyValue = array[j];

20. }

21. temp = array[i];

22. array[i] = array[index];

23. array[index] = temp;

24. }

25. System.out.println("\n使用选择排序法后的数组:");

26. for (int i = 0; i < array.length; i++) { // 遍

历排好序的array数组中的元素

27. System.out.print(" " + array[i]); // 输出

数组元素

28. if ((i + 1) % 5 == 0)

29. System.out.println(); // 每5个元

素一行

30. }

31. }

32.}

快速排序法

0.public class SortArray_05 {

1. public static void main(String args[]) {

2. int[] intArray = { 12, 11, 45, 6, 8, 43, 40, 57, 3, 20,

15 };

3. System.out.println("排序前的数组:");

4. for (int i = 0; i < intArray.length; i++) {

5. System.out.print(" " + intArray[i]); //

输出数组元素

6. if ((i + 1) % 5 == 0) // 每5

个元素一行

7. System.out.println();

8. }

9. System.out.println();

10. int[] b = quickSort(intArray, 0, intArray.length - 1);

// 调用quickSort

11. System.out.println("使用快迅排序法后的数组:");

12. for (int i = 0; i < b.length; i++) {

13. System.out.print(" " + b[i]);

14. if ((i + 1) % 5 == 0) // 每5

个元素一行

15. System.out.println();

16. }

17. }

18. public static int getMiddle(int[] array, int left, int righ

t) {

19. int temp;

20. // 进行一趟快速排序,返回中心点位置

21. int mid = array[left]; // 把中

心置于a[0]

22. while (left < right) {

23. while (left < right && array[right] >= mid)

24. right--;

25. temp = array[right]; // 将比

中心点小的数据移动到左边

26. array[right] = array[left];

27. array[left] = temp;

28. while (left < right && array[left] <= mid)

29. left++;

30. temp = array[right]; // 将比

中心点大的数据移动到右边

31. array[right] = array[left];

32. array[left] = temp;

33. }

34. array[left] = mid; // 中心移到

正确位置

35. return left; // 返回中心

点

36. }

37. public static int[] quickSort(int[] array, int left, int ri

ght) {// 快速排序法

38. if (left < right - 1) { // 如果开始点和结点没

有重叠的时候，也就是指针没有执行到结尾

39. int mid = getMiddle(array, left, right); //

重新获取中间点

40. quickSort(array, left, mid - 1);

41. quickSort(array, mid + 1, right);

42. }

43. return array;

44. }

45.}

C语言几种常见的排序方法

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种算法中比较难实现的）。

四种简单的排序算法

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.wendangku.net/doc/4a17564259.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()方法则用于交换数组中的两

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++)

数据结构中几种常见的排序算法之比较

几种常见的排序算法之比较 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) 在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序；在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。

常见的八种经典排序方法

常见经典排序算法 1.希尔排序 2.二分插入法 3.直接插入法 4.带哨兵的直接排序法 5.冒泡排序 6.选择排序 7.快速排序 8.堆排序 一.希尔（Shell）排序法（又称宿小增量排序，是1959年由D.L.Shell提出来的） /* Shell 排序法 */ #include void sort(int v[],int n) { int gap,i,j,temp; for(gap=n/2;gap>0;gap /= 2) /* 设置排序的步长，步长gap每次减半，直到减到1 */ { for(i=gap;i= 0) && (v[j] > v[j+gap]);j -= gap ) /* 比较相距gap远的两个元素的大小，根据排序方向决定如何调换 */ { temp=v[j];

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 temp) /* 如果中间元素比但前元素大，当前元素要插入到中间元素的左侧 */

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

数据排序的几种方法c语言实现

数据排序的几种方法(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 =0 && t <*(x+j); j--) /*注意：j=i-1，j--，这里就是下标为i的数，在它前面有序列中找插入位置。*/ { *(x+j+1) = *(x+j); /*如果满足条件就往后挪。最坏的情况就是t 比下标为0的数都小，它要放在最前面，j==-1，退出循环*/ } *(x+j+1) = t; /*找到下标为i的数的放置位置*/ } } ======================================================================= ======================================================================= 算法名称：冒泡排序 算法定义：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

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.} 数组递增排序

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

c语言实现简单排序(8种方法)

#include #include //冒泡排序 voidbubleSort(int data[], int n); //快速排序 voidquickSort(int data[], int low, int high); intfindPos(int data[], int low, int high); //插入排序 voidbInsertSort(int data[], int n); //希尔排序 voidshellSort(int data[], int n); //选择排序 voidselectSort(int data[], int n); //堆排序 voidheapSort(int data[], int n); void swap(int data[], inti, int j); voidheapAdjust(int data[], inti, int n); //归并排序 voidmergeSort(int data[], int first, int last); void merge(int data[], int low, int mid, int high); //基数排序 voidradixSort(int data[], int n); intgetNumPos(intnum, intpos); int main() { int data[10] = {43, 65, 4, 23, 6, 98, 2, 65, 7, 79}; inti; printf("原先数组:"); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n"); /*printf("冒泡排序:"); bubleSort(data, 10); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n"); printf("快速排序:"); quickSort(data, 0, 9); for(i=0;i<10;i++) { printf("%d ", data[i]); } printf("\n");

JAVA基础练习程序 数组冒泡排序

/* 数组排序 */ public class BubbleSort { public static void main(String[] args){ int[] arr = {1,25,36,21,24,12,39,87}; System.out.println("排序前："); String str = array2string(arr); System.out.println(str); bubblesort(arr); System.out.println("排序后："); String str2 = array2string(arr); System.out.println(str2); } /*冒泡排序*/ public static void bubblesort(int[] arr){ for(int x=0;x arr[y+1]){ swap(arr,y,y+1); } } } } //定义数组元素之间位置交换 public static void swap(int[] arr,int index1,int index2){ //定义临时变量 int temp = arr[index1]; arr[index1] = arr[index2]; arr[index2] = temp; } //定义字符串打印 public static String array2string(int[] arr){ String str = ""; for(int x=0;x

java中数组常见的排序问题整理

本文由我司收集整编，推荐下载，如有疑问，请与我司联系 java 中数组常见的排序问题整理 2016/03/13 0 span > 1.选择排序：选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的 起始位置，直到全部待排序的数据元素排完。选择排序是不稳定的排序方法。 如图所示：数组array 有5 个元素 首先，array[0]与array[1]比较大小，如果array[0] array[1],则将两元素互换位置，然后再将array[0]与array[2]进行比较，一次进行下去，当第一轮循环完成，则 array[0]是数组中最小的元素。然后开始拿array[1]与array[2]进行比较，依次下去， 比较到最后即可。 程序代码实现如下： public void SelectionSort(int[] array){for(int i=0;i array.length-1;i++){for(int j=i+1;j array.length;j++){int temp;if(array[i] array[j]){temp = array[i];array[i]=array[j];array[j]=temp;}}}}2.冒泡排序：它重复地走访过要排序的数 列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作 是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。下面用一张图 来详细说明冒泡的原理。如图： 数组array 有五个元素，int[] array={7,5,12,9,2}; 第一步还是和选择排序一样，先是array[0]和array[1]进行比较，如果array[0] array[1],两个元素互换位置，即array[0]=5,array[1]=7；第二步，array[1]和array[2]进行比较大小，array[1] array[2],位置不变；第三步，array[2]和array[3]比较，array[2] array[3],位置互换；array[3]与array[4]比较，array[3] array[4],位置互换，第一轮循环结束，我们会发现，数组的最后一个元素是数组中最大的。第一轮循环完成后的数 组变成如下图所示： 接下来继续又从array[0]和array[1]开始比较，重复下去。第一轮比较得出了最

C语言常用排序算法

/* ===================================================================== ======== 相关知识介绍（所有定义只为帮助读者理解相关概念，并非严格定义）： 1、稳定排序和非稳定排序 简单地说就是所有相等的数经过某种排序方法后，仍能保持它们在排序之前的相对次序，我们就 说这种排序方法是稳定的。反之，就是非稳定的。 比如：一组数排序前是a1,a2,a3,a4,a5，其中a2=a4，经过某种排序后为 a1,a2,a4,a3,a5， 则我们说这种排序是稳定的，因为a2排序前在a4的前面，排序后它还是在a4的前面。假如变成a1,a4, a2,a3,a5就不是稳定的了。 2、内排序和外排序 在排序过程中，所有需要排序的数都在内存，并在内存中调整它们的存储顺序，称为内排序； 在排序过程中，只有部分数被调入内存，并借助内存调整数在外存中的存放顺序排序方法称为外排序。 3、算法的时间复杂度和空间复杂度 所谓算法的时间复杂度，是指执行算法所需要的计算工作量。 一个算法的空间复杂度，一般是指执行这个算法所需要的内存空间。 ===================================================================== =========== */ /* ================================================ 功能：选择排序 输入：数组名称（也就是数组首地址）、数组中元素个数 ================================================ */ /* ==================================================== 算法思想简单描述：