关于螺旋矩阵问题的新思路

	function ring(tda,column,line){
		var xmax = column - 1,             //最大的列数
			ymax = line - 1,	   //最大的行数
			xmin = 0,		   //最小的列数
			ymin = 0,		   //最小的行数
			alln = line * column,      //总共的元素
			arry = [],
			q = 0,
			i,j;
		
		while(q < alln){
			i = xmin;
			j = ymin;
			
			while(i <= xmax && q < alln)
				 arry[q++] = tda[j][i++];
			i = xmax;
			j = ++ymin;  
			
			while(j <= ymax && q < alln)
				 arry[q++] = tda[j++][i];
			i = --xmax; 
			j = ymax;
			
			while(i >= xmin && q < alln)
				 arry[q++] = tda[j][i--];
			i = xmin;
			j = --ymax; 
			
			while(j >= ymin && q < alln)
				 arry[q++] = tda[j--][i];
			
			++xmin;     
		}
		
		return arry;
	}

public class Test {

    /**
     * Create date:May 3, 2011
     * Method name:main
     * Description: [螺旋问题]
     * return:void
     */
    public static void main(String[] args) {
        LX lx = new LX(3, 5);
        lx.print();
    }

}

class LX {

    private int col;

    private int row;

    private int[][] matrix;//二维数组

    private int count = 0;
    
    private boolean flag = true;//行列
    
    private int x = 1;//增减值

    public LX(int col, int row) {
        this.col = col;
        this.row = row;
        this.matrix = new int[col][row];
        turn();
    }

    public void print() {
        for (int[] i : matrix) {
            for (int j : i) {
                System.out.format("%3d", j);
            }
            System.out.println();
        }
    }

    public void turn() {
        int i = 0;
        int j = 0;
        int end = col * row;
        while (count < end) {
            matrix[i][j] = ++count;
            if (flag) {  
                j += x;  
                // 触边转向  
                if (j < 0 || j >= row || matrix[i][j] != 0) {  
                    j -= x;
                    flag = !flag;  
                    i += x;  
                }  
            } else {  
                i += x;  
                // 触边转向  
                if (i < 0 || i >= col || matrix[i][j] != 0) {  
                    i -= x;  
                    x *= -1;//纵方向到边界
                    flag = !flag;
                    j += x;
                }  
            }  
        }
    }
}

# -*- coding:utf-8 -*-

class RotateMatrix(object):
    DIRECTION = {'LEFT':(0,-1),
                'RIGHT':(0,1),
                'UP':(-1,0),
                'DOWN':(1,0)}
    def __init__(self,x,y,algs=None):
        self.width = x
        self.height = y
        self.start = 0
        self.matrix = [['' for i in range(self.width)] 
                           for j in range(self.height)]
        self.pos = (0,0)
        if algs == None:
            self.algs = ['RIGHT','DOWN','LEFT','UP']
        else:
            self.algs = algs

    def disp(self,width=3):
        return '\n'.join([' '.join(map(lambda x:str(x).rjust(width),i)) for i in self.matrix])

    def begin(self,start,pos=(0,0)):
        self.start = start 
        self.pos = self._safepos(pos)
    def _safepos(self,pos):
        assert 0<= pos[0] < self.height
        assert 0<= pos[1] < self.width
        return pos

    def GetPosByRel(self,dx=0,dy=0):
        x,y = self.pos
        x,y = x+dx,y+dy
        if not 0<= x < self.height:
            x = self.pos[0]
        if not 0<= y < self.width:
            y = self.pos[1]
        return x,y

    def PosNotExistNumber(self,cmd):
        dx,dy = self.DIRECTION[cmd]
        x,y = self.GetPosByRel(dx,dy)
        if self.matrix[x][y] == '':
            return True
        return False

    def _SetPosByRel(self,dx=0,dy=0):
        self.pos = self.GetPosByRel(dx,dy)
    def SetPosByCMD(self,cmd):
        if self.PosNotExistNumber(cmd):
            dx,dy = self.DIRECTION[cmd]
            self._SetPosByRel(dx,dy)
            return True
        return False

    def main(self):
        self.matrix = [['' for i in range(self.width)] 
                           for j in range(self.height)]
        self.matrix[self.pos[0]][self.pos[1]] = self.start
        algs = self.algs
        while any([self.PosNotExistNumber(i) for i in algs]):
            for i in algs:
                while self.PosNotExistNumber(i):
                    self.SetPosByCMD(i)
                    self.start += 1
                    self.matrix[self.pos[0]][self.pos[1]] = self.start

if __name__ == '__main__':
    m = RotateMatrix(10,15,['LEFT','DOWN','RIGHT','UP'])
    m.begin(3,(6,7))
    m.main()
    print m.disp()
    print 
    m.begin(9,(7,7))
    m.main()
    print m.disp()