java实现线性表

线性表的定义:线性表是n个类型相同的数据元素的有限序列。线性表中元素的个数N定义为线性表的长度。当N为0的时候定义为空表，在非空的线性表中每个数据元素在线性表中都有唯一确定的序号。

线性结构是最简单最常用的结构：线性结构的特点是：在数据元素的有限集中，除第一个元素无直接前驱，最后一个元素无直接后续外，每个元素有且仅有一个直接前驱和一个直接后续。

所以线性表和数组有点类似，线性表与数组之间的区别如下：
    1.概念上来讲：首先线性表是一种抽象数据类型，数组是一种具体的数据结构
    2.逻辑结构：线性表是元素之间具有1对1的线性关系的数据元素的集合，而数组是一组数据元素到数组下标的一一映射。
    3.物理性质：数组中相邻元素是连续的存储在内存的，线性表只是一个抽象的数据数学结构，并没有具体的物理形式。

线性表的实现方式包括俩种：

• 线性表的顺序存储结构[基于数组的实现]
  

定义线性表顺序存储结构的接口：

package 线性表.sunxu;/** * 定义线性表中的相关操作 * @author acer * 将数据的类型定义为Object类型，Object类式所有其他类的父类，因此其他任何类的引用或者任何类类型的变量都可以赋给Object类型的变量 * 这样实现的抽象数据类型对任何一种数据元素都适用。 */public interface List {//返回线性表的大小，即数据元素的个数public int getSize();//如果线性表为空，那么返回true，否则返回falsepublic boolean isEmpty();//判断线性表中是否包含元素Epublic boolean contains(Object e);//返回元素e在线性表中的序号public int indexOf(Object e);//将数据元素e插入到线性表中i号位置public void insert(int i,Object e) throws OutOfBoundaryException;//将元素e插入到元素obj之前public boolean insertBefore(Object obj,Object e);//将元素e插入到元素obj之后public boolean insertAfter(Object obj,Object e);//删除线性表中第i个元素，并将他返回public Object remove(int i) throws OutOfBoundaryException;//删除线性表中第一个与元素e相同的元素public boolean remove(Object e);//替换线性表中序号为i的数据元素为e,返回原数据元素public Object replace(int i,Object e) throws OutOfBoundaryException;//返回线性表中序号为i的元素public Object get(int i) throws OutOfBoundaryException;}

定义异常：

package 线性表.sunxu;/** * 定义异常 * @author acer */public class OutOfBoundaryException extends Exception {private static final long serialVersionUID = 1L;public OutOfBoundaryException(String err){super(err);}}

定义比较策略：

package 线性表.sunxu;/** * 将所有的数据类型都使用Object类来代替，那么在对俩个数据进行比较的时候便出现了不变，所有数据种类的比较就都需要使用Object类型的变量来完成。 * 但是不同的数据类型的比较是不同的，为此我们引入strategy接口,实现了这个接口就可以实现不同的比较策略 * @author acer */public interface Strategy {public boolean equals(Object obj1,Object obj2);public int compare(Object obj1,Object obj2);}线性表的实现：
package 线性表.sunxu;/** * 线性表的顺序存储与实现 * @author acer * 1.使用一组地址连续的存储单元依次存储线性表的数据元素，假设数据表中的每个数据元素需要占用K个存储单元，并以元素所占的第一个存储单元的地址作为数据元素的存储地址。 *    那么很容易得出第i个与第i+1个数据元素存储地址之间的关系。所以只要确定了线性表的起始地址，线性表中的任何一个数据元素都可以随机存取。因此线性表的顺序存储结构是一种 *    随机的存储结构。 */public class ListArray implements List{private final int LEN = 8;//数组的默认大小private Strategy strategy;//数据元素比较策略private int size;//线性表中数据元素的个数private Object[] elements;//数据元素数组/** * 构造方法 */public ListArray(){this(new DefaultStrategy());}public ListArray(Strategy strategy) {this.strategy = strategy;this.size = 0;elements = new Object[LEN];}@Overridepublic int getSize() {return size;}@Overridepublic boolean isEmpty() {return size == 0;}@Overridepublic boolean contains(Object e) {for(int i=0;i<size;i++) {if(strategy.equals(elements[i], e)){return true;}}return false;}@Overridepublic int indexOf(Object e) {for(int i=0;i<size;i++) {if(strategy.equals(elements[i], e)){return i;}}return -1;}@Overridepublic void insert(int i, Object e) throws OutOfBoundaryException {if(i<0 || i>size)throw new OutOfBoundaryException("超出线性表边界异常");if(size >= elements.length) {//如果系统需要扩容expandSpace();}for(int j=size;j>i;j--){elements[j] = elements[j-1];}elements[i] = e;size ++;}//进行扩容public void expandSpace(){Object a [] = new Object[elements.length*2];for(int i=0;i<size;i++) {a[i] = elements[i];}elements = a;//旧数组失去引用，将要被回收}@Overridepublic boolean insertBefore(Object obj, Object e)  {int i = this.indexOf(obj);if(i < 0) {return false;}try {this.insert(i, e);} catch (OutOfBoundaryException e1) {e1.printStackTrace();}return true;}@Overridepublic boolean insertAfter(Object obj, Object e) {int i = this.indexOf(obj);if(i < 0) {return false;}try {this.insert(i+1, e);} catch (OutOfBoundaryException e1) {e1.printStackTrace();}return true;}@Overridepublic Object remove(int i) throws OutOfBoundaryException {if(i<0 || i>size)throw new OutOfBoundaryException("超出范围");for(int j = i ;j<size;j++){elements[j] = elements[j+1];}elements[--size] = null;this.size --;return elements[i];}@Overridepublic boolean remove(Object e) {int i = this.indexOf(e);try {this.remove(i);} catch (OutOfBoundaryException e1) {// TODO Auto-generated catch blocke1.printStackTrace();}return true;}@Overridepublic Object replace(int i, Object e) throws OutOfBoundaryException {if(i<0 || i>size)throw new OutOfBoundaryException("超出范围");Object o = elements[i];elements[i] = e;return o;}@Overridepublic Object get(int i) throws OutOfBoundaryException {if(i<0 || i>size)throw new OutOfBoundaryException("超出范围");return elements[i];}}class DefaultStrategy implements Strategy{@Overridepublic boolean equals(Object obj1, Object obj2) {return false;}@Overridepublic int compare(Object obj1, Object obj2) {return obj1.toString().compareTo(obj2.toString());}}


线性表的链式存储实现
用指针将存储线性表中数据元素的那些单元依次串联在一起。这种方法避免了在数组中连续用存储单元存储元素的缺点，但是需要在每个单元中设置指针来表示表中元素之间的逻辑关系。
        
        单链表【single linked list】：除了尾节点外每个节点都只有一个指向后续节点的指针【java中使用对象】：优点：结构简单
        双向链表：单链表有一个缺点，只能访问后续节点，无法访问前驱节点，要在单链表中找到某个节点的前驱节点，必须从链表的首节点开始找。
package 线性表.linkedlist;/** * 定义线性表的节点 * @author acer */public interface Node {public Object getData();//获取节点数据域public void setData(Object o);//设置节点数据域}

package 线性表.linkedlist;/** * 单链表的节点定义 * @author acer * 单链表的节点是一个标准的javabean结构 */public class SLNode implements Node{private Object data;//定义数据域private SLNode next;//定义指针域public SLNode(){}public SLNode(Object o,SLNode n) {this.data = o;this.next = n;}public SLNode getNext() {return next;}public void setNext(SLNode next) {this.next = next;}@Overridepublic Object getData() {// TODO Auto-generated method stubreturn data;}@Overridepublic void setData(Object o) {this.data = o;}}

package 线性表.linkedlist;import 线性表.sunxu.*;public class ListSLinked{private Strategy strategy;//定义数据元素的比较策略private SLNode head;//单列表首节点的引用private int size;//线性表中数据元素的个数public ListSLinked() {new ListSLinked(new StudentStrategy());}public ListSLinked(Strategy strategy) {this.strategy = strategy;head = new SLNode();size = 0;}//添加部分工具方法//获取数据元素e所在节点的前驱节点private SLNode getPreNode(Object e) {SLNode p = head;while(p.getNext() != null) {if(strategy.equals(p.getNext().getData(), e))return p;elsep = p.getNext();}return null;}//获取序号为i的元素所在节点的前驱节点private SLNode getPreNode(int i) {SLNode p = head;for(int j=0;j<i;j++) {p = p.getNext();}return p;}//获取序号为i的元素所在的节点public SLNode getNode(int i) {return this.getPreNode(i-1).getNext();}//返回线性表的大小，即线性表中数据元素的个数public int getSize(){return size;}//判断线性表是否为空public boolean isEmpty(){return size == 0;}//判断线性表中是否包含数据元素epublic boolean contains(Object e) {SLNode p = head;while(p != null){if(strategy.equals(p.getData(),e))return true;p = p.getNext();}return false;}//返回数据元素e所在线性表中的序号,如果没有找到则返回-1public int indexOf(Object e) {SLNode p = head;int index = 0;while(p != null){if(strategy.equals(p.getData(),e))return index;p = p.getNext();index++;}return -1;}//将数据元素e插入到线性表中i号的位置public boolean insert(int i,Object o) throws OutOfBoundaryException {if(i<0 || i>size){return false;}SLNode p = getPreNode(i);SLNode node = new SLNode(o,p.getNext());p.setNext(node);size++;return true;}//将数据元素e插入到元素obj之后public boolean insertAfter(Object obj,Object e) throws OutOfBoundaryException{int i = this.indexOf(obj);boolean b = insert(i+1,e);return b;}//将数据元素e插入到元素obj之前public boolean insertBefore(Object obj,Object e) throws OutOfBoundaryException{int i = this.indexOf(obj);boolean b = insert(i,e);return b;}//删除线性表中序号为i的元素，并返回之public Object remove(int i) throws OutOfBoundaryException{if(i<0 || i>size) {throw new OutOfBoundaryException("超出边界了");}SLNode node = this.getNode(i);SLNode n = node.getNext();SLNode p = this.getPreNode(i);p.setNext(n);size --;return node.getData();}//删除线性表中第一个与e相同的元素public boolean remove(Object o) throws OutOfBoundaryException {int i = this.indexOf(o);Object e = this.remove(i);if(e != null)return true;return false;}//替换线性表中序号为i的数据元素为e,返回原数据元素public Object replace(int i,Object e) throws OutOfBoundaryException{if(i<0 || i>size)throw new OutOfBoundaryException("超出边界了");else {SLNode n = this.getNode(i);Object o = n.getData();n.setData(e);return o;}}//返回线性表中序号为i的元素public Object get(int i) throws OutOfBoundaryException{if(i<0 || i>size)throw new OutOfBoundaryException("超出边界了");return this.getNode(i).getData();}}

这就是线性表的链式存储结构实现。
这俩种实现方法的比较：线性表的操作主要包括：查找、插入、删除三类操作
    
    1、基于时间的比较：如果线性表的主要操作为插入，删除操作，那么使用链式存储的线性表性能最好
    2、基于空间的比较：顺序存储结构中，其存储空间是预先静态分配的，虽然在实现过程中可以动态扩展数组空间，如果线性表的长度范围变化较大，空间在使用过程中会存在大量的空闲空间使得空间的存储利用率不高。而线性表的链式存储结构完全相反，所以如果线性表的长度变化较大时，宜使用链式存储结构。

                                             
        0        0           
	
				
	
					   
Java实现线性表
	  	   
java线性表实现
	  	   
java 实现线性表
	  	   
Java实现线性表
	  	   
线性表java实现
	  	   
java实现线性表
	  	   
java 用链表实现线性表
	  	   
java 数组实现线性表
	  	   
java实现有序线性表
	  	   
【code】java线性表实现
	  	   
线性链表 java实现
	  	   
数据结构 线性表JAVA实现
	  	   
数据结构-Java实现线性表
	  	   
java实现线性链表
	  	   
【code】java线性表实现
	  	   
线性表的Java实现
	  	   
java实现线性表（数组实现）
	  	   
java 链表实现线性表
	     		  
	  	   
未能加载文件或程序集 Microsoft.ReportViewer.Common, Version=11.0.0.0
	  	   
git 本地分支与远程分支关联的一种方法
	  	   
Android应用开发：网络编程-1
	  	   
旋转字符串1347
	  	   
adb 常用命令
	  	   
java实现线性表
	  	   
最小公倍数最大公约数
	  	   
全排列——九个数排列组合得到1/3
	  	   
【商城开发四】Android商品详情全部评价（下拉刷新+上滑加载更多）
	  	   
Qt 操作注册表实现文件关联
	  	   
限制波尔兹曼机RBM
	  	   
北大菜鸟的忧伤.求关怀
	  	   
问题记录：NameNode is still loading. Redirecting to the Startup Progress page.
	  	   
使用adb操作android的sqlite出现的问题