2021.7.16（刷题时候的一些感悟）

旋转矩阵 

给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。

不占用额外内存空间能否做到？

示例 1:

给定 matrix = 
[
  [1,2,3],
  [4,5,6],
  [7,8,9]
],

原地旋转输入矩阵，使其变为:
[
  [7,4,1],
  [8,5,2],
  [9,6,3]
]
示例 2:

给定 matrix =
[
  [ 5, 1, 9,11],
  [ 2, 4, 8,10],
  [13, 3, 6, 7],
  [15,14,12,16]
], 

原地旋转输入矩阵，使其变为:
[
  [15,13, 2, 5],
  [14, 3, 4, 1],
  [12, 6, 8, 9],
  [16, 7,10,11]
]

思路：首先寻找以下规律，我们会发现第一行的元素，会变为最后一列的元素。第二行的变为倒数第二列的元素。但是如果不储存原来的矩阵，在发生一行改变时原来的矩阵已经被破坏，所以结果会出现错误，所以我们需要把原来的矩阵复制一遍，然后开始旋转。

代码如下

class Solution {
    public void rotate(int[][] matrix) {
        int length=matrix.length;
         int[][] matrix_new = new int[length][length];//复制矩阵
        for (int i = 0; i < length; ++i) {
            for (int j = 0; j < length; ++j) {
                matrix_new[i][j] = matrix[i][j];
            }
        }

        int p=length-1;//第二行的会变为倒数第二列，所以p作为新矩阵的列
        for(int i=0;i<length;i++)
        {
            for(int n=0;n<length;n++)
            {
                   matrix[n][p]=matrix_new[i][n];
                   
            }
            p--;
        }

    }
}

        感觉有点盲目刷题了，虽然是从数组这些简单的数据结构开始的，但是对于封装好的api函数是使的比较少 ，感觉起码要对基础常用的操作使用后再来刷题。后面将会学习更加复杂的数据结构，应该在了解之后再来刷题，我感觉那样会事半功倍。另外，也有很多东西是需要记忆的，有了充分的了解之后也需要自己不断的记忆。

二分查找：

二分查找算法思想

有序的序列，每次都是以序列的中间位置的数来与待查找的关键字进行比较，每次缩小一半的查找范围，直到匹配成功
一个情景：将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。

 

public class code
{
    public static void main(String []args){
        int[] arr = {1,3,5,5,7,9,11};
        int key = 5;
        int position = recursionBinarySearch(arr,key,0,arr.length - 1);
        if(position == -1){
            System.out.println("查找的是"+key+",序列中没有该数！");
        }else{
            System.out.println("查找的是"+key+",找到位置为："+position);
        }
    }
    public static int recursionBinarySearch(int[] arr,int key,int low,int high) {

        if(key<arr[low]||key>arr[high]||low>high)
        {
            return -1;
        }
        int middle=(low+high)/2;
        if(arr[middle]>key){
          return  recursionBinarySearch( arr,key,low,middle-1);
        }
        else if(arr[middle]<key)
        {
            return recursionBinarySearch(arr,key,middle+1,high);
        }
        else
        {
            return middle;
        }
    }


}