稀疏数组（压缩算法）及冒泡排序详解

稀疏数组（压缩算法）及冒泡排序详解

稀疏数组（压缩算法）实例

稀疏数组逻辑框架
（该数组共有6行7列，有8个有效值）

1.随机创建个二维数组

//1.创建一个二维数组11*11    
        int[][] array1 = new int[11][11];
        array1[1][2]=1;   //设置第一行第二列的值为1
        array1[2][3]=5;    //设置第二行第三列的值为5

2.输出原始的数组

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

3.转为稀疏数组保存，查出有效值的个数

 //转换为稀疏数组保存
        int sum = 0;  //获取有效值的个数
        for (int i=0;i<11;i++)
        {
             for (int j=0;j<11;j++)
             {
                 if (array1[i][j]!=0)
                 {
                     sum++;   //每当数组中有值不为o的时候  说明为有效值 sum+1
                 }
             }
        }
        System.out.println("有效值得个数"+sum);

4.创建稀疏数组并实现转换

//创建一个稀疏数组的数组
        int[][] array2 = new int[sum+1][3];  //创建一个行为有效值得行+1(第一行要统计，所以+1) 列为3的稀疏数组
        array2[0][0]=11;    //第一行第一列表示总共有11行
        array2[0][1]=11;   //第二行第二列表示总共有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行第1列的值就是横坐标i 
                    array2[count][1]=j; //只要有有效值，第count行第2列的值就是纵坐标j
                    array2[count][2]=array1[i][j];  //只要有有效值，第count行第3列的值就是有效值的值
                }
            }
        }
        //输出稀疏数组
        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");
    }

5.还原，将稀疏数组还原为原始数组

//读取稀疏数组
        int[][] array3 = new int[array2[0][0]][array2[0][1]];
        //给其中的元素还原它的值
        for (int i=1;i<array2.length;i++)//因为array2第一行是声明的不用写 所以从i=1开始
        {
          array3[array2[i][0]][array2[i][1]] = array2[i][2];//相当于把稀疏数组的第i行的两列当成数组的值还原
        }
        System.out.println("输出还原的数组");
        for (int [] ints :array3)
        {
            for (int anInt : ints)
            {
                System.out.print(anInt+"\t");
            }
            System.out.println();
        }

冒泡排序详解

（时间复杂度n2）

 int emap;//定义临时容器
       int[] arrey = {1,8,9,45,6,654,68}; //随便定义一个数组
       for (int i = 0; i < arrey.length-1;i++)  //外层循环，判断我们要走多少次，因为每走一次循环只能完成一个数的正确位置，例如第一次循环实现第一个数最小，第二次实现第二个数最小..........
       {
              for (int j=0;j<arrey.length-1-i;j++)//之前判断了的就不用继续判断了，所以总长度-i
              {
                  //从小到大排序
                  if (arrey[j]>arrey[j+1])  //如果前一个数比后一个数大
                  {
                      emap = arrey[j+1];  //将后一个数赋予临时容器
                      arrey[j+1]=arrey[j];//将前一个数给后一个数
                      arrey[j]=emap;  //将临时容器中保存的后一个数的值赋予前一个数
                  }

              }
       }
        System.out.println(Arrays.toString(arrey));//Arrays.toString是Arrays类里面的一个方法，相当于把数组遍历。
    }
  

总结：

​ 稀疏数组实质其实就是两个数组之前的转换，只要搞清楚有效值所在的行和列就能完美的实现转换。如果同一个数组中拥有大量重复的数字，就可以用稀疏数组将其转换，这样转换后减轻了用户的查找，不容易漏掉导致出错！