java数组：冒泡排序以及稀疏数组

冒泡排序

• 冒泡排序五一是最为出名的排序算法之一，总共有八大排序
• 冒泡的代码还是相对来说简单的两层循环，外层冒泡轮数，里层依次比较，江湖中人人尽皆知
• 我们看到嵌套循环，应该立马就可以得出这个算法的时间复杂度为O(n2)

package com.ljh.array;
import java.util.Arrays;
/**
 * 冒泡排序
 */
public class SortDemo {
    public static void main(String[] args) {
    int[] arr={1,6,2,22,66,354,88};
        System.out.println(Arrays.toString(sort(arr)));
    }
    public static int[] sort(int[] arr){
        for (int x=0;x<arr.length-1;x++){
            for (int y=0;y<arr.length-1-x;y++){
                if (arr[y]>arr[y+1]){
                    int temp=arr[y];
                    arr[y]=arr[y+1];
                    arr[y+1]=temp;
                }
            }
        }
        return arr;
    }

}

稀疏数组

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

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

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

• 如下图：左边是原始数组，右边是稀疏数组

  

接下来以此棋盘为例 来说明稀疏数组的使用

package com.ljh.array;
/**
 * 稀疏数组
 */
public class XiShuArrayDemo {
    public static void main(String[] args) {
        //1为黑棋
        //2为白棋
        int[][] arr=new int[11][11];
        arr[1][2]=1;
        arr[2][3]=2;
        int num=0;//棋盘上棋子的总数
        for (int x=0;x<arr.length;x++){
            for (int y=0;y<arr[x].length;y++){
                if (arr[x][y]!=0){
                    num++;
                }
                System.out.print(arr[x][y]+"\t");
            }
            System.out.println();
        }
        System.out.println("==================================="+num);
        //存到稀疏数组中
        int[][] arr2=new int[num+1][3];
        arr2[0][0]=11;
        arr2[0][1]=11;
        arr2[0][2]=num;
      //遍历arr 将非0的值赋值给arr2
        int count=0;
        for (int x=0;x<arr.length;x++){
            for (int y=0;y<arr[x].length;y++){
                if (arr[x][y]!=0){
                    count++;
                    arr2[count][0]=x;
                    arr2[count][1]=y;
                    arr2[count][2]=arr[x][y];
                }
            }
        }
        //赋值完成遍历稀疏数组arr2
        for (int[] ints : arr2) {
            for (int i : ints) {
                System.out.print(i+"\t");
            }
            System.out.println();
        }
        System.out.println("===================================");
        //将稀疏数组还原二维数组
        int[][] arr3=new int[arr2[0][0]][arr2[0][1]];
        //遍历稀疏数组arr2  将值赋值给arr3
        for (int x=1;x<arr2.length;x++){
        arr3[arr2[x][0]][arr2[x][1]]=arr2[x][2];
        }
        //遍历arr3
        System.out.println("===========================================");
       for (int x=0;x<arr3.length;x++){
           for (int y=0;y<arr3[x].length;y++){
               System.out.print(arr3[x][y]+"\t");
           }
           System.out.println();
       }
    }
}