Java基础班第四天笔记

第四天总结

1. 选择排序算法

    1.1 选择排序的基本思想

            将数组中的的第一个元素与处理它之外的所有元素进行遍历比较

            如果有比它还小的，就进行交换。接下来，将第二个元素与除了它

            和第一个元素之外的所有元素进行遍历比较，如果有比它小的，就

            进行交换。依次类推。直到循环遍历结束。

    1.2 代码的体现

            1.2.1 代码示例一

                      int[] arr = {9, 8, 5, 3, 2, 1};

                      for (int i = 0; i < arr.length - 1; ++i)

                      {

                          for (int j = i + 1; j < arr.length; ++j)

                          {

                              if (arr[i] > arr[j])

                              {

                                  int temp = arr[i];

                                  arr[i] = arr[j];

                                  arr[j] = temp;

                              }

                          }

                      }

            1.2.2 代码示例二

                      发现在遍历比较的时候，数组的元素交换过于频繁。

                      为了提高效率，我们只交换数组的角标。

                      int[] arr = {9, 8, 5, 3, 2, 1};

                      for (int i = 0; i < arr.length - 1; ++i)

                      {

                          // 定义一个变量记录角标

                          int minIndex = i;

                          for (int j = i + 1; j < arr.length; ++j)

                          {

                              if (arr[i] > arr[j])

                                  minIndex = j;    // 将最小值的元素的角标记录下来

                          }

                          // 在第一轮的比较结束后直接将最小值交换到最前面

                          int temp = arr[minIndex];

                          arr[minIndex] = arr[i];

                          arr[i] = temp;

                      }

 

2. 冒泡排序算法

    2.1 冒泡排序的基本思想

             将数组中的每一个元素与它右边相邻的元素进行比较，如果左边的比右边的大

             就相互交换。这样每次循环都会将最大的那个数值沉底，从第一个元素开始，

             不断重复此操作，知道遍历结束为止。

    2.2 代码的体现

             int arr[] = {9, 8, 5, 3, 2, 1};

             for (int i = 0; i < arr.length - 1; ++i)

             {

                 for (int j = 0; j < arr.length - 1 - i; ++j)

                 {

                     if (arr[j] > arr[j + 1])

                 
4000
    {

                         int temp = arr[j];

                         arr[j] = arr[j + 1];

                         arr[j + 1] = temp;

                     }

                 }

             }

 

3. 二分查找(折半查找)算法

    3.1 二分查找的基本思想

             将数组折半取出中间元素与需要查找的数值进行比较，如果大于中间的元素

             就将查找范围变为中间元素后一个元素到数组末尾的元素，如果小于中间的元素

             将查找范围变为数组第一个元素到中间元素的前一个元素，继续折半，然后比较

             依次类推，知道找到或者没有了查找范围。

    3.2 代码的体现

             public static int binarySearch(int[] arr, int key)

             {

                 // 左角标

                 int start = 0;

                 // 右角标

                 int end = arr.length - 1;

                 // 中间角标

                 int mid;

                

                 while (start <= end)

                 {

                     // 对角标进行折半

                     mid = (start + end) >> 1;

                     // 比较需要查找的值与中间值

                     if (key < arr[mid])

                         end = mid - 1;

                     else if (key > arr[mid])

                         start = mid + 1;

                     else

                         return mid;

                 }

                 return -1;

             }

    3.3 二分查找的另一种用途

             需求：在一个有序的数组中插入一个值，并且保证这个数组仍然是有序的。

             分析：发现，如果在查找时指定的需要查找的数值没有找到，左角标变量都会指向该没有找到的变量

                   应该插入的位置。所以，如果容器的长度是可以改变的，就可以将需要插入的位置之后的元素

                   全部向后移动一位置，然后在把这个需要插入的数值插入到左角标变量的角标位置。

    3.4 二分查找的注意事项

             a.操作的数组必须是有序的。

             b.在折半的时候，折半的是数组的角标，

               不是元素。应为只有角标是固定不变的。

 

4. Java提供的算法和一些常用的方法

    4.1 Java为我们提供了一些常用的算法和方法

            Arrays.sort             排序

            Arrays.binarySearch     二分查找

            Integer.toBinaryString  将传入的十进制转成二进制，返回字符串

            Integer.toHexString     将传入的十进制转成十六进制，返回字符串

            Integer.toOctalString   将传入的十进制转成八进制，返回字符串

           

