顺序表

顺序表就是按照顺序存储方式存储的 线性表，该线性表的结点按照逻辑次序存放在计算机的一组连续的存储单元中！

由于顺序表是依次存放的，所以只要知道了该顺序表的首地址以及每个数据元素所占用的存储长度，那么很容易计算出任何一个数据元素(即数据结点)的位置

JAVA: 

<1>简单测试代码：

package club.jadeshu.dataStruct;

import java.lang.reflect.Array;

public class MyArray{
	private long[] arr;
	private int len;
	
	public MyArray() {
		this(50);
	}
	
	public MyArray(int size) {
		this.arr = new long[size];
		this.len = 0;
	}
	
	/*
	 * 添加数据
	 */
	public void add(long e) {
		this.arr[this.len] = e;
		this.len++;
	}
	
	/*
	 * 删除数据
	 */
	public boolean removeByData(long e) {
		for (int i = 0; i < this.len; i++) {
			if (this.arr[i] == e) {
				for (int j = i; j < (this.len-1); j++) {
					this.arr[j] = this.arr[j+1];
				}
				this.len--;
				return true;
			}
		}
		
		return false;
	}
	
	/*
	 * 根据索引进行删除
	 */
	public boolean removeByIndex(int index) {
		if (index < 0 || index >= this.len) {
			throw new ArrayIndexOutOfBoundsException();
		}
		
		for (int i = index; i < (this.len-1); i++) {
			this.arr[i] = this.arr[i+1];
		}
		
		this.len--;
		return true;
	}
	
	/*
	 * 显示数据
	 */
	public void show() {
		System.out.print("[");
		for (int i = 0; i < this.len; i++) {
			System.out.print(this.arr[i] + " ");
		}
		System.out.print("]");
	}
	
	/*
	 * 查找数据
	 */
	public int findByData(long e) {
		for (int i = 0; i < this.len; i++) {
			if (this.arr[i] == e) {
				return i;
			}
		}
		return -1;
	}
	/*
	 * 根据索引来查找数据
	 */
	public long findByIndex(int index) {
		if (index < 0 || index >= this.len) {
			throw new ArrayIndexOutOfBoundsException();
		}
		
		return this.arr[index];
	}
	
	/*
	 * 根据索引更新数据
	 */
	public void change(int index, long newValue) {
		if (index < 0 || index >= this.len) {
			throw new ArrayIndexOutOfBoundsException();
		}
		
		this.arr[index] = newValue;
	}
	
	public static void main(String[] args) {
		MyArray myArr = new MyArray();
		myArr.add(13);
		myArr.add(43);
		myArr.add(55);
		myArr.add(2);
		myArr.add(103);
		myArr.show();
		
		System.out.println();
		int index = myArr.findByData(103);
		System.out.println("位置在数组的第" + (index+1) + "位!");
		
		myArr.removeByData(103);
		myArr.show();
		
		System.out.println();
		myArr.removeByIndex(1);
		myArr.show();
		
		System.out.println();
		long num = myArr.findByIndex(0);
		System.out.println("根据索引查找到的数据为：" + num);
		
		myArr.removeByIndex(2);
		myArr.show();
	}
}

