标签：数组下标 heap 存储器 oat 初始化 fbo bounds es2017 分配
一、数组的定义
三种定义方法:
int b[]=new int[5];
Int []b=new int[5];
int[] a=new int[5]; (建议使用这种定义方法) //必须规定数组长度，因为在编译的时候就要分配内存。
我们也可以在定义的时候就初始化数组
Int[] a={1,2,3,3,5};
这默认了数组a的长度是5.
分配内存详情如下：
开辟一块内存，有5个小块，a指向数组的首地址。
int[][] b=new int[5][]; //至少确定第一维的个数(即数组行数)才不会提示有错。第二维的个数可以暂时不固定。
int[][][] b=new int[5][][]; 同理三维数组长度也至少确定第一维的个数才不会提示有错。也可以确定一二维的个数，int[][][] b=new int[5][4][]; 但是无法单跨维确定，例如int[][][] b=new int[5][][5];
二、数组的遍历。
①只有确定了所有维数去遍历一个数组才不会报错。
②数组下标从0开始，到n-1结束(n为该维长度)。比如int[] s=new int[3]。这个数组长度为3，s[0],s[1],s[2]就是这三个值，访问s[3]是会报错的，报数组越界异常java.lang.ArrayIndexOutOfBoundsException。
为什么是0开始呢？跟外国人建房子习惯有关，因为外国人建房子都会建地下室，地下室不就是0层了(地下一层也叫地上0层，因为在地上一层的下一层)。
③没有初始化的时候，int数组所有元素值为0，float、double所有元素值为0.0，String所有元素值为null。Char所有元素都是一个空格(而不是什么都没有)。
④ char[] c=new char[a]; //a为已知常数
遍历方式一(for循环，用int变量控制)：
for(int i=0;i<a;i++){
System.out.println(c[i]);
}
遍历方式二(for循环)：
for(char p:c){
System.out.println(p);
}
char[][] c=new char[a][b]; //a,b为已知常数
遍历方式一(for循环，用int变量控制)：
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
System.out.println(c[i][j]);
}
}
遍历方式二(for循环)：
for(char i[]: c){
for(char j:i){
System.out.println(j);
}
}
三、排序
1.排序法种类:
内部排序: 指将需要处理的所有数据都加载到内部存储器中进行排序。(包括交换式排序法、选择式排序法、插入式排序法)
外部排序: 数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。(包括合并排序法和直接合并排序法)
交换式排序法，数据比较后，依判断规则对数据位置进行交换，以达到排序的目的。
①冒泡排序法(Bubble sort)
②快速排序法(Quick sort)
选择式排序法，是从欲排序的数据中，按指定的规则选出某一元素，经过和其他元素重整，再依原则交换位置后达到排序的目的。
①选择排序法(Select sort)
②堆排序法(Heap Sort)
插入式排序法，是对欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。
①插入排序法(Insertion sort)
②希尔排序法(Shell sort)
③二叉树排序法(Binary-tree sort)
其它排序法。
①选堆排序法
②合并排序法
2.冒泡排序法
public static int[] bubble(int[] array){
int temp=0;
for(int i=0;i<array.length;i++){ //外层循环，决定一共走几趟
for(int j=0;j<array.length-1-i;j++){ //内层循环，开始逐个比较，发现前一个数比后一个数大则交换
if(array[j]>array[j+1]){
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
// array[j]=array[j]+array[j+1];
// array[j+1]=array[j]-array[j+1];
// array[j]=array[j]-array[j+1];
}
}
}
return array;
}
3.选择排序法：
public static int[] select(int[] array){
int temp=0;
for(int j=0;j<array.length;j++){
//我认为第一个数就是最小的
int min=array[j];
//记录最小数的下标
int minIndex=j;
for(int k=j+1;k<array.length;k++){
if(min>array[k]){
//修改最小
min=array[k];
minIndex=k;
}
}
temp=array[j];
array[j]=array[minIndex];
array[minIndex]=temp;
}
return array;
}
4.插入排序法:
public static int[] insert(int[] array){
for(int i=1;i<array.length;i++){
int insertVal=array[i];
//insertval准备和前一个数比较
int index=i-1;
while(index>=0&&insertVal<array[index]){
//把array[index]向后移动
array[index+1]=array[index];
//让index向前移动
index--;
}
//将insertVal插入到适当位置
array[index+1]=insertVal;
}
return array;
}
5.快速排序法(交换式排序法):
public static int[] quick(int[] array){
int left=0;
int right=array.length-1;
return px(left, right, array);
}
public static int[] px(int left,int right,int[] array){
int l=left,r=right;
int privot=array[(l+r)/2];
int temp=0;
while(l<r){
while(array[l]<privot) l++;
while(array[r]>privot) r--;
if(l>=r) break;
temp=array[l];
array[l]=array[r];
array[r]=temp;
if(array[l]==privot) --r;
if(array[r]==privot) ++l;
}
if(l==r){
l++;
r--;
}
if(left<r) px(left,r,array);
if(right>l) px(l, right, array);
return array;
}
5.几种排序方法运行时间的比较：
随机生成十万个1~10000的数并存放到数组中。
int[] array=new int[100000];
for(int i=0;i<array.length;i++){
array[i]=(int)(Math.random()*10000);
}
排序前打印系统时间，排序后打印系统时间。
Calendar calendar=Calendar.getInstance();
System.out.println("排序前:"+calendar.getTime());
bubble(array);
calendar=Calendar.getInstance();
System.out.println("排序后:"+calendar.getTime());
发现排序时间大约是16秒
换成选择排序法：
Calendar calendar=Calendar.getInstance();
System.out.println("排序前:"+calendar.getTime());
select(array);
calendar=Calendar.getInstance();
System.out.println("排序后:"+calendar.getTime());
大约4秒钟
换成插入排序法：
Calendar calendar=Calendar.getInstance();
System.out.println("排序前:"+calendar.getTime());
insert(array);
calendar=Calendar.getInstance();
System.out.println("排序后:"+calendar.getTime());
大约3秒钟
换成快速排序法:
Calendar calendar=Calendar.getInstance();
System.out.println("排序前:"+calendar.getTime());
quick(array);
calendar=Calendar.getInstance();
System.out.println("排序后:"+calendar.getTime());
几乎没有排序时间。
6.浅测快速排序法
刚刚测试十万个数发现几乎没有排序时间。
我又测试了一百万个，发现还是没什么排序时间。
直到测试了一千万个:
发现仅有1s的排序时间。
那是不是快速排序法就是最好的呢？
不是，快速排序法在运行的时候对cpu和内存的占用是非常大的，其他排序法并不像快速排序法占用这么多。
四、查找
在java中我们常用的查找有两种
①顺序查找(最简单，效率最低的查找方法，一个一个找)
②二分查找(先排序，再择中查找，效率高)
public static void find(int val,int[] array){
int leftIndex=0;
int rightIndex=array.length-1;
f(leftIndex, rightIndex, val, array);
}
public static void f(int leftIndex,int rightIndex,int val,int array[]){
int midIndex=(rightIndex+leftIndex)/2;
int midVal=array[midIndex];
if(rightIndex>=leftIndex){
if(midVal>val){
f(leftIndex, midIndex-1, val, array);
}else if(midVal<val){
f(midIndex+1, rightIndex, val, array);
}else if(midVal==val){
System.out.println("找到此数，下标为"+midIndex);
}
}
}
二分查找要求数组已经是排好序(从小到大)的数组，所以我们一般先排序再使用二分查找。
标签：数组下标 heap 存储器 oat 初始化 fbo bounds es2017 分配
原文地址：http://www.cnblogs.com/myz666/p/7489318.html
