数组与排序

1.数组概念
数组是一个线性的存储结构（容器）。
数组在内存中是一个连续的存储空间。
数组智能存储固定的某一种数据类型。

2.一维数组定义与使用
定义一维数组的方式：
数据类型 [] 数组名 = new 数据类型[长度];
int [] array = new int[10];
int value = array[0];  //0
Student [] array = new Student[10];
Student value = array[0];  //null

数据类型 [] 数组名 = {值,...};

数据类型 [] 数组名 = new 数据类型[]{值,...};

数据类型 [] 数组名 ;
数组名 =  new 数据类型[长度];

数组有哪些方法和属性呢？
length属性，用来获取数组容器中能存储元素的总数（是从1开始计算的）
数组的下标是从0开始计算的

获取数组能存储元素的总数：int length = 数组名.length;
得到下标为1位置的元素内容：数据类型 变量名 = 数组名[下标];

3.二维数组定义与使用
定义二维数组的方式：
数据类型 [][] 数组名 = new 数据类型[行][列];

数据类型 [][] 数组名 = {{值,...},...};

数据类型 [][] 数组名 = new 数据类型[][]{{值,...},...};

数据类型 [][] 数组名 ;
数组名 =  new 数据类型[行][列];

二维数组有哪些方法和属性呢？
只有length属性
获取二维数组的行数：int row = array.length;
获取二位数组某一个行的列数：int column = new array[下标].length;

得到二维数组某一个单元格的元素值：int value = array[row][column];
/**
* 一维数组的创建与排序方法
*/
public class OneArray {

/**
* 程序入口的主函数
*/
public static void main(String[] args) {
OneArray array=new OneArray();//实例化一个OneArray类的对象
int [] arr=array.createArray(30);//调用创建一维数组的方法来创建一个有30个元素的以为数组
System.out.print("原始数组元素如下：");
printArray(arr);

int [] temp=array.BubbleSort(arr);
System.out.println("");
System.out.print("冒泡排序后数组元素如下：");
printArray(temp);

ChooseSort(arr);
System.out.println("");
System.out.print("选择排序后数组元素如下：");
printArray(arr);

ShellSort(arr);
System.out.println("");
System.out.print("希尔排序后数组元素如下：");
printArray(arr);

InsertSort(arr);
System.out.println("");
System.out.print("插入排序后数组元素如下：");
printArray(arr);
}

/**
*创建一维数组的方法
*/
public static int [] createArray(int length){
int [] array=new int[length];//创建一个一维数组
for(int i=0;i<array.length;i++){
int rand=new Random().nextInt(1000);//产生一个0-1000的随机整数
array[i]=rand;//用循环遍历数组的每个位置并且给每个位置填上一个随机值
}
return array;
}

/**
* 打印数组元素的方法
*/
public static void printArray(int [] array){
if(array==null){return;}//如果要打印的数组为null，则不打印
for(int i=0;i<array.length;i++){
if(i%10==0)System.out.println(""); //控制没输出10个元素就换行输出
System.out.print(array [i]+"\t");//用循环遍历每个元素并且输出
}
}

/**
* 冒泡排序法
* 冒泡排序算法的运作如下：
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。[1]
*/
public int [] BubbleSort(int [] x){
for(int i=0;i<x.length;i++){
for(int j=i+1;j<x.length;j++){
if(x [i]>x [j]){
int temp=x [i];//定义一个中间变量存放两个元素中较大的值
x [i]=x [j];//将两个元素中值较小的元素赋给数组中下表较小的元素
x [j]=temp;//将两个元素中值较大的元素赋给数组中下标较大的元素
}
}
}
return x;
}

/**
* 选择排序法
*/
public static int [] ChooseSort(int [] arr){
for(int i=0;i<arr.length;i++){
int lowerIndex=i;//找出最小的一个索引
for(int j=i+1;j<arr.length;j++){
if(arr [j]<arr [lowerIndex]){lowerIndex=j;}
}
int temp=arr [i];  //交换
arr [i]=arr [lowerIndex];
arr [lowerIndex]=temp;
}
return arr;
}

/**
* 希尔排序法
*/
public static int [] ShellSort(int [] x){
//进行分组
for(int incre=x.length/2;incre>0;incre=incre/2){
//再每个组内进行排序
for(int i=incre;i<x.length;i++){
int temp=x[i];
int j=0;
for(j=i;j>=incre;j-=incre){
if(temp<x[j-incre]){
x[j]=x[j-incre];
}else{break;}
}
}
}
return x;
}

/**
* 插入排序法
*/
public static int [] InsertSort(int [] x){
for(int i=1;i<x.length;i++){
for(int j=i;j>0;j--){
if(x[j]<x[j-1]){
int temp=x[j];
x[j]=x[j-1];
x[j-1]=x[j];
}
}
}
return x;
}

}

/**二维数组*/
public class TwoArray {

/**
* 二位数组的创建与排序
*/
public static void main(String[] args) {
int [][] arr=new int [10][10];
for(int i=0;i<arr.length;i++){
for(int j=0;j<arr[i].length;j++){
int rand=new Random().nextInt(200)+100;//产生一个100-300之间的随机整数
arr [i][j]=rand;
}
}
printArray(arr);
maxArray(arr);
}


/**
* 定义打印数组的方法
*/
public static void printArray(int [][] x){
if(x==null){return;}//若数组为空，则不打印
for(int i=0;i<x.length;i++){
for(int j=0;j<x [i].length;j++){
if(j%10==0) {System.out.println("");}//没输出10个元素就换行
System.out.print(x [i][j]+"\t");
}
}
}

/**
* 找出二维数组最大元素的方法
*/
public static void maxArray(int [][] x){
int max=x [0][0];//设二维数组中的第一个为最大的值
int h=0;int k=0;
for(int i=0;i<x.length;i++){
for(int j=0;j<x[i].length;j++){
if(x[i][j]>=max){
max=Math.max(max, x[i][j]);
h=i;k=j;
}
}

}
System.out.println("");
System.out.println("二维数组中最大值为："+max+"    位于数组的第"+(h+1)+"行         第"+(k+1)+"列");
System.out.println("");
}
}