算法01 之數組

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

    普通數組的java代碼

[java] view plain copy
 在CODE上查看代碼片派生到我的代碼片
  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代碼:

[java] view plain copy
 在CODE上查看代碼片派生到我的代碼片
  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)。
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章