数据结构与算法之有序数组及二分法

有序数组的实现原理


有序数组的实现类

public class OrderArray {
	private long arr[];
	private int nElements;
	
	 public OrderArray(int size) {
		 arr =new long[size];
		 nElements=0;
	 }
	 //添加
	 public void insert(long value) {
		 int i;
		 for(i=0;i<nElements;i++) {
			 if(arr[i]>value) {
				break; 
			 }
		 }
		 int j;
		 for(j=nElements;j>i;j--) {
			 arr[j]=arr[j-1];
		 }
		 arr[j]=value;
		 nElements++;
	 }
	 //查找
	 public int find(long value) {
		 int i;
		 for(i=0;i<nElements;i++) {
			if(arr[i]==value) {
				break;
			} 
		 }
		 if(i==nElements) {
			 return -1;
			 
		 }else {
			return i; 
		 }
	 }
	 
	 //删除
	 
	 public void delete(long value) {
		 int i = find(value);
		 if(i<0) {
			System.out.println("没有你要删除的元素"); 
		 }else {
			for(int j=i;j<nElements-1;j++) {
				arr[j]=arr[j+1];
			}
		}
		 nElements--;
	 }
	 
	 //遍历
	 
	 public void traverse() {
		 for(int i=0;i<nElements;i++) {
			 System.out.println(arr[i]);
		 }
	 }
}

测试类

public class OrderArrayTest {
	public static void main(String[] args) {
		OrderArray orderArray = new OrderArray(5);
		orderArray.insert(5);
		orderArray.insert(25);
		orderArray.insert(35);
		orderArray.insert(8);
		orderArray.insert(55);
		
		int index = orderArray.find(25);
		System.out.println(index);
		
		orderArray.delete(8);
		orderArray.traverse();
	}
}

加上二分法的查询方法（注：二分法只能在有序数组中使用）

// 使用二分法查找
	public int dichotomy(long value) {
		int left = 0;
		int right = nElements - 1;
		int curIn;
		while (true) {
			//得到中间的值
			curIn = (left + right)/2;
			//如果要找的值恰好等于中间的值，则返回索引值
			if (value == arr[curIn]) {
				return curIn;
				
			} else if (left > right) {//如果左边的下标大于有的下标，则表示没有找到，返回-1
				return -1;
			} else {
				if(arr[curIn]>value) {
					right=curIn-1;
				}else {
					left=curIn+1;
				}
			}
		}
	}
    //二分法删除

public void delete(long value) {
		int i = dichotomy(value);
		if(i<0){
			System.out.println("没有你要找的元素");
		}else {
			for(int j=i;i<nElements-1;i++) {
				arr[j]=arr[j+1];
			}
		}
		nElements--;
	}

总结：在一次总结数组这种数据结构特点：
a、无序数组在插入新数据的时候很高效：O(1)时间，但查找和删除数据较慢：O(n)时间
b、有序数组在查找数据的时候很高效：O(logn)时间，但插入数据和删除数据上费劲：O(n)时间