数组排序

                                                 数组联想

首先既然讲到数组，那我们来讲讲，数组有什么优点呢？
  按照下标顺序或者直接指定的下标，访问读取的速度效率高。
 数组有什么缺点呢？
  内存空间在定义的时候就固定了，不能改变内存大小。
 数组是属于什么数据类型的?
  Java
   基本数据类型
   引用类型（对象类型，类类型）
   class,interface,abstract class,数组
  String [] array = new String[10];
  Student stu = new Student();
 数组有哪些属性和方法？
  数组只有一个唯一的属性length。
我们在刚刚学习编程语言时，不论是C，C++，还是java，最先接触的毕竟是数组，先不要管后面出现的链表，栈，队列，之所以选择数组，主要还是数组是这些以后的基础，而且在大学的学生基本都学过线性代数，它十分类似于矩阵，因此在两相结合起来，更利于理解，在平时代码编辑中，一般来说，只要我大概能估算出我做需要的内存，基本还是会采用数组。

在学习过程中，觉得比较容易犯错的还是一下几点：

二维数组举例：获取二维数组的总行数：数组名.length;
  获取二维数组的每一行的列数：数组名[行下标].length;
说到一维数组，大家都会想到历史上各种有名的排序方法，像冒泡排序，快速排序，希尔排序，插半排序等等，无非在效率，时间，稳定性下手，当然其中冒泡排序法虽然称为最为繁琐的排序方法但是确实新手上手最容易理解的，之后的快速排序是对冒泡的改进一下是用快速排序做的一维数组排序代码：

 

public class Array {
	public static void main(String args[]){
		Array zyy=new Array();
		int[] array=zyy.creatArray(50);
		display(array);//打印数组
		System.out.print("\n");
		quickSort(array,0,49);//快速排序0-49
		display(array);//打印数组
		
		
	}
	public int[] creatArray(int size){
		int[] array=new int[size];
		Random random=new Random();//初始化随机数
		//遍历赋值
		for(int i=0;i<array.length;i++){
			array[i]=random.nextInt(50);
			
			
		}
		return array;
	}
	public static void quickSort(int array[], int start, int end)
	{        int i,j;
	         i = start;
	         j = end;
	         if((array==null)||(array.length==0))
	             return;
	         while(i<j){
	             while(i<j&&array[i]<=array[j]){     //以数组start下标的数据为key，右侧扫描
	                 j--;
	             }
	             if(i<j){                   //右侧扫描，找出第一个比key小的，交换位置
	                 int temp = array[i];
	                 array[i] = array[j];
	                 array[j] = temp;
	             }
	              while(i<j&&array[i]<array[j]){    //左侧扫描（此时a[j]中存储着key值）
	                 i++;
	               }
	             if(i<j){                 //找出第一个比key大的，交换位置
	                 int temp = array[i];
	                 array[i] = array[j];
	                 array[j] = temp;
	             }
	        }
	        if(i-start>1){
	             //递归调用，把key前面的完成排序
	            quickSort(array,start,i-1);
	        }
	        if(end-i>1){
	            quickSort(array,i+1,end);    //递归调用，把key后面的完成排序
	        }
	}
	public static void display(int[] array){
		for(int i=0;i<array.length;i++){
			System.out.print(array[i]+"\t");
			
		}
		
	}

}

 

 出来的效果是这样，不过每次不同：

 

21 6 7 44 25 1 48 0 5 48 37 24 40 1 1 44 2 2 4 19 35 14 12 25 11 3 21 0 14 39 0 32 27 13 23 16 20 0 49 42 9 32 49 34 44 47 15 46 33 13 
0 0 0 0 1 1 1 2 2 3 4 5 6 7 9 11 12 13 13 14 14 15 16 19 20 21 21 23 24 25 25 27 32 32 33 34 35 37 39 40 42 44 44 44 46 47 48 48 49 49

 

之后就是二维数组，二维数组与一维数组在方法使用以及定义都是换汤不换药，有着异曲同工之妙

 

 

 

 

import java.util.Random;
public class Array2 {
	public static void main(String args[]){
		Array2 yy=new Array2();
		int[][]array=yy.creatArray(3, 3);
		yy.print(array);
		yy.bigSort(array);
		
		
	}
	public int[][] creatArray(int Row,int Column){
		int[][] array=new int[Row][Column];//实例化一个int[][]型的数组对象
		Random random=new Random();//实例化一个随机数列对象
		//遍历二维数组赋值
		for(int i=0;i<array.length;i++){
			for(int j=0;j<array[i].length;j++){
				array[i][j]=random.nextInt(100);//将二维数组随机赋值为0-99的值
			}
		}
		return array;
		
	}
	public void bigSort(int array[][]){
		int max=array[0][0],m = 0,n=0;//设立max为第一行第一列个值，m，n记录行列数
		for(int i=0;i<array.length;i++){
			for(int j=0;j<array[i].length;j++){
				if(max<array[i][j]){
					max=array[i][j];
					m=i;
					n=j;
				}
			}
		}
		System.out.print("\n最大的数是"+max+"\t出现的位置是"+m+"行"+n+"列");
	}
	public void print(int array[][]){
		for(int i=0;i<array.length;i++){
			for(int j=0;j<array[i].length;j++){
			
			System.out.print(array[i][j]+"\t");
			if(j==array[i].length-1){
				System.out.print("\n");
			}
			}
		}
	}

}

 

结果：

60 73 24 
82 59 74 
41 20 39 

最大的数是82 出现的位置是1行0列