java 旋转排序 -- 顺时针排序 逆时针排序

顺时针 逆时针排序输出类：

能将二维数组 或者 将如下结构的输入文件：

12,2 ,11,8 ,17
1 ,13,3 ,9 ,18
4 ,10,16,7 ,19
5 ,15,14,6 ,20
25,23,24,21,22

输出成：

1、从里往外 逆时针

25,	24,	23,	22,	21
10,	9,	8,	7,	20
11,	2,	1,	6,	19
12,	3,	4,	5,	18
13,	14,	15,	16,	17

2、从里往外 顺时针

25,	10,	11,	12,	13
24,	9,	2,	3,	14
23,	8,	1,	4,	15
22,	7,	6,	5,	16
21,	20,	19,	18,	17

3、从外往里 逆时针

1,	16,	15,	14,	13
2,	17,	24,	23,	12
3,	18,	25,	22,	11
4,	19,	20,	21,	10
5,	6,	7,	8,	9

4、从外往里 顺时针

1,	2,	3,	4,	5
16,	17,	18,	19,	6
15,	24,	25,	20,	7
14,	23,	22,	21,	8
13,	12,	11,	10,	9

本类的方法支持N*M的矩阵结构，有可能有的边界值没作验证，常见的矩阵都能正常工作，
用来做笔试题或者考试题还是可以的。

代码如下（同时提供源文件 见附件）：
功能实现类：

package exericse.two;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.Arrays;

/**
 * 本类是将一个二维数组里的元素从小到大按照顺时针或者逆时针旋转输出
 * 
 * @author panyin
 * 
 */
public class RingSort
{
    // 一维数组
    private int[] intArr;
    
    // 二维数组
    private int[][] int2Arr;
    
    // 横坐标的做大值
    private int xmax;
    
    // 纵坐标的最大值
    private int ymax;
    
    // 横坐标的做小值
    private int xmin = 1;
    
    // 纵坐标的做小值
    private int ymin = 0;
    
    // i一维数组下标 x y二维数组的横坐标和纵坐标
    private int i, x = 0, y = 0;
    
    private boolean isSomethingWrong = false;
    
    
    private boolean inoutControl = false;

    // 0从外往里旋 1从里往外旋
    private int inoutFlag = 0;
    
    private String outputFileName = "output.txt";
    
    /**
     * 排序方法
     * 
     * @return 旋转好的二维数组
     */
    public int[][] sort2Ring(int[][] tempArr, int flag, int inoutFlag)
    {
        this.inoutFlag = inoutFlag;
        
        if (flag == 1)
        {
            xmin = 0;
            ymin = 1;
        }
        this.xmax = tempArr.length - 1;
        this.ymax = tempArr[0].length - 1;
        this.int2Arr = tempArr;
        
        arr2to1();
        
        if (inoutFlag == 1)
        {
            i = intArr.length - 1;
            inoutControl = i >= 0;
        }
        else
        {
            i = 0;
            inoutControl = i < intArr.length;
        }
        
        // 逆时针旋转
        if (flag == 1)
        {
            anticlockwise();
        }
        
        // 顺时针旋转
        else
        {
            clockwise();
        }
        
        if (isSomethingWrong)
        {
            return null;
        }
        
        output2File();
        
        return int2Arr;
    }
    
    public void sort2Ring(String fileName, int flag, int inoutFlag)
    {
        this.inoutFlag = inoutFlag;
        
        if (flag == 1)
        {
            xmin = 0;
            ymin = 1;
        }
        
        intArr = stringArr2IntArr(readFile2Arr(fileName));
        
        if (inoutFlag == 1)
        {
            i = intArr.length - 1;
            inoutControl = i >= 0;
        }
        else
        {
            i = 0;
            inoutControl = i < intArr.length;
        }
        
        this.int2Arr = new int[xmax + 1][ymax + 1];
        
        // 逆时针旋转
        if (flag == 1)
        {
            anticlockwise();
        }
        
        // 顺时针旋转
        else
        {
            clockwise();
        }
        
        output2File();
    }
    
    private String[] readFile2Arr(String fileName)
    {
        BufferedReader br = null;
        String[] strArr = null;
        try
        {
            br = new BufferedReader(new FileReader(fileName));
            String temp = null;
            
            StringBuilder sb = new StringBuilder();
            temp = br.readLine();
            
            if (temp == null)
            {
                isSomethingWrong = true;
            }
            
            while (null != temp)
            {
                if (!temp.trim().equals(""))
                {
                    sb.append(temp + ",");
                }
                // 读文件中的下一行
                temp = br.readLine();
                
                if (null != temp && !temp.trim().equals(""))
                {
                    ymax = temp.split(",").length - 1;
                    xmax++;
                }
                
            }
            
            strArr = sb.toString().substring(0, sb.toString().length() - 1).split(",");
        }
        catch (IOException e)
        {
            return null;
        }
        finally
        {
            try
            {
                br.close();
            }
            catch (IOException e)
            {
                isSomethingWrong = true;
            }
        }
        
        return strArr;
        
    }
    
