Java数据结构和算法(二)——数组

转自http://blog.csdn.net/iaiti/article/details/39493403

数组的用处是什么呢？——当你需要将30个数进行大小排列的时候，用数组这样的数据结构存储是个很好的选择，当你是一个班的班主任的时候，每次要记录那些学生的缺勤次数的时候，数组也是很有用。数组可以进行插入，删除，查找等。

1)创建和内存分配

Java中有两种数据类型，基本类型和对象类型，也有人称为引用类型，Java中把数组当成对象，创建数组时使用new操作符。

[java] view plain copy print?

1. int array[] = new int[10];  

既然是对象，那么array便是数组的一个引用，根据Java编程思想(一) —— 一切都是对象 的内存分配，array会在栈中开辟空间，并且空间存储着保存数组存储的地址，真正保存对象的地方是对，new操作在堆中开辟了所需的空间，然后array指向头地址。

初始化：

[java] view plain copy print?

1. public class UseArray {  
2.     public static void main(String[] args) {  
3.         int array[] = new int[10];  
4.         System.out.println(array[2]);  
5.         UseArray a[] = new UseArray[12];  
6.         System.out.println(a[1]);  
7.         int array2[] ={1,2,3,4,5,5,6};  
8.     }  
9. }  

new后的数组里面的值被默认初始化为0，而对象的初始化是空的，null，当然还可以通过{}的方式初始化。

2)数组封装后的使用

[java] view plain copy print?

1. public class UseArray {  
2.     private int[] array;  
3.     private int number = 0;  
4.     public UseArray(int max){  
5.         array = new int[max];  
6.     }  
7.     public void insert(int value){  
8.         array[number] = value;  
9.         number++;  
10.     }  
11.     public int find(int value){  
12.         for (int i= 0; i < number; i++) {  
13.             if(array[i]==value)  
14.                 return i;  
15.         }  
16.         return number;  
17.     }  
18.       
19.     public boolean delete(int value){  
20.         int index = find(value);  
21.         if(index != number){  
22.             for (int i = index; i < number-1; i++) {  
23.                 array[i] = array[i+1];  
24.             }  
25.             number--;  
26.             return true;  
27.         }  
28.         return false;  
29.     }  
30.       
31.     public void display(){  
32.         for (int i = 0; i < number; i++) {  
33.             System.out.printf(array[i]+" ");  
34.         }  
35.     }  
36.     public static void main(String[] args) {  
37.         UseArray ua  = new UseArray(5);  
38.         ua.insert(1);  
39.         ua.insert(2);  
40.         ua.insert(6);  
41.         ua.insert(7);  
42.         ua.insert(3);  
43.           
44.         ua.display();  
45.         if(ua.find(5) != ua.number){  
46.             System.out.println("find,the number index is "+ua.find(5));  
47.         }else{  
48.             System.out.println("not found!");  
49.         }  
50.         if(ua.delete(5)!=true){  
51.             System.out.println("can not delete!");  
52.         }  
53.         ua.display();  
54.     }  
55. }  

将整个数组封装，用number代替数组的个数，插入数据的时候也不必理会往哪个下标插，当然，也可以自定义一个具体下标的方法。

方法比较简单就不介绍了，但是存在的一个缺点在delete那里，其实只是从删除元素开始的左移而已，所以，虽然number减少了，但是最后一个元素并没有删除掉，只是display输出展示的时候隐藏了而已，但是，下次插入元素的时候新元素便会取代掉最后一个元素的位置。

3)查找优化——二分查找

[java] view plain copy print?

1. public int find(int value){  
2.         int start = 0;  
3.         int end = number-1;  
4.         while(end>=start){  
5.             int index =(end + start)/2;   
6.             if(array[index]==value){  
7.                 return index;  
8.             }else if(array[index] >value){  
9.                 end = index-1;  
10.             }else {   
11.                 start = index+1;  
12.             }  
13.         }  
14.         return number;  
15.     }  

二分查找前提是数组已经有序。刚开始index写成end和start相减，造成死循环。其实要的是相加。1,2,3,6,7。index=2，value=7，3小于7，start=3，那么index要的是3和4间的中间数，所以是相加之后除以2,6小于7，start=4，find到7。

排序的话倒是看—— Java数据结构和算法(三)——简单排序。

存储对象的话原理一样。

4)大O表示法

设N为数据总数，加入插入一个数据时间为K。

那么线性查找总时间T=K*N/2，因为查找的话大概为比较数目的一半。

二分查找的话T=k*log2(N)。

大O表示法，O可以看成是order of，大约是的意思，k/2也是常数，所以可以看成是O(N)。

数组的缺点呢，就是大小固定，查找慢，如果你要经常查找百万级别的数据，还会用数组吗？不会的，所以数据结构的选用要结合具体的实际情况，达到最大的效率值。