线性表介绍

数据结构中的线性存储结构分为两大类：顺序存储和链式存储，顺序存储对应的是顺序表，链式存储对应的是链表。这篇文章主要介绍如何使用Java实现一个顺序表。

顺序表介绍

顺序表： 把线性表的元素按照一定逻辑顺序依次放在一组地址连续的存储单元里，用这种方式存储的线性表简称为 顺序表。而链表中的元素是没有放在一组地址连续的存储单元里，它们之间的链接是靠指针串一起的。

优点：随机存取表中元素。随机存取的意思是对所有元素序号来讲都是一样的计算时间，也就是说，访问任何一个元素的时间都是相同的。由于每个元素在计算机中占有的存储单元是相同的（假设占有的空间是c），则可知a[i]所在的存储地址是： Loc(ai)=Loc(a0)+i*c，访问不同存储位置的元素时间都是相同的，因此顺序标是随机存取。

缺点：插入和删除比较慢，不可以增加长度，如想增加长度，则需另开内存将原数组复制到新空间。

Java->顺序表API

先看看代码的API，有助于理解代码（虽说代码中的注释很完整。。。）：

setIncr(int inc): 设置顺序表每次增加时增量的大小
setCapacity(int newSize): 设置新的最大容量
getCapacity(): 获取数组的最大容量
size(): 获取顺序表已经存放数据的数量，同length()
get(int i): 获取顺序表下标为i的元素值
set(int i,T x): 修改下标值为i的元素值，即为修改data[i]
indexOf(int begin,int end,T value): 在begin和end之间查找值为value的元素下标值，使用顺序查找法
indexOf(T o): 在整个线性表中查找元素o的下标值
indexOf(int begin,T o): 在下标为begin到末尾的线性表中查找元素o的下标值
add(int i,T x): 在i位置插入数据元素x
add(T x): 在表尾添加数据元素x
append(T x): 在表尾添加数据元素x
addSort(T x): 以有序方式向顺序表中插入数据元素x
sort(): 对顺序表从小到大排序
remove(int i): 删除下标为i的元素，并返回被删除的元素
remove(T value): 删除值为value的元素,并返回被删除的元素
clear(): 清除整个顺序表
toString(): 将顺序表转化成字符串，便于直接输出顺序表
toArray(): 将顺序表转化成Object数组，并返回
toArray(T[] a): 将顺序表转换为类型为E的数组
iterator(): 返回一个迭代对象
length(): 获取线性表长度
isEmpty(): 判断线性表是否为空

Java->顺序表代码

