冒泡排序算法，稀疏数组

冒泡排序

java代码

package array;

import java.util.Arrays;

public class ArrayDemo07 {
    public static void main(String[] args) {

        int[] test = {1, 34, 54, 5, 7, 3434, 7342, 546, 78, 89};

        int[] finTest = sort(test); // 调用完自己写的排序方法以后，返回一个排序好的数组

        System.out.println(Arrays.toString(finTest));   //打印输出数组
    }

    /*
     * 冒泡排序
     * 1.比较数组中，两个相邻元素，如果第一个数比第二个数大，我们就交换他们的位置
     * 2.每一次比较中，都会产生出一个最大或者最小的数；
     * 3.下一轮则可以少一次排序
     * 4.依次循环，直到结束！
     * */

    public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;

        //外层循环，判断我我们这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比较判断两个数，如果第一个数比第二个数小的话，则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j + 1]; //相对来说较小的一个在后面，把小的放前面
                    array[j + 1] = array[j];
                    array[j] = temp;
                }
            }

        }
        return array;
    }

}

冒泡排序的优化，以便减少时间成本

拿出我们所写的方法：

 public static int[] sort(int[] array) {
        //临时变量
        int temp = 0;
//====================================================
//优化：boolean flag = false;

        //外层循环，判断我我们这个要走多少次
        for (int i = 0; i < array.length - 1; i++) {
            //内层循环，比较判断两个数，如果第一个数比第二个数小的话，则交换位置
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j + 1] < array[j]) {
                    temp = array[j + 1]; //相对来说较小的一个在后面，把小的放前面
                    array[j + 1] = array[j];
                    array[j] = temp;
                    flag = true; 						//优化
                }
            }
//优化
		if(flage==false){			
					break;
						}
        }
        return array;
    }

稀疏数组

知识点：

1.遍历二维数组时，简便方法用foreach遍历方法
直接看代码，再结合上图

package array;

public class ArrayDemo08 {
    public static void main(String[] args) {
        //1.创建一个二维数组 11*11 0:没有棋子，1：黑棋子 2：白棋子

        int[][]  array1 = new int[11][11];
        array1[1][2] = 1;
        array1[2][3] = 2;
        //输出原始数组
        System.out.println("输出原始的数组");
        for (int[] ints : array1) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println("");
        }
        System.out.println("=============================");

        //转换为稀疏数组保存
        //获取有效值的个数
        int sum = 0;
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if (array1[i][j]!=0) {
                    sum++;
                }
            }
        }
        System.out.println("有效值的个数为："+sum);

        //2.创建于一个洗漱数组的数组
        int[][] array2 = new int[sum+1][3];//这里 sum+1为行的个数

        array2[0][0]= 11;  //存放行有多少个
        array2[0][1]= 11; //存放列有多少个
        array2[0][2]= sum;  //存放有效值的个数

        //遍历二维数组，将非零的值，存放在稀疏数组中
        int count= 0;       //定义一个数，来计算当前个数,作为当前的行数
        for (int i = 0; i < array1.length; i++) {
            for (int j = 0; j < array1[i].length; j++) {
                if (array1[i][j]!=0) {
                    count++;
                    array2[count][0] = i;       //里面count代表的当前行数；0代表当前第一列（行）；
                    array2[count][1] = j;       //里面count代表的当前行数；1代表当前第二列（列）；
                    array2[count][2] = array1[i][j];       //里面count代表的当前行数；2代表当前第三列（值）；
                }
            }
        }
        //输出稀疏数组
        System.out.println("输出稀疏数组：" );

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

        //还原稀疏数组
        //1.读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];       //array2里面的行值和列值的总和；

        //2.给其中的元素还原它的值
        for (int i = 1; i < array2.length; i++) {
            array3[array2[i][0]][array2[i][1]] = array2[i][2]; //其中 array2[i][0]代表行的值，array2[i][1]代表列的值，
            // 合起来代表的第几行第几列的值，array2[i][2]代表第几行第几列的真实值。
        }

        //3.打印还原数组
        System.out.println("输出还原数组：" );
        for (int[] ints : array3) {
            for (int anInt : ints) {
                System.out.print(anInt + "\t");
            }
            System.out.println("");
        }

    }
}