數組

數組是應用最廣泛的數據存儲結構。它被植入到大部分的編程語言中，由於數組十分易懂，所以在這裏就不贅述，主要附上兩端代碼，一個是普通的數組，另一個是有序數組。有序數組是按關鍵字升序（或降序）排列的，這種排列使快速查找數據項成為可能，即可以使用二分查找。

普通數組的java代碼：

 1 public class GeneralArray {  
 2     private int[] a;  
 3     private int size; //數組的大小  
 4     private int nElem; //數組中有多少項  
 5     public GeneralArray(int
 
 max) { //初始化數組  
 6         this.a = new int[max];  
 7         this.size = max;  
 8         this.nElem = 0;  
 9     }  
10     public boolean find(int searchNum) { //查找某個值      
11         int j;  
12         for(j = 0; j < nElem; j++){  
13             if(a[j] == searchNum)  
14                 break
 
;  
15         }  
16         if(j == nElem)  
17             return false;  
18         else  
19             return true;  
20     }  
21     public boolean insert(int value) { //插入某個值  
22         if(nElem == size){  
23             System.out.println("數組已滿！");  
24             return false;  
25         }  
 
26         a[nElem] = value;  
27         nElem++;          
28         return true;  
29     }  
30     public boolean delete(int value) {//刪除某個值  
31         int j;  
32         for(j = 0; j < nElem; j++) {  
33             if(a[j] == value) {  
34                 break;  
35             }  
36         }  
37         if(j == nElem)   
38             return false;  
39         if(nElem == size) {  
40             for(int k = j; k < nElem - 1; k++) {  
41                 a[k] = a[k+1];  
42             }  
43         }  
44         else {  
45             for(int k = j; k < nElem; k++) {  
46                 a[k] = a[k+1];  
47             }  
48         }  
49         nElem--;  
50         return true;  
51     }  
52     public void display() { //打印整個數組  
53         for(int i = 0; i < nElem; i++) {  
54             System.out.print(a[i] + " ");  
55         }  
56         System.out.println("");  
57     }  
58 }    

有序數組的java代碼：

 1 public class OrderedArray {  
 2     private long[] a;  
 3     private int size; //數組的大小  
 4     private int nElem; //數組中有多少項  
 5     public OrderedArray(int max) { //初始化數組  
 6         this.a = new long[max];  
 7         this.size = max;  
 8         this.nElem = 0;  
 9     }  
10     public int size() { //返回數組實際有多少值  
11         return this.nElem;  
12     }  
13 //--------------二分法查找某個值----------------//  
14     public int find(long searchNum) {  
15         int lower = 0;  
16         int upper = nElem - 1;  
17         int curr;  
18         while(true) {  
19             curr = (lower + upper) / 2;  
20             if(a[curr] == searchNum)  
21                 return curr;  
22             else if(lower > upper)   
23                 return -1;  
24             else {  
25                 if(a[curr] < searchNum)   
26                     lower = curr + 1;  
27                 else  
28                     upper = curr - 1;  
29             }  
30               
31         }  
32     }  
33     public boolean insert(long value) { //插入某個值  
34         if(nElem == size){  
35             System.out.println("數組已滿！");  
36             return false;  
37         }  
38         int j;  
39         for(j = 0; j < nElem; j++){  
40             if(a[j] > value)  
41                 break;  
42         }  
43           
44         for(int k = nElem; k > j; k--) {  
45             a[k] = a[k-1];  
46         }  
47         a[j] = value;  
48         nElem++;          
49         return true;  
50     }  
51     public boolean delete(long value) { //刪除某個值  
52         int j = find(value);  
53         if(j  == -1){  
54             System.out.println("沒有該元素！");  
55             return false;  
56         }  
57         if(nElem == size) {  
58             for(int k = j; k < nElem - 1; k++) {  
59                 a[k] = a[k+1];  
60             }         
61             a[nElem-1] = 0;  
62         }  
63         else {  
64             for(int k = j; k < nElem; k++) {  
65                 a[k] = a[k+1];  
66             }  
67         }  
68         nElem--;  
69         return true;  
70     }  
71     public void display() { //打印整個數組  
72         for(int i = 0; i < nElem; i++) {  
73             System.out.print(a[i] + " ");  
74         }  
75         System.out.println("");  
76     }  
77 }  

對於數組這種數據結構，線性查找的話，時間復雜度為O(N)，二分查找的話時間為O(longN)，無序數組插入的時間復雜度為O(1)，有序數組插入的時間復雜度為O(N)，刪除操作的時間復雜度均為O(N)。

主要是用於自己o學習所整理之用！

參考博文：http://blog.csdn.net/eson_15/article/details/51126182

　　　　　https://www.cnblogs.com/wuchanming/p/4371055.html　　　　

數據結構與算法（一）--數組