leetcode 54. Spiral Matrix

下面的处理是一个非常笨拙的方法：acc,  考虑边界条件，调试出现很多问题。

import java.util.ArrayList;
import java.util.List;

public class Solution {
	public static void main(String[] args){
		int num[][]  = new int[2][2];
		int cnt = 1;
		for(int i=0;i<2;i++){
			for(int j=0;j<2;j++)
				num[i][j] = cnt++;
		}
		Solution s = new Solution();
		List<Integer> res = s.spiralOrder(num);
	}
	
	
	public int move(int[][] matrix, List<Integer> res, int i, int j, boolean m_l, boolean m_r, boolean m_u, boolean m_d){
		int re = 0;
		if(m_r){
			int k;
			re = j;
			for(k=j;k<matrix[0].length;k++){
				if(matrix[i][k]!=Integer.MAX_VALUE){
					re = k;
					res.add(matrix[i][k]);
					matrix[i][k]=Integer.MAX_VALUE;
				}else{
					break;
				}
			}
		}
		if(m_l){
			int k;
			re = j;
			for(k=j;k>=0;k--){
				if(matrix[i][k]!=Integer.MAX_VALUE){
					re = k;
					res.add(matrix[i][k]);
					matrix[i][k]=Integer.MAX_VALUE;
				}
				else{
					break;
				}
			}
		}
		
		if(m_u){
			int k;
			re = i;
			for(k=i;k>=0;k--){
				if(matrix[k][j]!=Integer.MAX_VALUE){
					re = k;
					res.add(matrix[k][j]);
					matrix[k][j]=Integer.MAX_VALUE;
				}else{
					break;
				}
			}
		}
		
		if(m_d){
			int k;
			re = i;
			for(k=i;k<matrix.length;k++){
				if(matrix[k][j]!=Integer.MAX_VALUE){
					re = k;
					res.add(matrix[k][j]);
					matrix[k][j]=Integer.MAX_VALUE;
				}else{
					break;
				}
			}
		}
		return re;
	}
	
	
    public List<Integer> spiralOrder(int[][] matrix) {
        List<Integer> res = new ArrayList<Integer>();
        int m = matrix.length;    // row
        if(m==0)  return res;
        int n = matrix[0].length; // column
        System.out.print(m);
        System.out.print(n);
        //List<Integer> res = new ArrayList<Integer>();
        int s_i = 0, s_j=0;
        boolean found = true;
        boolean n_r = false;
        boolean n_l = false;
        boolean n_u = false;
        boolean n_d = false;
        if(s_i==0&&s_j==0){
        	n_r = true;
        	s_j = move(matrix,res,0,0,n_l,n_r,n_u,n_d);
        	n_r = false;
        }
        while(found){
        	    System.out.print(s_j);
        		if(s_i+1<m&&matrix[s_i+1][s_j]!=Integer.MAX_VALUE)  {
        			n_d = true;  //down
        			s_i = s_i+1;
        			s_i = move(matrix,res,s_i,s_j,n_l,n_r,n_u,n_d);
        		}
        		else if(s_i-1>=0&&matrix[s_i-1][s_j]!=Integer.MAX_VALUE)  {
        			n_u = true;  //up 
        			s_i = s_i - 1;
        			s_i = move(matrix,res,s_i,s_j,n_l,n_r,n_u,n_d);
        		}
        		else if(s_j+1<n&&matrix[s_i][s_j+1]!=Integer.MAX_VALUE)  {
        			n_r = true;  //right
        			s_j = s_j + 1;
        			s_j = move(matrix,res,s_i,s_j,n_l,n_r,n_u,n_d);
        		}
        		else if(s_j-1>=0&&matrix[s_i][s_j-1]!=Integer.MAX_VALUE)  {
        			n_l = true;  //left
        			s_j = s_j -1;
        			s_j = move(matrix,res,s_i,s_j,n_l,n_r,n_u,n_d);
        		}else{
        			found = false;
        		}
        		//if(found)
        	n_r = false;
            n_l = false;
            n_u = false;
            n_d = false;
        }
        return res;
    }
}

螺旋性转圈，还没有编译通过，草稿，设计移动规则

public class Solution {
	public void move(int[][] matrix, List<Integer> res,int i,int j, boolean m_l, boolean m_r, boolean m_u, boolean m_d){
		if(m_r){
			for(int k=j;k<matrix.length;k++){
				if(matrix[i][k]!=Integer.MAX_VALUE){
					res.add(matrix[i][k]);
					matrix[i][k]=Integer.MAX_VALUE;
				}
			}
		}
		
		if(m_l){
			for(int k=j;k>=0;k--){
				if(matrix[i][k]!=Integer.MAX_VALUE){
					res.add(matrix[i][k]);
					matrix[i][k]=Integer.MAX_VALUE;
				}
			}
		}
		
		if(m_u){
			for(int k=i;k>=0;k--){
				if(matrix[i][k]!=Integer.MAX_VALUE){
					res.add(matrix[i][k]);
					matrix[i][k]=Integer.MAX_VALUE;
				}
			}
		}
		
		if(m_d){
			for(int k=i;k<matrix.length;k++){
				if(matrix[i][k]!=Integer.MAX_VALUE){
					res.add(matrix[i][k]);
					matrix[i][k]=Integer.MAX_VALUE;
				}
			}
		}
	}
	
	
    public List<Integer> spiralOrder(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        System.out.print(m);
        System.out.print(n);
        List<Integer> res = new ArrayList<Integer>();
        int s_i = 0, s_j=0;
        res.add(matrix[0][0]);
        matrix[0][0] = Integer.MAX_VALUE;
        boolean found = true;
        boolean n_r = false;
        boolean n_l = false;
        boolean n_u = false;
        boolean n_d = false;
        while(found){
        	if(s_i==0&&s_j==0){
        		n_r = true;
        		move(matrix,res,0,1,n_r,n_l,n_u,n_d);
        	}else{
        		if(s_i+1<m&&matrix[s_i+1][s_j]!=Integer.MAX_VALUE)  {
        			n_d = true;
        			s_i = s_i+1;
        		}
        		else if(s_i-1>0&&matrix[s_i-1][s_j]!=Integer.MAX_VALUE)  {
        			n_u = true;
        			s_i = s_i - 1;
        		}
        		else if(s_j+1<n&&matrix[s_i][s_j+1]!=Integer.MAX_VALUE)  {
        			n_r = true;
        			s_j = s_j + 1;
        		}
        		else if(s_j-1<n&&matrix[s_i][s_j-1]!=Integer.MAX_VALUE)  {
        			n_l = true;
        			s_j = s_j -1;
        		}else{
        			found = false;
        		}
        		if(found) move(matrix,res,0,1,n_r,n_l,n_u,n_d);
        	}
        }
        
        
        return res;
    }
}