数组冒泡排序和稀疏数组

1、比较数组中，相邻的元素，如果第一个比第二个数大，我们就交换他们的位置。

2、每一次的比较，都会产生出一个最大，或者最小的数字。

3、依次循环，直到结束。

 

例子：

 1 public class Demo8 {
 2     public static void main(String[] args) {
 3         int[] a = {1,35,35,124,5,3,3,6,4,2};
 4 
 5         //调用完我们自己写的排序方法后，返回一个排序后的数组
 6         int[] sort = sort(a);
 7         System.out.println(Arrays.toString(sort));
 8 
 9     }
10     public static int[] sort(int[] array){
11         //定义第三方
12         //临时变量
13         int temp = 0;
14         //外层循环： 判断我们这个要走多少次
15         for (int i = 0; i < array.length-1; i++) {
16             //优化
17             //通过flag标识符减少没有意义的比较
18             boolean flag = false;
19             //内层循环： 比价判断两个数，如果第一个数， 比第二个数大， 则交换位置
20             for (int j = 0; j < array.length-1-i; j++) {
21                 if (array[j+1] > array[j]){
22                     temp = array[j];
23                     array[j] = array[j+1];
24                     array[j+1] = temp;
25                     flag = true;
26                 }
27             }
28             if (flag==false){
29                 break;
30             }
31         }
32         return array;
33     }
34 }

 

 

稀疏数组：

 1 public class Demo9 {
 2     public static void main(String[] args) {
 3         //1、建立一个二维数组11*11    0：又没棋子    1：黑棋   2： 白棋
 4         int[][] array1 = new int[11][11];
 5         array1[1][2] = 1;
 6         array1[2][3] = 2;
 7 
 8         //输出原始的数组
 9         System.out.println("输出原始数组");
10 
11         //打印
12         for (int[] ints : array1) {
13             for (int anInt : ints) {
14                 System.out.print(anInt+" ");
15             }
16             System.out.println("\n");
17         }
18 
19         //转换为稀疏数组
20         //获取有效值的个数
21         int sum = 0;
22         for (int i = 0; i < 11; i++) {
23             for (int j = 0; j < 11; j++) {
24                 if (array1[i][j] != 0){
25                     sum++;
26                 }
27             }
28         }
29         System.out.println("有效的个数："+sum);
30         System.out.println("==========================================");
31 
32         //2、创建一个稀疏数组的数组
33         int[][] array2 = new int[sum+1][3];
34         array2[0][0] = 11;
35         array2[0][1] = 11;
36         array2[0][2] = sum;
37 
38         //遍历二维数组， 将非零的值， 存放在稀疏数组中
39         int count = 0;
40         for (int i = 0; i < array1.length; i++) {
41             for (int j = 0; j < array1[i].length; j++) {
42                 if (array1[i][j] != 0){
43                     count++;
44                     array2[count][0] = i;
45                     array2[count][1] = j;
46                     array2[count][2] = array1[i][j];
47                 }
48             }
49         }
50         //输出稀疏数组
51         System.out.println("稀疏数组");
52         for (int i = 0; i < array2.length; i++) {
53             System.out.println(array2[i][0]+"\t"+
54                     array2[i][1]+"\t"+
55                     array2[i][2]);
56         }
57 
58         System.out.println("================================");
59         System.out.println("还原");
60         //1、读取稀疏数组
61         int[][] array3 = new int[array2[0][0]][array2[0][1]];
62         //2、给其中的元素还原它的值
63         for (int i = 1; i < array2.length; i++) {
64             array3[array2[i][0]][array2[i][1]] = array2[i][2];
65         }
66         //3、打印
67         for (int[] ints : array3) {
68             for (int anInt : ints) {
69                 System.out.print(anInt+" ");
70             }
71             System.out.println("\n");
72         }
73     }
74 }

 

标签：int,array2,System,冒泡排序,稀疏,数组,println,out
来源： https://www.cnblogs.com/xiao-wang-tong-xue/p/15988379.html