Java学习笔记（一）-- 算法及其他

Java学习笔记（一）-- 算法及其他

冒泡排序

思想:

从前到后（即从下标较小的元素开始）依次比较相邻元素的值，若发现逆序则交换位置，使值较大的元素逐渐从前移向后部。

**eg:**待排序的数：7,3,22,15,8

根据冒泡排序的思想：

1. 首先我们应该比较7和3是否是逆序的：若逆序则交换这2个数的位置，因为7>3，它们的位置是逆序的故交换位置交换后：7,3, 22,15,8 -> 3,7,22,15,8
2. 比较7和22是否是逆序的：若逆序则交换这2个数的位置，因为7<22，它们的位置是顺序的。故不用交换位置顺序仍为：3,7,22, 15,8 -> 3,7,22, 15,8
3. 以此类推，思路分析会进行详细分析。

public class BubbleSort {
    //排序
    public static int[] sort(int[] array){
        //定义临时交换变量
        int temp=0;

        //外层循环，从头走到数组长度-1
        for (int i = 0; i <array.length-1 ; i++) {

            //内层循环，判断两个数大小，前一个数大于后一个数，则交换位置
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;
                }
            }
        }
        return array;
    }
}

设置flag

如果在一次循环后数据已经正常排列，不需要再交换数字位置，可以通过设置flag跳出外层循环。

public class BubbleSort {
    //排序
    public static int[] sort(int[] array){
        //定义临时交换变量
        int temp=0;

        boolean flag=false;
        //外层循环，从头走到数组长度-1
        for (int i = 0; i <array.length-1 ; i++) {

            flag=false;
            //内层循环，判断两个数大小，前一个数大于后一个数，则交换位置
            for (int j = 0; j <array.length-1-i ; j++) {
                if (array[j]>array[j+1]){
                    temp=array[j];
                    array[j]=array[j+1];
                    array[j+1]=temp;

                    flag=true;
                }
            }
            if (flag){
                break;
            }
        }
        return array;
    }
}

稀疏数组

定义

稀疏数组可以看做是普通数组的压缩，但是这里说的普通数组是值无效数据量远大于有效数据量的数组。原数组在个别数据不一样，其他数据都一样（如0）的情况。

• 这些大量无效数据造成保存原数组时，占据大量的存储空间。
• 压缩存储可以节省存储空间以避免资源的不必要的浪费，在数据序列化到磁盘时，压缩存储可以提高IO效率。

              0 0 0 0 0 0 0 0 0 0 0
              0 0 1 0 0 0 0 0 0 0 0
              0 0 0 2 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 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

稀疏数组存储方式

1. 普通存储

   第一行存储原始数据总行数，总列数，总的非0数据个数。

   接下来每一行都存储非0数所在行，所在列，和具体值。

   行（row）	列(col)	值(value)
   11	11	2
   2	2	1
   3	3	2

2. 链式存储

		0 0 0 0 
        0 1 0 0
        0 0 2 0
        0 0 3 0

a.普通链式存储

b.行式链式存储

c.十字链式存储

普通存储Java实现

将原数组转成稀疏数组

		/**
        * 稀疏数组
        * <p>
        *     11 11 2
        *     1  2  1
        *     2  4  2
        * </p>
        */
        public int[][] sparseArrayTo(int[][] array){
            int[][] sparseArray=null;
            if (array!=null && array.length>0&& array[0].length>0) {
                //得到非0数据数
                int sum = 0;
                for (int i = 0; i < 11; i++) {
                    for (int j = 0; j < 11; j++) {
                        if (array[i][j] != 0) {
                            sum++;
                        }
                    }
                }
                //创建稀疏数组
                sparseArray = new int[sum + 1][3];
                //给稀疏数组赋值
                sparseArray[0][0] = array.length;
                sparseArray[0][1] = array[0].length;
                sparseArray[0][2] = sum;
                //将非0的数放入稀疏数组
                //count：标识第几个非0数
                int count = 0;
                for (int i = 0; i < array.length; i++) {
                    for (int j = 0; j < array[i].length; j++) {
                        if (array[i][j] != 0) {
                            count++;
                            sparseArray[count][0] = i;
                            sparseArray[count][1] = j;
                            sparseArray[count][2] = array[i][j];
                        }
                    }
                }

            }
            return sparseArray;
        }

将稀疏数组还原为原数组

		/**
         * 恢复的二维数组
         * <p>
         *     0 0 0 0 0 0 0 0 0 0 0
         *     0 0 1 0 0 0 0 0 0 0 0
         *     0 0 0 0 2 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 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
         * </p>
         */
        public int[][] restoreArray(int[][] sparseArray){
            int[][] oldArray=null;
            if (sparseArray !=null){
                oldArray= new int[sparseArray[0][0]][sparseArray[0][1]];
                //将原来非0的数填充回去
                for(int i = 1;i<sparseArray.length;i++){
                    oldArray[sparseArray[i][0]][sparseArray[i][1]] = sparseArray[i][2];
                }
            }
            return oldArray;

        }