Java数据结构与算法-数组

  1 public class TestMyArray{
  2
  3     public static void main(String[] args) {
  4
  5         MyArray array = new MyArray(6);
  6         array.insert(10);
  7         array.insert(12);
  8         array.insert(8);
  9         array.insert(17);
 10         array.insert(6);
 11         array.insert(15);
 12         array.display();
 13         System.out.println(array.search(12));
 14
 15         System.out.println(array.get(1));
 16
 17         array.delete(1);
 18         array.delete(3);
 19         array.display();
 20
 21     }
 22
 23 }
 24
 25 /**
 26  * 使用自定义类封装数组 添加类方法实现操作
 27  *
 28  */
 29 class MyArray {
 30     private long[] array;
 31     //表示有效数据的长度
 32     private int elements;
 33     public MyArray() {
 34         array = new long[50];
 35     }
 36
 37     public MyArray(int maxSize) {
 38         array = new long[maxSize];
 39     }
 40
 41     /**
 42      * 添加数据
 43      */
 44     public void insert(long value){
 45         array[elements] = value;
 46         elements++;
 47     }
 48
 49     /**
 50      * 显示数据
 51      */
 52     public void display(){
 53         System.out.print("[" + array[0]);
 54         for(int i= 1; i < elements; i++){
 55             System.out.print("," + array[i]);
 56         }
 57         System.out.println("]");
 58     }
 59
 60     /**
 61      * 查找数据
 62      */
 63     public int search(long value){
 64         int i = 0;
 65         for(; i < elements; i++){
 66             if(value == array[i]){
 67                 break;
 68             }
 69         }
 70         if(i == elements){
 71             return -1;
 72         } else {
 73             return i;
 74         }
 75     }
 76     /**
 77      * 查找数据，根据索引来查
 78      */
 79     public long get(int index){
 80         indexOK(index);
 81         return array[index];
 82     }
 83
 84     /**
 85      * 删除数据
 86      */
 87     public void delete(int index){
 88         indexOK(index);
 89         elements--;
 90         for(int i = index; i < elements; i++){
 91             array[i] = array[i+1];
 92         }
 93     }
 94
 95     /**
 96      * 更新数据
 97      */
 98     public void change(int index, int newValue){
 99         indexOK(index);
100         array[index] = newValue;
101     }
102
103     /**
104      * 角标越界
105      */
106     public void indexOK(int index){
107         if(index >= elements || index < 0){
108             throw new ArrayIndexOutOfBoundsException();
109         }
110     }
111 }

  1 package cn.array;
  2
  3 /**
  4  * 有序数组
  5  */
  6 public class TestMyOrderArray{
  7
  8     public static void main(String[] args) {
  9
 10         MyOrderArray array = new MyOrderArray(6);
 11         array.insert(10);
 12         array.insert(12);
 13         array.insert(8);
 14         array.insert(17);
 15         array.insert(6);
 16         array.insert(15);
 17         array.display();
 18         System.out.println(array.search(12));
 19
 20         System.out.println(array.get(1));
 21
 22         array.delete(1);
 23         array.delete(3);
 24         array.insert(3);
 25         array.display();
 26
 27     }
 28
 29 }
 30
 31 /**
 32  * 使用自定义类封装数组 添加类方法实现操作
 33  *
 34  */
 35 class MyOrderArray{
 36     private long[] array;
 37     //表示有效数据的长度
 38     private int elements;
 39     public MyOrderArray() {
 40         array = new long[50];
 41     }
 42
 43     public MyOrderArray(int maxSize) {
 44         array = new long[maxSize];
 45     }
 46
 47     /**
 48      * 添加数据
 49      */
 50     public void insert(long value){
 51         int i ;
 52         for(i = 0; i < elements; i++){
 53             if(array[i] > value){
 54                 break;
 55             }
 56         }
 57
 58         for(int j = elements ; j > i ; j--){
 59             array[j] = array[j - 1];
 60         }
 61
 62         array[i] = value;
 63         elements++;
 64     }
 65
 66     /**
 67      * 显示数据
 68      */
 69     public void display(){
 70         System.out.print("[" + array[0]);
 71         for(int i= 1; i < elements; i++){
 72             System.out.print("," + array[i]);
 73         }
 74         System.out.println("]");
 75     }
 76
 77     /**
 78      * 查找数据
 79      */
 80     public int search(long value){
 81         int i = 0;
 82         for(; i < elements; i++){
 83             if(value == array[i]){
 84                 break;
 85             }
 86         }
 87         if(i == elements){
 88             return -1;
 89         } else {
 90             return i;
 91         }
 92     }
 93     /**
 94      * 查找数据，根据索引来查
 95      */
 96     public long get(int index){
 97         indexOK(index);
 98         return array[index];
 99     }
100
101     /**
102      * 删除数据
103      */
104     public void delete(int index){
105         indexOK(index);
106         elements--;
107         for(int i = index; i < elements; i++){
108             array[i] = array[i+1];
109         }
110     }
111
112     /**
113      * 更新数据
114      */
115     public void change(int index, int newValue){
116         indexOK(index);
117         array[index] = newValue;
118     }
119
120     /**
121      * 角标越界
122      */
123     public void indexOK(int index){
124         if(index >= elements || index < 0){
125             throw new ArrayIndexOutOfBoundsException();
126         }
127     }
128 }

 1 /**
 2      * 二分法查找数据
 3      */
 4     public int binarySearch(long value){
 5         int middle = 0;
 6         int low = 0;
 7         int pow = elements;
 8
 9         while(true){
10             middle = (pow + low) / 2;
11             if(array[middle] == value){
12                 return middle;
13             }else if(low > pow){
14                 return -1;
15             }else{
16                 if(array[middle] > value){
17                     pow = middle - 1;
18                 }else {
19                     low = middle + 1;
20                 }
21             }
22
23         }
24
25     }