1、查找-顺序查找

数组实现线性表

 

    线性表特征： 
    1、一个特定的线性表，应该是用来存放特定的某一个类型的元素的（元素的“同一性”）；
    2、除第一个元素外，其他每一个元素有且仅有一个直接前驱；除最后一个元素外，其他每一个元素有且仅有一个直接后继（元素的“序偶性”）；
    3、元素在线性表中的“下标”唯一地确定该元素在表中的相对位置（元素的“索引性”）。
    PS：

    1、线性表只是数据的一种逻辑结构，其具体存储结构可以为顺序存储结构和链式储存结构来完成，对应可以得到顺序表和链表，使用内置数组可得到顺序表；使用指针可得到链表；
    2、对线性表的入表和出表顺序做一定的限定，可以得到特殊的线性表，栈(FILO)和队列（FIFO）。

 

    这一节介绍如何利用数组实现线性表，从而得到顺序表。

    思路：
    1. 顺序表因为采用顺序存储形式，所以内部使用数组来存储数据
    2.因为存储的具体对象类型不一定，所以采用泛型操作
    3.数组操作 优点：1.通过索引快速定位到下表，查询快速
               缺点：1.数组声明时即需要确定数组大小。当操作中超过容量时，则需要重新声明数组，并且复制当前所有数据；

                     2.当需要在中间进行插入或者删除时，则需要移动大量元素（size-index个）。

    实现代码：

 

/**
 * 自己用数组实现的线性表
 */
public class ArrayList<E> {
	Object[] data = null;// 用来保存此队列中内容的数组
	int current;// 保存当前为第几个元素的指标
	int capacity;// 表示数组大小的指标

	/**
	 * 如果初始化时，未声明大小，则默认为10
	 */
	public ArrayList() {
		this(10);
	}

	/**
	 * 初始化线性表，并且声明保存内容的数组大小
	 * 
	 * @param initalSize
	 */
	public ArrayList(int initalSize) {
		if (initalSize < 0) {
			throw new RuntimeException("数组大小错误:" + initalSize);
		} else {
			this.data = new Object[initalSize];
			this.current = 0;
			capacity = initalSize;
		}
	}

	/**
	 * 添加元素的方法 添加前，先确认是否已经满了
	 * 
	 * @param e
	 * @return
	 */
	public boolean add(E e) {
		ensureCapacity(current);// 确认容量
		this.data[current] = e;
		current++;
		return true;
	}

	/**
	 * 确认系统当前容量是否满足需要,如果满足，则不执行操作 如果不满足，增加容量
	 * 
	 * @param cur
	 *            当前个数
	 */
	private void ensureCapacity(int cur) {
		if (cur == capacity) {
			// 如果达到容量极限，增加10的容量，复制当前数组
			this.capacity = this.capacity + 10;
			Object[] newdata = new Object[capacity];
			for (int i = 0; i < cur; i++) {
				newdata[i] = this.data[i];
			}
			this.data = newdata;
		}
	}

	/**
	 * 得到指定下标的数据
	 * 
	 * @param index
	 * @return
	 */
	public E get(int index) {
		validateIndex(index);
		return (E) this.data[index];
	}

	/**
	 * 返回当前队列大小
	 * 
	 * @return
	 */
	public int size() {
		return this.current;
	}

	/**
	 * 更改指定下标元素的数据为e
	 * 
	 * @param index
	 * @param e
	 * @return
	 */
	public boolean set(int index, E e) {
		validateIndex(index);
		this.data[index] = e;
		return true;
	}

	/**
	 * 验证当前下标是否合法，如果不合法，抛出运行时异常
	 * 
	 * @param index
	 *            下标
	 */
	private void validateIndex(int index) {
		if (index < 0 || index > current) {
			throw new RuntimeException("数组index错误：" + index);
		}
	}

	/**
	 * 在指定下标位置处插入数据e
	 * 
	 * @param index
	 *            下标
	 * @param e
	 *            需要插入的数据
	 * @return
	 */
	public boolean insert(int index, E e) {
		validateIndex(index);
		Object[] tem = new Object[capacity];// 用一个临时数组作为备份
		// 开始备份数组
		for (int i = 0; i < current; i++) {
			if (i < index) {
				tem[i] = this.data[i];
			} else if (i == index) {
				tem[i] = e;
			} else if (i > index) {
				tem[i] = this.data[i - 1];
			}
		}
		this.data = tem;
		return true;
	}

	/*
	 * 删除指定下标出的数据
	 * 
	 * @param index<br> * @return<br>
	 */
	public boolean delete(int index) {
		validateIndex(index);
		Object[] tem = new Object[capacity];// 用一个临时数组作为备份
		// 开始备份数组
		for (int i = 0; i < current; i++) {
			if (i < index) {
				tem[i] = this.data[i];
			} else if (i == index) {
				tem[i] = this.data[i + 1];
			} else if (i > index) {
				tem[i] = this.data[i + 1];
			}
		}
		this.data = tem;
		return true;
	}

}

 

    PS：在Java语言中，通过动态数组实现的线性表，对应着Collection接口中的子接口List接口，其数组实现可参考类ArrayList源码和Vector源码。