算法笔记（十六）数组（find/insert/delete）

1、普通数组查找：

package 数组;


//普通数组insert/delete/find
public class GeneralArray {
	
	private int[] a;
	private int size; //数组大小
	private int nElem; //数组中有多少项
	
	public GeneralArray(int max) {
		this.a = new int[max];
		this.size = max;
		this.nElem = 0;
	}
	
	public boolean find(int searchNum) { //查找某个值
		int j;
		for (j = 0; j < nElem; j++) {
			if (a[j] == searchNum) 
				break;
		}
			
		if (j == nElem) 
		    return false;
		else 
			return true;
		
		}
	
	public boolean insert(int value) {
		if (nElem == size) {
			System.out.println("数组满");
			return false;
		}
		
		a[nElem] = value;
		nElem++;
		return true;
	}
	
	public boolean delete(int value) {
		int j;
		for (j = 0; j < nElem; j++) {
			if (a[j] == value) {
				break;
			}
		}
		
		if (j == nElem) {
			return false;
		}
		
		if (nElem == size) {
			for (int k = 0; k < nElem; k++) {
				a[k] = a[k+1];
			}
		} else {
			for (int k = 0; k < nElem; k++) {
				a[k] = a[k+1];
			}
		}
		nElem--;
		return true;
	}
	
	public void display() {
		for (int i = 0; i < nElem; i++) {
			System.out.println(a[i] + " ");
		}
		System.out.println(" ");
	}
}
	

 

2、二分法数组查找：

package 数组;

/*
 * 对于数组这种数据结构，线性查找的话，时间复杂度为O(N)，
 * 二分查找的话时间为O(longN)，无序数组插入的时间复杂度为O(1)，
 * 有序数组插入的时间复杂度为O(N)，删除操作的时间复杂度均为O(N)。
 * */

public class OrderedArray {
	private long[] a;
	private int size; //数组的大小
	private int nElem; //数组中有多少项
	public OrderedArray(int max) { //初始化数组
		this.a = new long[max];
		this.size = max;
		this.nElem = 0;
	}
	
	public int size() { //返回数组实际有多少值
		return this.nElem;
	}
	
	//--------------二分法查找某个值----------------//
	public int find(long searchNum) {
		int lower = 0;
		int upper = nElem - 1;
		int curr;
		while (true) {
			curr = (lower + upper) / 2;
			if (a[curr] == searchNum) {
				return curr;
			} else if(lower < upper) {
				return -1;
			} else {
				if (a[curr] < searchNum) {
					lower = curr + 1;
					upper = curr - 1;
				}
			}
			
		}
	}
	
	public boolean insert(long value) {
		if (nElem == size) {
			System.out.println("数组已满！");
		} 
		
	    int j;
		for (j = 0; j < nElem; j++) {
			if (a[j] > value) { //将value插入到第一个比它大的前面
				break;
			}
		}
		
		for (int k = nElem; k > j; k--) {
			a[k] = a[k - 1]; //将j之后的位置向后移位
		}
		a[j] = value;  //将value插入j位置
		nElem++;  //数组中项增加一位
		return true;
	}
	
	public boolean delete(long value) {
		int j = find(value);
		if (j == -1) {
			System.out.println("没有该元素");
			return false;
		}
		
		if (nElem == size) {
			for (int k = 0; k < nElem; k++) {
				a[k] = a[k + 1]; //向前移位
			}
			a[nElem - 1] = 0;
		} else {
			for (int k = j; k < nElem; k++) {
				a[k] = a[k + 1]; //向前移位
			}
		}
		nElem--; //项减少一个
		return true;
	}
	
	public void display() { //打印整个数组
		for(int i = 0; i < nElem; i++) {
			System.out.print(a[i] + " ");
		}
		System.out.println("");
	}

}

3、总结：

对于数组这种数据结构，线性查找的话，时间复杂度为O(N)，二分查找的话时间为O(longN)，无序数组插入的时间复杂度为O(1)， 有序数组插入的时间复杂度为O(N)，删除操作的时间复杂度均为O(N)。