一点点矩阵

73. 矩阵置0

//O(m*n) O(m+n)
var setZeroes = function(matrix) {
    let row=[]
    let col=[]
    let n=matrix.length
    let m=matrix[0].length
    for(let i=0;i<n;i++){
        for(let j=0;j<m;j++){
            if(matrix[i][j]==0){
                row.push(i)
                col.push(j)
            }
        }
    }
    for(let i of row){
        for(let j=0;j<m;j++){
            matrix[i][j]=0
        }
    }
    for(let i of col){
        for(let j=0;j<n;j++){
            matrix[j][i]=0
        }
    }
};

//O(mn) O(m+n)
var setZeroes = function(matrix) {
    let n=matrix.length
    let m=matrix[0].length
    let row=new Set()
    let col=new Set()
    for(let i=0;i<n;i++){
        for(let j=0;j<m;j++){
            if(matrix[i][j]==0){
                row.add(i)
                col.add(j)
            }
        }
    }
    for(let i=0;i<n;i++){
        if(row.has(i)){
            matrix[i].fill(0)
        } 
        for(let j=0;j<m;j++){
            if(col.has(j)){
                matrix[i][j]=0
            }
        }
    }
};

• 空间复杂度O(1)的算法
  就是把本来要存储的有0的行啊列啊都存到这个矩阵的第一行第一列
  让第一行第一列的数来决定这一行这一列要不要置0
  那万一本来第一行没有0，但是遍历完矩阵内部的值后第一行有0了，第一行就被额外置0了，所以我们要用额外的变量来存第一行/列要不要置0

var setZeroes = function(matrix) {
    let n=matrix.length
    let m=matrix[0].length
    let flagRow=false
    let flagCol=false
    for(let i=0;i<m;i++){
        if(matrix[0][i]==0){
            flagRow=true
        }
    }
    for(let i=0;i<n;i++){
        if(matrix[i][0]==0){
            flagCol=true
        }
    }
    for(let i=1;i<n;i++){
        for(let j=1;j<m;j++){
            if(matrix[i][j]==0){
                matrix[0][j]=matrix[i][0]=0
            }
        }
    }
    for(let i=1;i<n;i++){
        for(let j=1;j<m;j++){
            if(matrix[i][0]==0||matrix[0][j]==0){
                matrix[i][j]=0
            }
        }
    }
    if(flagCol){
        for(let i=0;i<n;i++){
            matrix[i][0]=0
        }
    }
    if(flagRow){
        // for(let i=0;i<m;i++){
        //     matrix[0][i]=0
        // }
        matrix[0].fill(0)
    }
};

54. 螺旋矩阵
    
    注意发现规律

var spiralOrder = function(matrix) {
    if (!matrix.length || !matrix[0].length) {
        return [];
    }
    let n=matrix.length
    let m=matrix[0].length
    let ans=[]
    let top=0,left=0
    let bottom=n-1,right=m-1
    while (left <= right && top <= bottom){
        for(let column=left;column<=right;column++){
            ans.push(matrix[top][column])
        }
        for(let row=top+1;row<=bottom;row++){
            ans.push(matrix[row][right])
        }
        if (left < right && top < bottom) {//⚠️注意这里的判断
            for(let column=right-1;column>=left+1;column--){
                ans.push(matrix[bottom][column])
            }
            for(let row=bottom;row>=top+1;row--){
                ans.push(matrix[row][left])
            }
        }
        top++
        left++
        right--
        bottom--
    }
    return ans
};

48. 旋转图像
    感觉和那个轮换数组有点像 感觉
    也是根据规律做得

var rotate = function(matrix) {
    let n=matrix.length
    for(let i=0;i<Math.floor(n/2);i++){
        for(let j=0;j<Math.floor((n+1)/2);j++){
            let tmp=matrix[i][j];
            matrix[i][j]=matrix[n-j-1][i]
            matrix[n-j-1][i]=matrix[n-i-1][n-j-1]
            matrix[n-i-1][n-j-1]=matrix[j][n-i-1]
            matrix[j][n-i-1]=tmp
        }
    }
};

240. 搜索二维矩阵
     排好序得😯

var searchMatrix = function(matrix, target) {
    let n=matrix.length
    let m=matrix[0].length
    let x=0,y=m-1
    // for(let i=0;i<n;i++){
    //     // const result=midSort(matrix[i])
    //     // if(result>=0) return true
    //     if(midSort(matrix[i],target)) return true
    // }
    // return false
    while(x<n &&y>=0){
        if(matrix[x][y]==target) return true
        if(matrix[x][y]<target){
            x++
        }else{
            y--
        }
    }
    return false
    
};

74. 搜索二维矩阵
    把矩阵扁平化，用坐标换一维索引，然后再用二分查找

var searchMatrix = function(matrix, target) {
    let n=matrix.length
    let m=matrix[0].length
    let left=0,right=n*m-1
    while(left<=right){
    let mid=Math.floor((left+right)/2)
    let [i,j]=findIndex(mid,m)
    if(matrix[i][j]>target){
        right=mid-1
    }else if(matrix[i][j]<target){
        left=mid+1
    }else return true
    }
    return false
};
const findIndex=(index,n)=>{
    return [Math.floor(index/n),index%n]
}