/** created on April 15 8:20 2019** @author:lhy*/package DS;import java.util.Arrays;
import java.util.Iterator;import org.w3c.dom.html.HTMLIsIndexElement;interface MyList<T>{//接口中每一个方法都是隐式抽象的，接口中所有方法会被隐式指定为public abstract类型（且只能是public abstract）//接口中的变量会被隐式指定为public static final类型变量//接口中的函数不能在接口中实现，只能由实现接口的类来实现接口中的方法boolean isEmpty();//判断线性表是否为空int length();//获得List的元素个数T get(int i);//取得第i个位置上的数据元素，返回数据元素的值boolean set(int i,T x);//将第i个位置上的数据元素设置为值xvoid add(int i,T x);//位置i及其后的元素依次后移一个位置，然后将x插入到第i个位置T remove(int i);//删除第i个位置上的数据元素，位置i+1及其后的元素依次前移一个位置int indexOf(T x);//获取数据元素x在表中的下标位置
}abstract class AbsList<T> implements Iterable<T>,MyList<T>{//必须实现接口MyList中所描述的所有方法，否则必须声明为抽象类protected int length;//length指的是这个顺序表已经容纳的元素个数abstract public T get(int i);//返回第i个元素abstract public boolean set(int i,T x);//设置第i个元素的值为xabstract public int indexOf(int begin,int end,T o);//在begin和end之间寻找值为o的元素的下标abstract public void add(int i,T x);//插入x作为第i个元素abstract public void clear();//清空列表abstract public T remove(int i);//删除第i个元素并返回被删除对象abstract public Iterator<T> iterator();//返回一个迭代器//判断线性表是否为空public boolean isEmpty() {return length==0;}//获取线性表长度public int length(){return length;}//在线性表最后插入x元素public void add(T x) {add(length,x);}//与add一样public void append(T x) {add(length,x);}//在整个线性表中查找元素o的下标值public int indexOf(T o) {return indexOf(0,length,o);}//在下标为begin到末尾的线性表中查找元素o的下标值public int indexOf(int begin,T o) {return indexOf(begin,length,o);}//删除第i个元素并返回删除对象public T remove(T o) {return remove(indexOf(o));}
}/** SeqList API介绍* setIncr(int inc): 设置顺序表每次增加时增量的大小* setCapacity(int newSize): 设置新的最大容量* getCapacity(): 获取数组的最大容量* size(): 获取顺序表已经存放数据的数量，同length()* get(int i): 获取顺序表下标为i的元素值* set(int i,T x): 修改下标值为i的元素值，即为修改data[i]* indexOf(int begin,int end,T value): 在begin和end之间查找值为value的元素下标值，使用顺序查找法* indexOf(T o): 在整个线性表中查找元素o的下标值* indexOf(int begin,T o): 在下标为begin到末尾的线性表中查找元素o的下标值* add(int i,T x): 在i位置插入数据元素x* add(T x): 在表尾添加数据元素x* append(T x): 在表尾添加数据元素x* addSort(T x): 以有序方式向顺序表中插入数据元素x* sort(): 对顺序表从小到大排序* remove(int i): 删除下标为i的元素，并返回被删除的元素* remove(T value): 删除值为value的元素,并返回被删除的元素* clear(): 清除整个顺序表* toString(): 将顺序表转化成字符串，便于直接输出顺序表* toArray(): 将顺序表转化成Object数组，并返回* toArray(T[] a): 将顺序表转换为类型为E的数组* iterator(): 返回一个迭代对象* length(): 获取线性表长度* isEmpty(): 判断线性表是否为空*/public class SeqList<T> extends AbsList<T> implements Iterable<T> {//必须实现抽象类AbsList中的所有抽象方法private int incrementSize;//顺序表每次增量的长度protected Object[] data;//保存顺序表数据的数组//默认构造函数public SeqList() {this(16);}//构造函数，设定初始容量为initLenpublic SeqList(int initLen) {if(initLen<=0) {initLen=16;}length=0;incrementSize=16;data=new Object[initLen];}//构造函数，用elem数组初始化顺序表public SeqList(T[] elem) {length=elem.length;incrementSize=16;data=Arrays.copyOf(elem, length);}//设置顺序表每次容量增加时增量的大小，默认是16public void setIncr(int inc) {incrementSize=inc;}//设置新的数组容量public void setCapacity(int newSize) {data=Arrays.copyOf(data, newSize);}//获得data数组的最大容量public int getCapacity() {return data.length;}//获取顺序表已经存放数据的数量，同length()public int size() {return length;}//取得顺序表下标为i的元素值，即data[i]public T get(int i) {if(i<0 || i>length-1)return null;return (T)data[i];}//修改下标值为i的元素值，即修改data[i]public boolean set(int i,T x) {if(i<0 || i>length-1)return false;else{data[i]=x;return true;}}//内部使用，提供数据元素的比较方法private int compare(T a,T b) {if(a instanceof Comparable && b instanceof Comparable) {return ((Comparable) a).compareTo((Comparable) b);}else {return ((String) a).compareTo((String) b);}}//在begin和end之间查找值为value的数据元素下标，使用顺序查找法public int indexOf(int begin,int end,T value) {//先查找null值if(value==null) {for(int i=0;i<length;i++) {if(data[i]==null) {return i;}}}//查找有效值else {for(int i=0;i<length;i++) {if(compare((T)data[i],value)==0) {return i;}}}return -1;}//内部使用，自动增加顺序表容量private void grow() {int newSize=data.length+incrementSize;data=Arrays.copyOf(data, newSize);}//在i位置插入数据元素xpublic void add(int i, T x) {//顺序表存满的时候自动增加顺序表容量if(length==data.length)grow();if(i<0) i=0;if(i>length) {i=length;}for(int j=length-1;j>=i;j--) {data[j+1]=data[j];}data[i]=x;length++;}//向表尾添加数据元素xpublic void add(T x) {if(length==data.length) {grow();}data[length]=x;length++;}//向表尾添加数据元素x,功能同上public void append(T x) {add(x);}//内部使用，以有序方式插入数据元素xprivate void insertOrder(int end,T x) {if(length==data.length) {grow();}int k;for(k=end-1;k>=0;k--) {//当x小于data[k]时if(compare(x,(T)data[k])<0) {data[k+1]=data[k];}else break;}data[k+1]=x;}//以有序方式向顺序表中插入数据元素xpublic void addSort(T x) {insertOrder(length,x);length++;}//对顺序表排序public void sort() {for(int i=1;i<=length-1;i++) {//调用插入函数insertOrder完成具体插入过程insertOrder(i, (T)data[i]);}}//删除下标为i的元素，并返回被删除的元素public T remove(int i) {if(i<0 || i>length-1)throw new IndexOutOfBoundsException("下标越界 i="+i);T olddata=(T)data[i];for(int j=i;j<length-1;j++) {data[j]=data[j+1];}length--;data[length]=null;return olddata;}//删除值为value的元素public T remove(T value) {int i=indexOf(value);return remove(i);}//清除整个列表public void clear() {for(int i=0;i<length;i++)//将元素指向空指针，使用Java虚拟机的辣鸡回收机制自动处理data[i]=null;length=0;}//将顺序表转化成字符串，便于直接输出顺序表public String toString() {StringBuilder strbui=new StringBuilder();strbui=strbui.append("(");for(int i=0;i<length-1;i++) {strbui.append(data[i].toString()+",");}strbui=strbui.append(data[length-1].toString()+")");String string=new String(strbui);strbui=null;return string;}//将顺序表转化成Object数组，并返回public Object[] toArray() {return Arrays.copyOf(this.data, this.length);}//将顺序表转换为类型为T的数组（因为T是泛型，理论上可以代表任何变量类型）public T[] toArray(T[] a) {//当传入的数组a的长度小于顺序表的长度时，创建一个与数组a的运行时类型相同的数组，a的长度可以是0if(a.length<length) {return (T[]) Arrays.copyOf(this.data, this.length,a.getClass());}//将data里面的以第1个元素复制到a中第1个元素，以此往后加一，一共加到this.length-1的位置System.arraycopy(this.data, 0, a, 0, this.length);if(a.length>this.length) {a[length]=null;}return a;}//创建一个迭代器类class MyIterator implements Iterator<T>{private int index=0;public boolean hasNext() {return index!=length();}public T next() {//用索引来获取SeqList中下标为index的项return get(index++);}public void remove() {//未实现此方法}}//返回一个迭代器对象public Iterator<T> iterator(){return new MyIterator();}
}

