重新温习数据结构一:数组

我对java基础和数据结构,算法学得好的人很佩服,毕竟无论什么时候,基础的学习才是最重要的.以前学过数据结构,现在重新温习一下.
数组分为有序数组与无序的数组,在一个无序数组中可以很快进行插入,花费O(1)时间,但查找与删除都速度比较慢O(n)时间;有序数组,查找很快O(1)时间花费,但插入却花费O(n)时间.
(本文的例子是摘<<data java="" in="" algorithms="" structures=""></data>>这一本书的)

下面看一个无序数组的例子

1. package org.h2;   
2.   
3. /**  
4.  * 这一个类是为说明数组在数据结构中的运用  
5.  *   
6.  * @author lighter  
7.  *   
8.  */  
9. class HighArray {   
10.  private long[] a; // 定义一个数组a   
11.   
12.  private int nElems; // 定义数组里面有多少项   
13.   
14.  // -----------------------------------------------------------   
15.   
16.  public HighArray(int max) // 构造方法   
17.  {   
18.   a = new long[max]; // 创建一个数组   
19.   nElems = 0; // 刚开始数组元素为空   
20.  }   
21.   
22.  // -----------------------------------------------------------   
23.  public boolean find(long searchKey) { // 寻找指定的值   
24.   int j;   
25.   for (j = 0; j < nElems; j++)   
26.    if (a[j] == searchKey) // 找到元素?   
27.     break;            // 退出循环   
28.   if (j == nElems)   
29.    return false;         // 没有在数组中找到元素   
30.   else  
31.    return true;          // 在数组中找到元素   
32.  }   
33.   
34.  // -----------------------------------------------------------   
35.   
36.  public void insert(long value) // 增加一个元素到数组中去   
37.  {   
38.   a[nElems] = value;   
39.   nElems++;   
40.  }   
41.   
42.  // -----------------------------------------------------------   
43.  public boolean delete(long value) {// 删除一个元素,先查找,找到则删除   
44.   int j;   
45.   for (j = 0; j < nElems; j++)   
46.    if (value == a[j])   
47.     break;   
48.   if (j == nElems)   
49.    return false;   
50.   else {   
51.    for (int k = j; k < nElems; k++)   
52.     a[k] = a[k + 1];   
53.    nElems--;   
54.    return true;   
55.   }   
56.  }   
57.   
58.  // -----------------------------------------------------------   
59.   
60.  public void display() // 打印出数组的内容   
61.  {   
62.   for (int j = 0; j < nElems; j++)   
63.    System.out.print(a[j] + " ");   
64.   System.out.println("");   
65.  }   
66. }   
67.   

注:find方法中的如下语句:  if (j == nElems)
   return false;         // 没有在数组中找到元素
  else
   return true;          // 在数组中找到元素
可以用这一条语句来替代return (j!=nElems);

再写一个类:

1. package org.h2;   
2.   
3. class HighArrayApp   
4. {   
5. public static void main(String[] args)   
6.    {   
7.    int maxSize = 100;            // array size   
8.    HighArray arr;                // reference to array   
9.    arr = new HighArray(maxSize); // create the array   
10.   
11.    arr.insert(77);               // insert 10 items   
12.    arr.insert(99);   
13.    arr.insert(44);   
14.    arr.insert(55);   
15.    arr.insert(22);   
16.    arr.insert(88);   
17.    arr.insert(11);   
18.    arr.insert(00);   
19.    arr.insert(66);   
20.    arr.insert(37);   
21.   
22.    arr.display();                // display items   
23.   
24.    int searchKey = 35;           // search for item   
25.    if( arr.find(searchKey) )   
26.       System.out.println("找到 " + searchKey);   
27.    else  
28.       System.out.println("不能找到" + searchKey);   
29.   
30.    arr.delete(00);               // delete 3 items   
31.    arr.delete(55);   
32.    arr.delete(99);   
33.   
34.    arr.display();                // display items again   
35.    }  // end main()   
36. }  // end class HighArrayApp   
37.   

运行结果如下:
77 99 44 55 22 88 11 0 66 37
不能找到35
77 44 22 88 11 66 37

下面看一个有序数组的例子,比较上面的,看一下两者的不同之处

java 代码

1. package org.h2;   
2.   
3. class OrderArray {   
4.  private long[] a; // ref to array a   
5.   
6.  private int nElems; // number of data items   
7.   
8.  public OrderArray(int max) // constructor   
9.  {   
10.   a = new long[max]; // create array   
11.   nElems = 0;   
12.  }   
13.   
14.  public int size() {   
15.   return nElems;   
16.  }   
17.   
18. //这里采用二分查找的方法,速度比较快   
19.  public int find(long searchKey) {   
20.   int lowerBound = 0;   
21.   int upperBound = nElems - 1;   
22.   int curIn;   
23.   
24.   while (true) {   
25.    curIn = (lowerBound + upperBound) / 2;   
26.    if (a[curIn] == searchKey)   
27.     return curIn;     // found it   
28.    else if (lowerBound > upperBound)   
29.     return nElems;    // can't find it   
30.    else                  // divide range   
31.    {   
32.     if (a[curIn] < searchKey)   
33.      lowerBound = curIn + 1; // it's in upper half   
34.     else  
35.      upperBound = curIn - 1; // it's in lower half   
36.    }    
37.   }     
38.  }    
39.   
40.  public void insert(long value) // put element into array   
41.  {   
42.   int j;   
43.   for (j = 0; j < nElems; j++)   
44.    if (a[j] > value)      // (linear search)   
45.     break;   
46.   for (int k = nElems; k > j; k--)   
47.    a[k] = a[k - 1];   
48.   a[j] = value;             // insert it   
49.   nElems++;                 // increment size   
50.  }    
51.   
52.  public boolean delete(long value) {   
53.   int j = find(value);   
54.   if (j == nElems) // can't find it   
55.    return false;   
56.   else            // found it   
57.   {   
58.    for (int k = j; k < nElems; k++)   
59.     a[k] = a[k + 1];   
60.    nElems--;  // decrement size   
61.    return true;   
62.   }   
63.  }   
64.   
65.  public void display() // displays array contents   
66.  {   
67.   for (int j = 0; j < nElems; j++)   
68.    System.out.print(a[j] + " ");    
69.   System.out.println("");   
70.  }   
71. }   
72.   

再写一个实现类,测试一下测试结果如下:
Found 55
0 11 22 33 44 55 66 77 88 99
11 22 33 44 66 77 88

1. package org.h2;   
2.   
3. class OrderArrayApp   
4. {   
5. public static void main(String[] args)   
6.    {   
7.    int maxSize = 100;             // array size   
8.    OrderArray arr;                  // reference to array   
9.    arr = new OrderArray(maxSize);   // create the array   
10.   
11.    arr.insert(77);                // insert 10 items   
12.    arr.insert(99);   
13.    arr.insert(44);   
14.    arr.insert(55);   
15.    arr.insert(22);   
16.    arr.insert(88);   
17.    arr.insert(11);   
18.    arr.insert(00);   
19.    arr.insert(66);   
20.    arr.insert(33);   
21.   
22.    int searchKey = 55;            // search for item   
23.    if( arr.find(searchKey) != arr.size() )   
24.       System.out.println("Found " + searchKey);   
25.    else  
26.       System.out.println("Can't find " + searchKey);   
27.   
28.    arr.display();                 // display items   
29.   
30.    arr.delete(00);                // delete 3 items   
31.    arr.delete(55);   
32.    arr.delete(99);   
33.   
34.    arr.display();                 // display items again   
35.    }  // end main()   
36. }  // end class OrderedApp   
37.   
38.