数据结构—表

数据结构

• 数据元素是数据的基本单位，它在计算机处理和程序设计中通常作为独立个体
  

• 数据对象是具有相同特征的数据元素的集合，十数据的一个子集。
  

数据的物理结构

• 数据的物理结构又称存储结构，有顺序和链式两种不同的方式
• 顺序存储的特点是数据元素在存储器的相对位置来体现数据元素之间的相互关系
• 链式存储结构是通过一组任意存储单元来存储数据元素的，而这些存储单元可以是连续的也可以是不连续的

ADT 抽象数据类型名
{ 
 数据对象：<数据对象的定义>
 数据关系：<数据关系的定义>
 基本操作：<基本操作的定义>
}

线性表的逻辑结构

• 线性表示n个数据元素的有效序列，称n为线性表的表长当n=0时为空表
• aI时表中的数据元素称i为ai在线性表中的位序
• 线性表的顺序表示用一组地址连续的存储单元依次存储线性表的数据元素。称之为顺序表

顺序表

public class sequenceList<T>{
final int maxSize=10;//一维数组的初始长度
private T[] listArray;//存储元素数据对象
private int lengh;//保证顺序表当前长度
}

• 顺序表的插入

for(int i=length;i>=pos;i--)
   listArray[i]=listArray[i-1];//插入数据元素后按照从后到前的次序依次后移一个位置

• 代码

package 数据结构;
/**
 * 顺序表类声明
 * @author wgq
 *
 * @param <T>表示顺序表数据元素的数据类型，创建该类时，
 * T的实际参数为一个确定的类。例如：
 * String values[]={"a","b","c","d","e"};
 * SeqList<String> lista = new SeqList<String>(values);
 * 
 */

public class SeqList<T> {
	protected Object[] element;//对象数组
	protected int n;//元素个数
	public SeqList(int length) {
		//构造容量为length的空表
		this.element = new Object[length];//申请数组的存储空间，元素为null。
		this.n=0;
	}
	public SeqList() {
		//构造方法重载
		this(64);//创造一个容量为64的数组
	}
	public SeqList(T[] values) {//由values数组提供元素
		this(values.length);//创建容量为values.length的空表
		for (int i = 0; i < values.length; i++) {//赋值数组元素，O(n)
			this.element[i] = values[i];//对象引用赋值	
		}
		this.n = element.length;//把顺序表中的元素个数赋值给表长n、
	}
	public boolean isEmpty() {//判断表是否为空，空返回true
		return this.n == 0;	
	}
	public int size() {//返回表元素个数
		return this.n;
	}
	public T get(int i) {
		if (i>=0 && i<this.n) {//&&表示逻辑与
			return (T) this.element[i];//(T) this.element[i]是将element的返回值强制转换成T
		}
		return null;
	}
	public void set(int i,T x) {
		/**
		 * 设置第i个元素为x，0<=i<n
		 */
		if (x == null) {
			throw new NullPointerException("x==null");//抛出空对象异常			
		}
		if (i>=0 && i<this.n) {
			this.element[i] = x;	
		}else {
			throw new IndexOutOfBoundsException(i+"");//抛出序号越界异常
		}
	}
	public int insert(int i,T x) {
		/**
		 * 插入x作为第i个元素，x=null，抛出空对象异常
		 */
		if(x==null) {
			throw new NullPointerException("x==null");
			
		}
		if(i<0) {
			i=0;//插在最前
		}
		if(i>this.n) {
			i= this.n;//插在最后
		}
		Object[] source = this.element;//数组变量引用赋值，source也应用element数组
		if(this.n == element.length) {//若数组满则扩充
			this.element = new Object[source.length*2];//重新申请一个容量更大的数组
			for (int j = 0; j < i; j--) {//复制当前数组前i-1个元素
				this.element[j] = source[j];
				
			}
		}
		for(int j=this.n-1;j>=i;j--) {//从i开始至表尾的元素向后移动，次序从何向前
			this.element[j+1] = source[j];
		}
		this.element[i] = x;
		this.n++;
		return i;//返回x序号
	}
	public T resource(int i) {
		/**
		 * 删除第i个元素，返回被删除元素。若i越界返回null
		 */
		if (this.n>0 && i>=0 && i<this.n) {
			T old = (T)this.element[i];//old中存储被删除元素
			for (int j = i; j<this.n-1; j++) {
				this.element[j] = this.element[j+1];//元素前移一个位置
			}
			this.element[this.n-1] = null;//设置数组元素对象为空，释放原引用实例
			this.n--;
			return old;//返回old局部变量应用的对象
		}
		return null;
	}
	public static void main(String[] args) {
		String values[]={"a","b","c","d","e"};
		SeqList<String> lista = new SeqList<String>(values);
		lista.set(2,"f");
		System.out.println("元素个数有"+lista.size()+"个");
		System.out.println(lista.resource(2));
		System.out.println("第一位元素是"+lista.get(0));
		System.out.println("第二位元素是"+lista.get(1));
		System.out.println("第三位元素是"+lista.get(2));
		System.out.println("第四位元素是"+lista.get(3));
		System.out.println("第五位元素是"+lista.get(4));
		System.out.println("第六位元素是"+lista.get(5));
	}


	

}

链式表

• 线性表的链式存储结构是用一组任意的存储单元来存放线性表的数据元素，可以是连续的也可以是不连续的
  对每个数据元素ai，除了存储其本身信息外还需存储一个指示其后继存放位置的指针
  
  
• 单链表的实现

public class linkList<T>{
private Node<T> head;
private int length;//存放单链表长度
}

• 循环链表特点是表中最后一个结点的指针域不在为空，而是指向表头结点整个链表形成一个环
  
• 双向链表
  
• 双向链表插入
  
• 删除