《Java数据结构与算法》笔记-CH2有序数组

/**
 * 上个例子是无序数组,并且没有考虑重复元素的情况。 
 * 下面来设计一个有序数组，我们设定不允许重复，这样提高查找的速度，但是降低了插入操作的速度。 
 * 1.线性查找
 * 2.二分查找
 * 有序数组优点：查找比无序数组快
 * 		 缺点：插入操作由于所有靠后的数据都需要移动来腾开空间，所以插入比较慢
 * 有序数组和无序数组删除操作都很慢，因为数据项必须向前移动来填补已删除的数据项的洞。
 * 有序数组在查找频繁的情况下很有用，但若是插入和删除较为频繁，则无法高效工作。
 */
class OrderArray {
	private long[] array;
	private int nElement;

	public OrderArray(int size) {
		this.array = new long[size];
		this.nElement = 0;
	}

	public String toString() {
		if (nElement == 0)
			return "[]";
		StringBuilder sb = new StringBuilder();
		sb.append("[");
		for (int i = 0; i < nElement; i++) {
			sb.append(array[i] + ",");
		}
		sb.deleteCharAt(sb.length() - 1);
		sb.append("]");
		return sb.toString();
	}

	public void display() {
		System.out.println(toString());
	}

	public void insert(long value) {
		// 如果array满了，就不插入，直接返回
		if (nElement == array.length) {
			System.out.println("数组已满，插入停止...");
			return;
		}
		// 如果没有满则进行插入操作
		// 找到插入位置
		int j;
		for (j = 0; j < nElement; j++) {
			if (array[j] == value) {// 插入值在数组中已存在，停止
				System.out.println("重复了，插入停止...");
				return;
			} else if (array[j] > value) {// 找到位置
				break;
			}
		}
		// 从最后一个元素到该位置的元素，依次向后挪动一个位置
		for (int k = nElement; k > j; k--) {
			array[k] = array[k - 1];
		}
		// 把value放入该位置
		array[j] = value;
		// eElement加一
		nElement++;
	}
	/**
	 * 线性查找
	 * @param value
	 * @return
	 */
	public int findValueByIte(long value) {
		for (int i = 0; i < size(); i++) {
			if (array[i] == value)
				return i;
		}
		return -1;
	}
	/**
	 * 二分法查找
	 * @param value
	 * @return
	 */
	public int findValueByBi(long value) {
		int lower = 0;
		int upper = nElement - 1;
		int curr;
		while (true) {
			curr = (lower + upper) / 2;
			if (array[curr] == value)
				return curr;
			else if (lower > upper)
				return -1;
			else {
				if (array[curr] < value)
					lower = curr + 1;
				else
					upper = curr - 1;
			}
		}
	}

	public boolean delete(long value) {
		int index = findValueByBi(value);
		//value不在数组中
		if(index == -1){
			System.out.println(value+"不在数组中，退出");
			return false;
		}
		//value所在位置为index
		//从该位置开始到倒数第二个位置，将后继元素向前移动一个位置，然后数组个数-1
		for(int k=index;k<nElement-1;k++)
			array[k] = array[k+1];
		nElement --;
		return true;
	}

	public int size() {
		return nElement;
	}
}

public class ArrayDemo2 {
	public static void main(String[] args) {
		OrderArray oa = new OrderArray(10);
		long[] arr = { 3, 2, 54, 32, 3, 66, 7, 455, 678, 33, 21, 26, 1, 98, 7 };
		for (int i = 0; i < arr.length; i++) {
			oa.insert(arr[i]);
			oa.display();
		}
		System.out.println(oa.findValueByIte(668));
		System.out.println(oa.findValueByBi(678));
		System.out.println(oa.delete(668));
		oa.display();
		System.out.println(oa.delete(455));
		oa.display();
		System.out.println(oa.delete(2));
		oa.display();
		System.out.println(oa.delete(678));
		oa.display();
		oa.delete(3);
		oa.delete(7);
		oa.delete(32);
		oa.display();
		oa.delete(54);
		oa.delete(33);
		oa.delete(32);
		oa.delete(21);
		oa.display();
		oa.delete(66);
		oa.display();
		oa.delete(7);
	}
}