java冒泡排序和稀疏数组

冒泡排序、稀疏数组

1.冒泡排序

两层循环，外层记录冒泡轮数，里层依次比较

时间复杂度：O(n^2)

步骤：（以升序为例）

1. 比较数组中两个相邻的元素，第一个数比第二个数大，则交换位置，依次类推完成一轮冒泡（第一轮找到了最大值，放到了数组末尾，类推）
2. 下一轮可以减少一次排序比较，因为上一轮已经确定了一个最大值，下一轮就应该除去这个数，以求剩余数的最大值，所以里层循环次数应该减去已经排好的数的个数（简单一点就是里层循环次数=数组长度-外层循环次数）
3. 依次循环，直到结束。

import java.util.Arrays;

public class Demo02 {
    public static void main(String[] args) {
        int[] a={2,5,3,8,47,14};
        int[] b= sort(a);
        System.out.println(Arrays.toString(b)); 
    }
    //冒泡排序
    //定义一个静态方法sort
    public static int[] sort(int[] a){
        int temp=0;
        for(int i=0; i<a.length-1;i++){      //记录冒泡轮数
            for(int j=0;j<a.length-1-i;j++){    //j<a.length-1-i ，这里减一是防止下标溢出，因为下面比较时有a[j+1],当													j是最后一位是溢出，所以减一
                if(a[j+1]<a[j]){
                    temp=a[j+1];
                    a[j+1]=a[j];
                    a[j]=temp;
                }
            }
        }
        return a;

        }
    }

2.稀疏数组

稀疏数组介绍

• 当一个数组中大部分元素是0后者某一个相同的值的时候，就可以用稀疏数组来保存该数组
• 稀疏数组的处理：
  • 记录数组一共有几行几列，有多少个不同的值
  • 将行数、列数、值记录在一个小数组中（相当于值的坐标表）

如和把一个数组转成稀疏数组，怎么还原？

1. 如何转？

   • 创建一个数组1（符合稀疏）

   • 遍历数组1，计算有效值个数（有效值个数是用来创建稀疏数组的，稀疏数组的行数就是有效值个数加一，见上图）

   • 创建稀疏数组，稀疏数组只有3列（行、列、值）

     array[有效值个数+1][3];
     

   • 此时再遍历数组1，找到有效值及其坐标，作为稀疏数组的元素存入

2. 如何还原？

   • 创建一个数组3，行数列数均从稀疏数组中读取，即稀疏数组的第0行的0，1列
   • 遍历稀疏数组，根据稀疏数组的坐标信息，在数组3中找到并赋值（遍历时应该从第二行开始，即下标1开始。第一行记录的是原数组的行列和有效值个数）

3. 代码

   import java.lang.reflect.Array;
   import java.util.Arrays;
   
   public class Demo01 {
       public static void main(String[] args) {
           int[][] array1 = new int[10][10];
           array1[1][2] = 1;
           array1[2][3] = 2;
           //输出原始数组array1
           System.out.println("这是原数组array1：");
           for (int[] a : array1) {
               for (int value : a) {
                   System.out.print(value + "\t");
               }
               System.out.println();
           }
   
           //创建稀疏数组
           //先找到有效数的个数，即遍历原数组
           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++;
                   }
               }
           }
           int[][] array2 = new int[count + 1][3];   //创建稀疏数组
           array2[0][0] = 10;
           array2[0][1] = 10;
           array2[0][2] = count;
   
   
           //找到每个有效数的下标
           int sum = 0;
           for (int i = 0; i < array1.length; i++) {
               for (int j = 0; j < array1[i].length; j++) {
                   if (array1[i][j] != 0) {
                       sum++;
                       array2[sum][0] = i;
                       array2[sum][1] = j;
                       array2[sum][2] = array1[i][j];
                   }
               }
           }
   
           //遍历稀疏数组
           System.out.println("这是稀疏数组===================");
           for (int[] x : array2) {
               for (int y : x) {
                   System.out.print(y + "\t");
               }
               System.out.println();
           }
   
   
           //将稀疏数组还原成原数组
           int[][] array3 = new int[array2[0][1]][array2[0][1]];
           for (int i = 1; i < array2.length; i++) {
               array3[array2[i][0]][array2[i][1]] = array2[i][2];
           }
   
   
   
           //遍历array3
           System.out.println("还原数组======================");
           for(int[] z:array3){
               for(int k:z){
                   System.out.print(k+"\t");
               }
               System.out.println();
           }
       }
   
   
   }
   
   

运行效果：