(数据结构)线性表之顺序表，java实现

数据的四种基本逻辑结构

1.集合：数据元素都属于同一个集合

2.线性结构：数据间存在一个对一个的关系

3.树形结构：数据间存在一个对多个的关系

4.图状或网状结构：数据之间多个对多个的关系

不同的逻辑结构在底层通常有两种物理存储结构

1.顺序结构

2.链式结构

线性表的基本特征

1.总存在第一个数据元素，同样存在最后一个元素

2.除第一个元素，其他元素都有且仅有一个直接前驱元素，相应的，除最后一个元素，其他元素都有且仅有一个直接后继元素

线性表的基本操作

1.初始化

2.添加元素，可以到任意合理索引值

2.删除元素，可以是任意合理索引值

3.返回索引值对应的值

4.返回值对应的索引值

5.清空顺序表

6.返回顺序表的长度

7.判断是否为空

线性表之顺序表：一组连续的存储单元依次存放表中的元素，程序通常以数组存放顺序表的元素。

package xxx.hk.linearlist;

import java.util.Arrays;

public class SequenceList<T> {

	/**
	 * 初始容量8
	 */
	private int default_size = 8;

	/**
	 * 顺序表的元素个数
	 */
	private int size;
	/**
	 * 顺序表的容量
	 */
	private int capacity;
	 
	/**
	 * 装数据的数组
	 */
	private Object[] elementData;

	/**
	 * 默认构造方法，构造一个初始容量为8的数组
	 */
	public SequenceList() {
		capacity = default_size;
		elementData = new Object[capacity];
	}

	/**
	 * 初始容量为count的顺序表
	 * 
	 * @param count
	 */
	public SequenceList(int count) {
		capacity = count;
		elementData = new Object[capacity];
	}

	/**
	 * 可以传可变参数为初始值的顺序表构造器
	 * 
	 * @param elements
	 */
	public SequenceList(Object... elements) {
		int length = elements.length; // 得到可变参数的个数
		capacity = default_size;
		while (capacity < length) { // 初始容量大于可变参数的长度 为2的n次方
			capacity <<= 1;
		}
		elementData = new Object[capacity];
		for (int i = 0; i < length; i++) {
			elementData[i] = elements[i];
			size++;
		}
	}

	/**
	 * 添加元素到索引为index的位置
	 * 
	 * @param 插入元素的值 插入到的位置
	 * @return
	 */
	public boolean add(T elem, int index) {
		if (index < 0 || index > capacity - 1) {
			throw new IndexOutOfBoundsException("下标越界，请确认插入到数组的位置");
		}
		try {
			int minCapacity = ++size; // 添加一个元素后的size
			ensureCapacity(minCapacity); // 确认容量
			//将index后面的元素依次往后移 从最后一个开始移动
			System.arraycopy(elementData, index, elementData, index+1, capacity - index-1);
			//将元素插入到开索引值
 			elementData[index] = elem;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
		return true;
	}

	/**
	 * 添加一个元素到末尾
	 * 
	 * @param elem
	 * @return
	 */
	public boolean add(T elem) {
		return add(elem, size);
	}

	/**
	 * 删除指定索引值的元素
	 * 
	 * @param index
	 * @return 删除的元素
	 */
	public T delete(int index) {
		if (index < 0 || index > capacity - 1) {
			throw new IndexOutOfBoundsException("下标越界，请确认插入到数组的位置");
		}
		T elem;
		elem = (T) elementData[index];	// 返回删除的值
		elementData[index] = null;		
		//将index后面的元素向前移动 从index+1开始移动
		System.arraycopy(elementData, index+1, elementData, index, capacity - index-1);
		size--;
		
		return elem;
	}

	/**
	 * 删除最后一个元素
	 * @return
	 */
	public T delete(){
		return delete(size);
	}
	
	/**
	 * 返回顺序表的元素个数
	 * @return
	 */
	public int size(){
		return size;
	}
	
	public Object get(int index){
		if(index<0||index>size){
			throw new IndexOutOfBoundsException("下标越界，请确认插入到数组的位置");
		}
		return elementData[index];
	}
	
	/**
	 * 清空顺序表
	 */
	public void clear(){
		for(int i = 0 ; i < size;i++){
			elementData[i] = null;
		}
		size=0;
	}
	
	/**
	 * 判断顺序表是否为空
	 * @return true/false
	 */
	public boolean isEmpty(){
		return size==0;
	}
	
	/* 
	 * toString方法 打印所有元素
	 * @see java.lang.Object#toString()
	 */
	@Override
	public String toString() {
		StringBuilder sb = new StringBuilder("[");
		for(int i = 0;i<size;i++){
			sb.append(elementData[i]+",");
		}
		String result = sb.append("]").delete(sb.length()-2, sb.length()-1).toString();//最后添加]并删除最后一个,
		return result;
	}
	
	/**
	 * 确认数组容量
	 * 
	 * @param minCapacity
	 */
	public void ensureCapacity(int minCapacity) {
		while (minCapacity > capacity-1) {
			capacity <<= 1; // 容量*2
			elementData = Arrays.copyOf(elementData, capacity);// 数组扩容
		}
	}

	/**
	 * 主方法 测试
	 * @param args
	 */
	public static void main(String[] args) {
		SequenceList<Integer> arr = new SequenceList<Integer>();
		arr.add(1);
		arr.add(9);
		arr.add(9);
		arr.add(7);
		arr.add(1);
		arr.add(0);
		arr.add(2);
		arr.add(8);
		arr.add(1); //扩容
		arr.add(2);
		arr.add(3);
		arr.add(4);
		arr.add(0,0);//插入到指定位置
		arr.delete();//删除最后一个
		//arr.delete(1);//删除指定位置
		System.out.println(arr);//打印顺序表
		arr.clear();//清空顺序表
		System.out.println(arr.isEmpty());//判断是否为空
	}
	
}

本人拙见，有错请指正！

next：线性表之链表