5. 数组的应用

    5.1 什么时候需要使用数组或者容器呢？

             当数据多的时候，先将这些数据都存储起来，在进行使用。

    5.2 查表法

            其实就是在使用容器，当对需求进行分析时，发现需求存在映射关系时，

            就可以使用容器。数组映射关系的一方是数字(角标)。同时数据的个数

            必须是固定的。

    5.3 查表法举例

            a.用户输入一个数字，判断是星期几。

                public static String getWeek(int week)

                {

                    if (week < 1 || week > 7)

                        return "输入有误";

                    String[] weeks = {

                        "", "星期一", "星期二", "星期三",

                            "星期四", "星期五", "星期六",

                            "星期日"

                    };

                    return weeks[week];

                }

            b.进制转换

                    public static String toBinaryString(int num)

                    {

                        return trans(num, 2, 1);

                    }

                    public static String toOctalString(int num)

                    {

                        return trans(num, 8, 3);

                    }

                    public static String toHexString(int num)

                    {

                        return trans(num, 16, 4);

                    }

                    // 将进制转换封装起来

                    public static String trans(int num, int sys, int offset)

                    {

                        String str = "";

                        // 进制查询表,十进制，二进制，八进制，十六进制都适用。

                        char[] table = {

                            '0', '1', '2', '3', '4', '5', '6',

                            '7', '8', '9', 'A', 'B', 'C', 'D',

                            'E', 'F'

                        };

                        while (num != 0)

                        {

                            str = table[num % sys] + str;

                            num >>= offset;

                        }

                        return str;

                    }

 

6. 二维数组

    6.1 概念

            二维数组是数组中的数组，也就是说一个一维数组中的所有元素都是一个一维数组。

            可以将二维数组想象成一个矩阵。第一维是行，第二维是列。

    6.2 二维数组的定义

            6.2.1 格式

                       数据类型[][] 数组名 = new 数据类型[第一维度][第二维度];

                       // 第二维度可以不明确，但是第一维度必须明确

                       数据类型[][] 数组名 = new 数据类型[第一维度][];

            6.2.2 示例详解

                       (一).int[][] arr1 = new int[4][3];    // 定义了一个二维数组，该二维数组中

                                                             // 有4个一维数组，每个一维数组中有

                                                             // 3个元素。

                             System.out.println(arr1[0][0]);     // 打印0号角标数组的0号角标元素

                             System.out.println(arr1[0]);        // [I@64883c  数据类型@哈希值   [表示一维数组

                             System.out.println(arr1);           // [[I@2c1e6b  数据类型@哈希值  [[代表二维数组

                             System.out.println(arr1.length);    // 打印的是二维数组中有多少个一维数组

                             System.out.println(arr1[0].length); // 打印0号角标数组(第一个数组)中有多少个元素

                       (二).int[][] arr2 = new int[4][];    // 第二维没有明确

                            System.out.println(arr2[0]);    // 因为第二维没有明确所以是null

                            System.out.println(arr2[0][0]); // NullPointerException异常。

                            // 可以使用这样的方法来创建不规则数组

                            arr2[0] = new int[4];

                            arr2[1] = new int[2];

                            arr2[2] = new int[5];

                            arr2[3] = new int[1];

                            // 也可以使用这种方法来创建不规则数组

                            int[][] arr2 = new int[][] {{1, 2, 3}, {4, 5}, {8, 9, 10 ,11}};

                            // 或者简写成

                            int[][] arr2 = {{1, 2, 3}, {4, 5}, {8, 9, 10 ,11}};

            6.2.3 定义二维数组的一种特殊写法

                      int[] arr1, arr2[]; // arr1是一维数组，arr2是二维数组。不要这样写，容易误解

    6.3 二维数组在内存中的体现

            int[][] arr = new int[4][3];

            执行该语句后，会在栈内存中为arr创建一段内存空间，然后会在堆内存中为二维数组创建一段

            内存空间并且为每个元素初始化为null,然后在堆内存中依次为三个一维数组分配内存，并且

            将所有元素初始化。然后依次将这些一维数组的内存地址赋给二维数组的元素中，然后将二维数组

            的内存地址赋给arr，arr指向二维数组的首地址。

           

7. 多维数组

    7.1 概述

            理论上来说数组的维度是可以定义任意维度的，但是为了运行效率和代码的阅读性，

            建议数组的维度大小不要超过三维

    7.2 三维数组

            int[][][] arr3 = new int[3][][]; // 定义了一个三维数组，该三维数组中有3个二维数组

                                             // 每个二维数组中的一维数组个数不明确

                                             // 每个一维数组中的元素个数不明确

            int[][][] arr4 = new int[3][4][]; // 定义了一个三维数组，该三维数组中有3个二维数组

                                              // 每个二维数组中有四个一维数组

                                              // 每个一维数组中的元素个数不明确 

                                             

            int[][][] arr5 = new int[3][5][6]; // 定义了一个三维数组，该三维数组中有3个二维数组

                                               // 每个二维数组中有五个一维数组

                                               // 每个一维数组中有6个元素