////泛型
//public class MyArray<T>{
//	private T[] arr;
//	private int len;
//	
//	public MyArray(Class<T> type) {
//		this(type, 50);
//	}
//	
//	public MyArray(Class<T> type,int size) {
//		// 记录: (T[])(Array.newInstance(arr.getClass().getComponentType(), size));
//		this.arr = (T[])Array.newInstance(type, size);
//		this.len = 0;
//	}
//	
//	/*
//	 * 添加数据
//	 */
//	public void add(T e) {
//		this.arr[this.len] = e;
//		this.len++;
//	}
//	
//	/*
//	 * 删除数据
//	 */
//	public boolean removeByData(T e) {
//		for (int i = 0; i < this.len; i++) {
//			if (this.arr[i] == e) {
//				for (int j = i; j < (this.len-1); j++) {
//					this.arr[j] = this.arr[j+1];
//				}
//				this.len--;
//				return true;
//			}
//		}
//		
//		return false;
//	}
//	
//	/*
//	 * 根据索引进行删除
//	 */
//	public boolean removeByIndex(int index) {
//		if (index < 0 || index >= this.len) {
//			throw new ArrayIndexOutOfBoundsException();
//		}
//		
//		for (int i = index; i < (this.len-1); i++) {
//			this.arr[i] = this.arr[i+1];
//		}
//		
//		this.len--;
//		return true;
//	}
//	
//	/*
//	 * 显示数据
//	 */
//	public void show() {
//		System.out.print("[");
//		for (int i = 0; i < this.len; i++) {
//			System.out.print(this.arr[i] + " ");
//		}
//		System.out.print("]");
//	}
//	
//	/*
//	 * 查找数据
//	 */
//	public int findByData(T e) {
//		for (int i = 0; i < this.len; i++) {
//			if (this.arr[i] == e) {
//				return i;
//			}
//		}
//		return -1;
//	}
//	/*
//	 * 根据索引来查找数据
//	 */
//	public T findByIndex(int index) {
//		if (index < 0 || index >= this.len) {
//			throw new ArrayIndexOutOfBoundsException();
//		}
//		
//		return this.arr[index];
//	}
//	
//	/*
//	 * 根据索引更新数据
//	 */
//	public void change(int index, T newValue) {
//		if (index < 0 || index >= this.len) {
//			throw new ArrayIndexOutOfBoundsException();
//		}
//		
//		this.arr[index] = newValue;
//	}
//	
//	public static void main(String[] args) {
//		MyArray<Long> myArr = new MyArray<Long>(Long.class);
//		myArr.add((long) 13);
//		myArr.add((long) 43);
//		myArr.add((long) 55);
//		myArr.add((long) 2);
//		myArr.add((long) 103);
//		myArr.show();
//		
//		System.out.println();
//		int index = myArr.findByData((long) 103);
//		System.out.println("位置在数组的第" + (index+1) + "位!");
//		
//		myArr.removeByData((long) 103);
//		myArr.show();
//		
//		System.out.println();
//		myArr.removeByIndex(1);
//		myArr.show();
//		
//		System.out.println();
//		long num = myArr.findByIndex(0);
//		System.out.println("根据索引查找到的数据为：" + num);
//		
//		myArr.removeByIndex(2);
//		myArr.show();
//	}
//}

 <2>.输入学号、姓名、年龄进行保存并测试!

import java.util.Scanner;

/***
 * @ClassName: Data 
 * @version V1.0
 * @author: jadeshu
 * @date: 2018年2月24日 下午11:26:07 
 * @Description:测试数据类的结构
 */
class Data {
	String key;		// 结点的关键字 
	String name;	// 保存的数据
	int age;		// 保存的数据
}

/***
 * @ClassName: SeqList 
 * @version V1.0
 * @author: jadeshu
 * @date: 2018年2月24日 下午11:25:52 
 * @Description:顺序表,索引从1开始存储
 */
class SeqList {
	static final int MAXLEN = 100;	// 定义顺序表的最大长度
	private Data[] listData = new Data[MAXLEN + 1];		// 保存顺序表的结构数组 从1开始
	private int size;	// 顺序表已存结点的数量
	
	public int getSize() { // 返回顺序表的元素个数
		return size;
	}

	public SeqList() {
		this.size = 0;
	}

	// 添加数据到顺序表末尾
	public boolean add(Data data) {
		if (this.size >= MAXLEN) {
			System.out.println("顺序表已满，不能再添加结点了！");
			return false;
		}
		
		this.listData[++this.size] = data;
		return true;
	}
	
	// 插入数据元素到顺序表的索引index处
	public boolean insert(int index, Data data) {
		if (this.size >= MAXLEN) {
			System.out.println("顺序表已满，不能插入结点！");
			return false;
		}
		
		if (index < 1 || index > this.size) {
			System.out.println("元素序号错误，不能插入元素！");
			return false;
		}
		
		for (int i = this.size; i >= index; i--) {
			this.listData[i + 1] = this.listData[i];
		}
		this.listData[index] = data;
		this.size++;
		return true;
	}
	