使用顺序表示例

创建一个顺序表并对以上类中函数进行实现检验，代码如下：

/** created on April 16 21:33 2019* * @author:lhy*/
package DS;
import java.util.Iterator;import DS.SeqList;/** SeqList API介绍* setIncr(int inc): 设置顺序表每次增加时增量的大小* setCapacity(int newSize): 设置新的最大容量* getCapacity(): 获取数组的最大容量* size(): 获取顺序表已经存放数据的数量，同length()* get(int i): 获取顺序表下标为i的元素值* set(int i,T x): 修改下标值为i的元素值，即为修改data[i]* indexOf(int begin,int end,T value): 在begin和end之间查找值为value的元素下标值，使用顺序查找法* indexOf(T o): 在整个线性表中查找元素o的下标值* indexOf(int begin,T o): 在下标为begin到末尾的线性表中查找元素o的下标值* add(int i,T x): 在i位置插入数据元素x* add(T x): 在表尾添加数据元素x* append(T x): 在表尾添加数据元素x* addSort(T x): 以有序方式向顺序表中插入数据元素x* sort(): 对顺序表从小到大排序* remove(int i): 删除下标为i的元素，并返回被删除的元素* remove(T value): 删除值为value的元素,并返回被删除的元素* clear(): 清除整个顺序表* toString(): 将顺序表转化成字符串，便于直接输出顺序表* toArray(): 将顺序表转化成Object数组，并返回* toArray(T[] a): 将顺序表转换为类型为E的数组* iterator(): 返回一个迭代对象* length(): 获取线性表长度* isEmpty(): 判断线性表是否为空*/public class Test_SeqList {public static void main(String[] args) {//new一个顺序表对象SeqList<Integer> seqList= new SeqList<Integer>(16);System.out.println("顺序表是否为空："+seqList.isEmpty());//随机初始化顺序表for(int i=0;i<6;i++)seqList.add((int)(1+Math.random()*(1000)));//创建一个顺序表迭代器，并输出顺序表Iterator<Integer> seq_iterator=seqList.iterator();System.out.print("使用迭代器输出整个顺序表：");for(int i=0;i<6;i++)System.out.print(seq_iterator.next()+" ");System.out.print("\n");System.out.println("初始化后，顺序表是否为空："+seqList.isEmpty());System.out.println("获取顺序表容量："+seqList.getCapacity());System.out.println("删除下标为2的元素:"+seqList.remove(2));System.out.println("删除下标为2的元素之后顺序表为:"+seqList.toString());seqList.append(78);System.out.println("顺序表末尾加入数据78之后顺序表为："+seqList.toString());seqList.sort();System.out.println("将顺序表从大到小排序后顺序表为："+seqList.toString());seqList.add(1,233);System.out.println("在下标为1的位置插入元素233之后，顺序表为："+seqList.toString());System.out.println("获取下标为length-1(最后一个元素)的位置的元素为："+seqList.get(seqList.length()-1));seqList.add(998);System.out.println("顺序表末尾加入数据998之后顺序表为："+seqList.toString());seqList.sort();seqList.addSort(555);System.out.println("对顺序表排序后，有序插入数据555顺序表为："+seqList.toString());System.out.println("查找排序后的元素555所在的位置："+seqList.indexOf(0,seqList.length(),555));seqList.setCapacity(32);System.out.println("将顺序表最大容量变成32之后，最大容量为"+seqList.getCapacity());Integer num=new Integer(555);System.out.println("删除元素555："+seqList.remove(num));System.out.println("删除元素555之后顺序表为："+seqList.toString());//将seqList顺序表转化成Integer[]数组,使用toArray(),这个函数返回的是Object[]类型的数组Integer[] nums=new Integer[seqList.length()];//TIPS:因为Integer[]不是Object[]的子类，所以不能直接强制类型转换（Integer是Object的子类）Object[] nums_object=seqList.toArray();for(int i=0;i<nums.length;i++)nums[i]=(Integer)nums_object[i];System.out.print("输出转化后的数组num：");for(int j=0;j<nums.length;j++) {System.out.print(nums[j]+" ");}System.out.print("\n");//将seqList顺序表转化成Integer[]数组,使用toArray(T[] a)),这个函数返回的是T类型的数组Integer[] nums2=new Integer[seqList.length()];nums2=seqList.toArray(nums2);System.out.print("输出转化后的数组num2：");for(int j=0;j<nums2.length;j++) {System.out.print(nums2[j]+" ");}System.out.print("\n");System.out.println("使用clear函数清空整个顺序表");seqList.clear();System.out.println("顺序表现在是否为空："+seqList.isEmpty());}}

输出为：

顺序表是否为空：true
使用迭代器输出整个顺序表：700 889 70 218 510 319
初始化后，顺序表是否为空：false
获取顺序表容量：16
删除下标为2的元素:70
删除下标为2的元素之后顺序表为:(700,889,218,510,319)
顺序表末尾加入数据78之后顺序表为：(700,889,218,510,319,78)
将顺序表从大到小排序后顺序表为：(78,218,319,510,700,889)
在下标为1的位置插入元素233之后，顺序表为：(78,233,218,319,510,700,889)
获取下标为length-1(最后一个元素)的位置的元素为：889
顺序表末尾加入数据998之后顺序表为：(78,233,218,319,510,700,889,998)
对顺序表排序后，有序插入数据555顺序表为：(78,218,233,319,510,555,700,889,998)
查找排序后的元素555所在的位置：5
将顺序表最大容量变成32之后，最大容量为32
删除元素555：555
删除元素555之后顺序表为：(78,218,233,319,510,700,889,998)
输出转化后的数组num：78 218 233 319 510 700 889 998
输出转化后的数组num2：78 218 233 319 510 700 889 998
使用clear函数清空整个顺序表
顺序表现在是否为空：true

【数据结构】使用Java实现顺序表类 SeqList相关推荐

数据结构之C++实现顺序表（SeqList）无主函数
#include <iostream> using namespace std; #define SIZE 10 class SeqList { public:SeqList(){m_ca ...
线性表的顺序存储结构之顺序表类的实现_Java
在上一篇博文--线性表接口的实现_Java中,我们实现了线性表的接口,今天让我们来实现线性表的顺序存储结构--顺序表类. 首先让我们来看下顺序表的定义: 线性表的顺序存储是用一组连续的内存单元依次存放 ...
顺序表类的声明java_顺序表实现解约瑟夫环_Java
今天我们来使用顺序表类求解约瑟夫(Josephus)环问题. 首先我闲来描述下约瑟夫环问题:古代某法官要裁决n个犯人的死刑,他有一条荒唐的法律,将犯人站成一个圆圈,从第s个人开始数起,每数到第d个犯人 ...
java数据结构与算法之顺序表与链表深入分析
转载请注明出处(万分感谢!): http://blog.csdn.net/javazejian/article/details/52953190 出自[zejian的博客] 关联文章: java数据结 ...
java设计一个顺序表类的成员函数_顺序表代码讲解以及实现
用C语言编写一个有关顺序表的程序代码创建一个顺序表,其数据元素类型为整型: 在该顺序表中插入数据(#include #include #define MaxSize 50 typedef char ...
Java数据结构（1）---顺序表
以下程序在JDK1.5.0_05环境下调试通过,程序分3个文件,放在同一目录下 //List.java 顺序表抽象数据类型的接口定义 public interface List { publ ...
数据结构入门——顺序表（SeqList）详解（初始化、增、删、查、改）
SeqList顺序表 1. 线性表介绍 2. 顺序表 2.1 顺序表的结构介绍 2.2 顺序表的定义和接口声明--`SeqList.h` 2.3 顺序表接口函数的具体实现--`SeqList.c` 3 ...
顺序表——基本概念、顺序表类实现、基本操作
顺序表线性表的顺序存储结构 1.数组是实现顺序存储结构的基础. 特点:地址连续确定,容量固定,随机存取T(n) = O(1) 一维数组占用一块内存空间,数组的存储单元个数成为数组容量,也成为数字长度 ...
数据结构严薇敏顺序表的实现(增删改)及其使用方法详解
时间复杂度数据结构时间复杂度和空间复杂度目录 1.线性表 2.顺序表 2.1概念及结构 2.2 接口实现 SeqList.h SeqList.c 2.2.1初始化链表以及销毁链表的实现初始化顺 ...

【数据结构】使用Java实现顺序表类 SeqList

目录