    // 将String数组转换成int数组 转换出错者返回null
    public int[] stringArr2IntArr(String[] strArr)
    {
        int[] inArr = new int[strArr.length];
        for (int i = 0; i < strArr.length; i++)
        {
            try
            {
                inArr[i] = Integer.parseInt(strArr[i].trim());
            }
            catch (NumberFormatException e)
            {
                isSomethingWrong = true;
            }
        }
        
        Arrays.sort(inArr);
        
        return inArr;
    }
    
    // 将入参的二维数组放进一维数组里并排序
    private void arr2to1()
    {
        intArr = new int[(xmax + 1) * (ymax + 1)];
        int m = 0;
        for (int k = 0; k <= xmax; k++)
        {
            for (int j = 0; j <= ymax; j++)
            {
                intArr[m++] = int2Arr[k][j];
                int2Arr[k][j] = 0;
            }
        }
        Arrays.sort(intArr);
    }
    
    private void anticlockwise()
    {
        while (i < intArr.length)
        {
            up2down();
            left2right();
            down2up();
            right2left();
            if (xmax == xmin || ymax == ymin)
            {
                int2Arr[x][y] = intArr[i];
                break;
            }
            changeLocation();
        }
    }
    
    private void clockwise()
    {
        while (i < intArr.length)
        {
            left2right();
            up2down();
            right2left();
            down2up();
            if (xmax == xmin || ymax == ymin)
            {
                int2Arr[x][y] = intArr[i];
                break;
            }
            changeLocation();
        }
    }
    
    // 从上到下
    private void up2down()
    {
        while (x < xmax && inoutControl)
        {
            int2Arr[x++][y] = intArr[i];
            if (inoutFlag == 0)
            {
                i++;
            }
            else
            {
                i--;
            }
        }
        
    }
    
    // 从左到右
    private void left2right()
    {
        while (y < ymax && inoutControl)
        {
            int2Arr[x][y++] = intArr[i];
            if (inoutFlag == 0)
            {
                i++;
            }
            else
            {
                i--;
            }
        }
        
    }
    
    // 从下到上
    private void down2up()
    {
        while (x > xmin && inoutControl)
        {
            int2Arr[x--][y] = intArr[i];
            if (inoutFlag == 0)
            {
                i++;
            }
            else
            {
                i--;
            }
        }
        
    }
    
    // 从右到左
    private void right2left()
    {
        while (y > ymin && inoutControl)
        {
            int2Arr[x][y--] = intArr[i];
            if (inoutFlag == 0)
            {
                i++;
            }
            else
            {
                i--;
            }
        }
        
    }
    
    private void changeLocation()
    {
        xmax--;
        ymax--;
        xmin++;
        ymin++;
    }
    
    private void output2File()
    {
        try
        {
            FileWriter fw = new FileWriter(outputFileName);
            StringBuilder sb = new StringBuilder();
            if (isSomethingWrong)
            {
                sb.append("input error!");
            }
            else
            {
                for (int j = 0; j < int2Arr.length; j++)
                {
                    for (int k = 0; k < int2Arr[0].length; k++)
                    {
                        sb.append(int2Arr[j][k]);
                        if (k < int2Arr[0].length - 1)
                        {
                            sb.append(",\t");
                        }
                    }
                    sb.append("\n");
                }
            }
            
            fw.write(sb.toString());
            fw.flush();
            fw.close();
            
            System.out.println(sb.toString());
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    /**
     * 返回 outputFileName
     * @return outputFileName
     */
    public String getOutputFileName()
    {
        return outputFileName;
    }

    /**
     * 对outputFileName进行赋值
     * @param outputFileName 对outputFileName进行赋值
     */
    public void setOutputFileName(String outputFileName)
    {
        this.outputFileName = outputFileName;
    }
    
}

简单验证类：

package exericse.two;

public class TestRingSort
{
    
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        
        // 可以传二维数组或者直接传文件名既可
        boolean isFileTest = true;
        
        String fileName = "input.txt";
        
        // 旋转方法 0为顺时针 1为逆时针 如果是从里往外则相反
        int flag = 0;
        
        // 0从外往里旋 1从里往外旋
        int inoutFlag = 0;
        
        if (isFileTest)
        {
            new RingSort().sort2Ring(fileName, flag, inoutFlag);
        }
        else
        {
            int xmax = 5, ymax = 5;
            int[][] int2Arr = new int[xmax][ymax];
            int m = 1;
            for (int j = 0; j < int2Arr.length; j++)
            {
                for (int k = 0; k < int2Arr[0].length; k++)
                {
                    int2Arr[j][k] = m++;
                }
            }
            
            new RingSort().sort2Ring(int2Arr, flag, inoutFlag);
            
        }
    }
}

说明：
功能类支持文件和二维数组两种入参
验证类中可以 isFileTest 来选择验证哪种入参验证
input.txt放在工程下就可以
程序会有控制台和文件输出两种结果
输出文件默认为output.txt 可以再 new RingSort()之后进行更改输出文件名
然后再调用排序方法。

源文件 见附件

在下露拙 有不对或者可以改进的地方 望各位大侠不吝金玉。