	// 根据索引删除顺序表中的数据元素
	public boolean delete(int index) {
		if (index < 1 || index > this.size) {
			System.out.println("删除结点序号错误，不能删除结点！");
            return false;              	//删除不成功，返回0
		}
		
		for (int i = index; i < this.size; i++) {
			this.listData[i] = this.listData[i + 1];
		}
		this.size--;
		return true;
	}
	
	// 根据索引返回数据
	public Data findByIndex(int index) {	
		if (index < 1 || index > this.size) {
			System.out.println("结点序号错误，不能返回结点！");
			return null;
		}
		
		return this.listData[index];
	}
	
	// 根据关键字key来查找,返回索引位置
	public int findByKey(String key) {
		for (int i = 1; i <= this.size; i++) {
			if (this.listData[i].key.compareTo(key) == 0) {
				return i;	// 返回节点序号
			}
		}
		return 0;	// 未找到
	}
	
	public void show() {
		for (int i = 1; i <= this.size; i++) {
			System.out.printf("%s,%s,%d\n", this.listData[i].key,
					this.listData[i].name, this.listData[i].age);
		}
	}
}

public class SequentialList {
	public static void main(String[] args) {
		
		System.out.println("顺序表操作练习！");
		SeqList sList = new SeqList();	// 定义顺序表
		Scanner scanner = new Scanner(System.in);
		
		do {
			System.out.println("请输入添加的结点(学号[key]、姓名、年龄)");
			Data data = new Data();
			data.key = scanner.next();
			data.name = scanner.next();
			data.age = scanner.nextInt();
			
			if (data.age != 0) {
				if (!sList.add(data)) {
					break;
				}
			} else {	// 输入年龄为0则退出输入
				break;
			}
		} while (true);
		
		System.out.println("顺序表中的节点顺序为：");
		sList.show();
		
		System.out.println("\n要取出结点的序号：");
		int index = scanner.nextInt();   //输入节点序号    
		Data pdata = sList.findByIndex(index);
		if (pdata != null) {
			System.out.printf("第%d个结点为：(%s,%s,%d)\n",index,pdata.key,pdata.name,pdata.age);
		}
		
		System.out.println("\n要查找结点的关键字：");
		String keyStr = scanner.next();
		index = sList.findByKey(keyStr); // 按关键字查找返回序号
		
		pdata = sList.findByIndex(index); // 按序号查找，返回节点数据
		if (pdata != null) {
			System.out.printf("第%d个结点为：(%s,%s,%d)\n",index,pdata.key,pdata.name,pdata.age);
		}
	}
}

C++

#include <iostream>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 存储空间初始分配量 */

typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int ElemType;        /* ElemType类型根据实际情况而定，这里假设为int */

typedef struct
{
	ElemType data[MAXSIZE];
	int length;
}SqList;

/* 初始化顺序线性表 */
Status InitList(SqList *L)
{
	L->length = 0;
	return OK;
}

/* 初始条件：顺序线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
Status ListEmpty(SqList L)
{
	return (L.length==0)?TRUE:FALSE;
}

/* 初始条件：顺序线性表L已存在。操作结果：将L重置为空表 */
Status ClearList(SqList *L)
{
	L->length = 0;
	return TRUE;
}

