Java——冒泡排序和稀疏数组

一、冒泡排序

• 冒泡排序无疑是最为出名的排序算法之一，总共有八大排序
• 冒泡的代码还是相当简单，两层循环，外层泡轮数，里层一次比较
• 我们看到嵌套循环，立马得出这个算法的时间复杂度为O（n2）

四个步骤

1. 两个循环，外层循环计算比较次数

2. 内层循环比较两个相邻的元素，如果第一个数比第二个数大，则交换位置**(每次都找出了最大的数字)**

3. 下一轮则可以少一次排序

4. 依次循环，直至结束

public static int[] sort1(int[] a ){
	for (int i = 0;i<a.length-1;i++){
		boolean flag = false; //若已经排好了便直接退出循环，而不进行下一次排序
		for(int j = 0;j<a.length-1-i;i++){
			if(a[j]>a[j+1]){
				int temp = a[j];
				a[j] = a[j+1];
				a[j+1] = temp;
				flag = true;  //为true 则表明进行了排序
			}
			while (flag == false){
				break;
			}
		}
	}
	return a;
}

二、稀疏数组

稀疏数组介绍

• 当一个数组中大部分元素为0，或者为同一值的数组时，可以使用稀疏数组来保存该数组。（压缩）

• 稀疏数组的处理方式是：

  1. 记录数组一共有几行几列，有多少个不同值
  2. 把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

• 如：左边为原始数组，右边为稀疏数组

  9行10列

0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 5 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 9 0 0 0
0 0 8 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0

转化为 稀疏数组 则为下图：
[0]表示的是该数组的行列信息，及有几个不一样的值

	行	列	值
[0]	9	10	3
[1]	3	5	5
[2]	5	7	9
[3]	6	3	8

一. 把数组转化为稀疏数组

1. 创建9行10列的数组

int[][] a = new int[9][10];
        a[3][5] = 5;
        a[5][7] = 9;
        a[6][3] = 8;
        //打印数组元素
        for (int[] ints : a){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

2. 创建稀疏数组

//1.获取有效值的个数
        int count = 0;
        for (int i = 0;i<a.length;i++){
            for (int j = 0; j<a[i].length;j++){
                if (a[i][j] != 0){
                    count++;
                }
            }
        }
        System.out.println("有效值个数为："+count);
        //2.创建稀疏数组表头
        int[][] b = new int[count+1][3];
        b[0][0] = 9;
        b[0][1] = 10;
        b[0][2] = count;
        //3.遍历数组，将非零元素放入稀疏数组中
        int temp = 0;
        for (int i = 0;i<a.length;i++){
            for (int j = 0;j<a[0].length;j++){
                if (a[i][j]!=0){
                    temp++;
                    b[temp][0] = i;
                    b[temp][1] = j;
                    b[temp][2] = a[i][j];
                }
            }
        }

3. 输出稀疏数组

for (int i = 0;i<b.length;i++){
            System.out.println(b[i][0]+"\t"+b[i][1]+"\t"+b[i][2]);
        }

二.把稀疏数组还原为原始数组

1. 读取稀疏数组

int[][] c = new int[b[0][0]][b[0][1]];

2. 给其中的元素复原

for (int i = 1;i<b.length;i++){
            c[b[i][0]][b[i][1]] = b[i][2];
        }

3. 打印稀疏数组

for (int[] ints : c){
            for (int anInt : ints){
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }