Java算法手册读书笔记 04.数据结构之顺序表

01.什么是顺序表

顺序表（Sequential List）是按照顺序存储是存储的线性表。

该线性表的结点按照逻辑次序存放在计算机的一组连续的存储单元中，由于是依次存放，只要知道了顺序表的首地址即每个数据元素所占用的存储长度，就可以计算出任何一个数据元素（结点）存放的位置。

假设顺序表中所有的类型相同，则每个结点所占用的存储空间大小相同，每个结点占用c个存储单元，其中第一个单元的存储地址则为该结点的存储地址，并设顺序表中开始结点a1的存储地址（简称为基地址）为LOC(A1) ,  那么结点ai的存储地址LOC(Ai)可如下表示

LOC(Ai) = LOC(Ai) + (i-1) * c      1<=i<=n

02.构建顺序表

数据结点

package algorithm.chapter02.SequentialList.code;

/**
 * 数据结点
 */
public class DATA {

	/** 结点关键字 **/
	public String key;
	/** 名称 **/
	public String name;
	/** 年龄 **/
	public int age;
	
}

顺序表

package algorithm.chapter02.SequentialList.code;

/**
 * 顺序表
 */
public class SequenceList {

	/** 定义顺序表的最大长度 **/
	public static final int MAXLEN = 100; 
	/** 保存顺序表结构数组 **/
	public DATA[] listData = new DATA[MAXLEN+1];
	/** 顺序表已存结点数量 **/
	public int listLen ; 
	
	/**
	 * 返回顺序表中元素数量
	 * @param type
	 * @return
	 */
	public int init(SequenceList sl) {
		return sl.listLen;
	}
	
	/**
	 * 插入结点
	 * @param sl
	 * @param n
	 * @param data
	 * @return
	 */
	public int insert(SequenceList sl, int n, DATA data) {
		if(sl.listLen >= MAXLEN) { //顺序表结点数量以超过最大数量
			System.out.println("顺序表已满，不能插入结点");
			return 0;
		}
		if(n<1 || n>sl.listLen-1) { //插入结点的序号不正确
			System.out.println("插入元素序号错误，不能插入元素");
			return 0;
		}
		for (int i = sl.listLen; i >= n; i--) { //将顺序表中的数据向后移动
			sl.listData[i+1] = sl.listData[i];
		}
		sl.listData[n] = data;
		sl.listLen++;
		return 1;
	}
	
	/**
	 * 从顺序表尾部添加结点
	 * @param sl
	 * @param data
	 * @return
	 */
	public int add(SequenceList sl, DATA data) {
		if(sl.listLen >= MAXLEN) { //顺序表已满
			System.out.println("顺序表已满，不能添加结点");
			return 0;
		}
		sl.listData[++sl.listLen] = data;
		return 1;
	}
	
	/**
	 * 删除顺序表中的数据元素
	 * @param sl
	 * @param n
	 * @return
	 */
	public int delete(SequenceList sl, int n) {
		if(n<1 || n>sl.listLen+1) {
			System.out.println("删除结点序号错误，不能删除结点");
			return 0;
		}
		for (int i = 0; i < sl.listLen; i++) {
			sl.listData[i] = sl.listData[i+1];
		}
		sl.listLen--;
		return 1;
	}
	
	/**
	 * 根据序号返回数据元素
	 * @param sl
	 * @param n
	 * @return
	 */
	public DATA findNodeByNum(SequenceList sl, int n) {
		if(n<1 || n>sl.listLen+1) {
			System.out.println("结点序号错误，不能返回结点");
			return null;
		}
		return sl.listData[n];
	}
	
	/**
	 * 按关键字查询结点
	 * @param sl
	 * @param key
	 * @return
	 */
	public int findByCont(SequenceList sl, String key) { 
		DATA[] list = sl.listData;
		for (int i = 1; i <= sl.listLen; i++) {
			if(list[i].key.compareTo(key) == 0) { //找到所需要结点
				return i;
			}
		}
		return 0;
	}
	
	/**
	 * 现实顺序表中所有结点
	 * @param sl
	 * @return
	 */
	public int all(SequenceList sl) {
		for (int i = 1; i <= sl.listLen; i++) {
			DATA data = sl.listData[i];
			if(data!=null) {
				System.out.printf("(%s,%s,%d)",sl.listData[i].key,sl.listData[i].name,sl.listData[i].age);
			}
		}
		return 0;
	}
	
}

    //测试代码
	private static void test() {

		SequenceList sl = new SequenceList();
		sl.init(sl);
		for (int i = 0; i < 100; i++) {
			DATA data = new DATA();
			data.key = String.valueOf(i);
			data.name =  "No." + String.valueOf(i);
			data.age = i;
			sl.add(sl, data);
		}
		
		sl.all(sl);
		
		System.out.println("输入要查找的结点序号:");
		Scanner input = new Scanner(System.in);
		int i = input.nextInt();
		DATA pdata = sl.findNodeByNum(sl, i);
		if(pdata != null) {
			System.out.printf("第%d个结点为:(%s,%s,%d)",i,pdata.key,pdata.name,pdata.age);
		}
		
		System.out.println("输入要查找的结点关键字:");
		String key = input.next();
		int j = sl.findByCont(sl, key);
		pdata = sl.findNodeByNum(sl, j);
		if(pdata!=null) {
			System.out.printf("第%d个结点为:(%s,%s,%d)",i,pdata.key,pdata.name,pdata.age);
		}
		
	}

顺序表的存储方式很方便，但是有如下缺点

1.在插入或删除节点时，往往需要移动大量数据。

2.如果表比较大，比较难分配足够多的连续存储空间，导致内存分配失败，无法存储。