/* 初始条件：顺序线性表L已存在。操作结果：返回L中数据元素个数 */
Status ListLength(SqList L)
{
	return L.length;
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：用e返回L中第i个数据元素的值,注意i是指位置，第1个位置的数组是从0开始 */
Status GetElem(SqList L,int i,ElemType *e)
{
	if (L.length==0 || i<1 || i>L.length)
	{
		return ERROR;
	}
	*e = L.data[i-1];
	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：返回L中第1个与e满足关系的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
int LocateElem(SqList L,ElemType e)
{
	int i;
	if (L.length == 0)
	{
		return ERROR;
	}
	for (i=0;i<L.length;i++)
	{
		if (L.data[i]==e)
		{
			break;
		}
	}
	if (i>=L.length)
	{
		return ERROR;
	}
	return i+1;
}
/* 初始条件：顺序线性表L已存在,1≤i≤ListLength(L)， */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int i,ElemType e)
{
	int k;
	if (L->length == MAXSIZE)
	{
		return ERROR;
	}
	if (i<1 || i>L->length+1)
	{
		return ERROR;
	}
	if (i<=L->length)
	{
		for (k=L->length-1;k>=i-1;k--)
		{
			L->data[k+1]=L->data[k];
		}
	}
	L->data[i-1]=e;
	L->length++;
	return OK;
}

/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e)
{
	int k;
	if (L->length == 0)
	{
		return ERROR;
	}
	if (i<1 || i>L->length)
	{
		return ERROR;
	}
	*e=L->data[i-1];
	if (i<L->length)
	{
		for (k=i;k<L->length;k++)
		{
			L->data[k-1]=L->data[k];
		}
	}
	return OK;
}

/* 初始条件：顺序线性表L已存在 */
/* 操作结果：依次对L的每个数据元素输出 */
Status ListTraverse(SqList L)
{
	int i;
	if (L.length == 0)
	{
		return ERROR;
	}
	for (i=0;i<L.length;i++)
	{
		printf("%d ",L.data[i]);
	}
	return OK;
}

void unionL(SqList *La,SqList Lb)
{
	int La_len,Lb_len,i;
	ElemType e;
	La_len=ListLength(*La);
	Lb_len=ListLength(Lb);
	for (i=1;i<=Lb_len;i++)
	{
		GetElem(Lb,i,&e);
		if (!LocateElem(*La,e))
			ListInsert(La,++La_len,e);
	}
}
int main()
{
	SqList L;
	SqList Lb;

	ElemType e;
	Status i;
	int j,k;
	i=InitList(&L);
	printf("初始化L后：L.length=%d\n",L.length);
	for(j=1;j<=5;j++)
		i=ListInsert(&L,j,j);
	printf("在L的表头依次插入1～5后：L.data=");
	ListTraverse(L); 

	printf("L.length=%d \n",L.length);
	i=ListEmpty(L);
	printf("L是否空：i=%d(1:是 0:否)\n",i);

	i=ClearList(&L);
	printf("清空L后：L.length=%d\n",L.length);
	i=ListEmpty(L);
	printf("L是否空：i=%d(1:是 0:否)\n",i);

	for(j=1;j<=10;j++)
		ListInsert(&L,j,j);
	printf("在L的表尾依次插入1～10后：L.data=");
	ListTraverse(L); 

	printf("L.length=%d \n",L.length);

	ListInsert(&L,1,0);
	printf("在L的表头插入0后：L.data=");
	ListTraverse(L); 
	printf("L.length=%d \n",L.length);

	GetElem(L,5,&e);
	printf("第5个元素的值为：%d\n",e);
	for(j=3;j<=4;j++)
	{
		k=LocateElem(L,j);
		if(k)
			printf("第%d个元素的值为%d\n",k,j);
		else
			printf("没有值为%d的元素\n",j);
	}


	k=ListLength(L); /* k为表长 */
	for(j=k+1;j>=k;j--)
	{
		i=ListDelete(&L,j,&e); /* 删除第j个数据 */
		if(i==ERROR)
			printf("删除第%d个数据失败\n",j);
		else
			printf("删除第%d个的元素值为：%d\n",j,e);
	}
	printf("依次输出L的元素：");
	ListTraverse(L); 

	j=5;
	ListDelete(&L,j,&e); /* 删除第5个数据 */
	printf("删除第%d个的元素值为：%d\n",j,e);

	printf("依次输出L的元素：");
	ListTraverse(L); 

	//构造一个有10个数的Lb
	i=InitList(&Lb);
	for(j=6;j<=15;j++)
		i=ListInsert(&Lb,1,j);

	unionL(&L,Lb);

	printf("依次输出合并了Lb的L的元素：");
	ListTraverse(L); 
	return 0;
}