顺时针 逆时针排序输出类：
能将二维数组 或者 将如下结构的输入文件：
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()之后进行更改输出文件名
然后再调用排序方法。
源文件 见附件
在下露拙 有不对或者可以改进的地方 望各位大侠不吝金玉。
分享到：
相关推荐
在某些场景下，我们可能需要对二维数组进行特定的排序，例如顺时针排序或逆时针排序。顺时针排序意味着从数组的左上角开始，沿着顺时针方向依次访问元素；逆时针排序则是从左上角开始，沿着逆时针方向进行。这样的...
它的基本思想是从一个起点开始，按照顺时针或逆时针方向，依次选取与当前点距离最近的点，直到返回到起点为止。这个过程可以想象为一个虚拟的线段（包裹线）围绕着点集转动，直到完全包裹住所有点。 在POJ1113问题...
- 首先确定多边形的顶点顺序，通常按照顺时针或逆时针方向。 - 对于每个顶点，计算它与目标点之间的向量，然后与下一个顶点到目标点的向量做叉乘，得到一个角度增量Δθ。 - 如果多边形是顺时针排列，Δθ的正负...
14. 旋转图像：将矩阵顺时针或逆时针旋转90度。 15. 加一：在给定的非负整数数组表示的数上加一，考虑进位情况。 16. 爬楼梯：模拟爬楼梯过程，使用动态规划求解最小步数。 17. 灰码序列：生成n位的二进制格雷码序列...
并行计算项目 图像处理 - Android 应用 根据选定的功能以及是否单击串行/并行按钮来操作图像。 功能： 水平翻转 垂直翻转 顺时针旋转 逆时针旋转 按颜色排序 使用 Java 线程进行并行计算。
旋转图像**：这是一个二维数组操作问题，要求按照顺时针或逆时针方向旋转矩阵。Java中，可以使用两次转置的方法来实现。 11. **54. 螺旋矩阵**：题目要求按螺旋顺序返回矩阵中的所有元素。在Java中，可以利用四个...
4. **数组旋转**：将数组顺时针或逆时针旋转一定的角度，如右旋90度。 5. **双指针技术**：使用两个指针从数组两端向中间移动，常用于寻找最大/最小元素，判断回文等。 字符串是字符序列，它们在Java中是对象，基于...
例如，对一个矩阵进行顺时针或逆时针旋转，可以改变其元素的排列顺序。这样的操作可以帮助优化算法，或者解决特定问题，比如解决二维空间的问题。 在"cs260_wk2_data_twirl-master"这个压缩包中，我们可以期待找到...