数据结构和算法分析之线性表

1.结构目录


如图:



自定义数组越界异常:

/**
* @ClassName: OutOfBoundaryException
* @Description: TODO  自定义的数组越界的异常
* @author 萨摩耶
* @date 2018年4月29日 下午3:37:11
*
*/
@SuppressWarnings("serial")
public class OutOfBoundaryException extends Exception{
    public OutOfBoundaryException(String message)
    {
        super(message);
    }

}


List接口:


/**
* @ClassName: List
* @Description: TODO 线性表的接口
* @author 萨摩耶
* @date 2018年4月29日 下午3:31:41
*
*/
public interface List {
    //返回线性表的大小,即数据元素的个数
    public int getSize();
    //如果线性表为空返回true否则返回false
    public boolean isEmpty();
    //判断线性表中是否包含数据元素e
    public 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;

}


strategy配置:(利用Object类型,就会产生一个问题:int类型和String类型的比较)

public interface Strategy {
    //判断两个数据元素是否相等
    public boolean equal(Object obj1,Object obj2);
    //比较两个数据元素的大小
    public int compare(Object obj1,Object obj2);

}


List接口的实现(ListArray.java):

public class ListArray implements List{

    private final int LEN=8;// 数组的默认大小
    private Strategy strategy;//数据元素的比较策略
    private int size;//线性表中数据元素的个数
    private Object[] elements;//数据元素数组
    public ListArray(Strategy strategy)
    {
        this.strategy=strategy;
        this.size=0;
        elements=new Object[LEN];
    }
    @Override
    public int getSize() {
        // TODO Auto-generated method stub
        return size;
    }

    @Override
    public boolean isEmpty() {
        // TODO Auto-generated method stub
        return size==0;
    }

    @Override
    public boolean contains(Object e) {
        // TODO Auto-generated method stub
        for(int i=0;i<size;i++)
        {
            if(strategy.equal(e,elements[i]))
                return true;
        }
        return false;
    }

    @Override
    public int indexOf(Object e) {
        // TODO Auto-generated method stub
        for(int i=0;i<size;i++)
        {
            if(strategy.equal(e,elements[i]))
                return i;
        }
        return -1;
    }

    @Override
    public void insert(int i, Object e) throws OutOfBoundaryException {
        // TODO Auto-generated method stub

        if(i<0||i>size)
            throw new OutOfBoundaryException("越界" );
        if(size>=elements.length)
            expandSapce();
        for(int j=size;j>i;j--)
            elements[j]=elements[j-1];
            elements[i]=e;
            size++;
            return;

    }
    public void expandSapce()
    {
        Object[] a=new Object[elements.length*2];
        for(int i=0;i<elements.length;i++)
        {
            a[i]=elements[i];
        }
        elements=a;
    }
    @Override
    public boolean insertBefore(Object obj, Object e) {
        // TODO Auto-generated method stub
        int i=indexOf(obj);
        if(i<0) return false;
        try {
            insert(i,e);
        } catch (OutOfBoundaryException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return true;
    }

    @Override
    public boolean insertAfter(Object obj, Object e) {
        // TODO Auto-generated method stub
        int i=indexOf(obj);
        if(i<0) return false;
        try {
            insert(i+1,e);
        } catch (OutOfBoundaryException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return true;
    }

    @Override
    public Object remove(int i) throws OutOfBoundaryException {
        // TODO Auto-generated method stub

        if(i<0||i>size)
            throw new OutOfBoundaryException("越界" );
        Object obj=elements[i];
        for(int j=i;j<size;j++)
        {
            elements[j]=elements[j+1];
        }
        elements[--size]=null;
        return obj;

    }

    @Override
    public boolean remove(Object e) {
        // TODO Auto-generated method stub
        int i=indexOf(e);
        if(i<0) return false;
        try {
            remove(i);
        } catch (OutOfBoundaryException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return true;
    }

    @Override
    public Object replace(int i, Object e) throws OutOfBoundaryException {
        // TODO Auto-generated method stub
        if(i<0||i>size)
            throw new OutOfBoundaryException("越界" );
        Object obj=elements[i];
        elements[i]=e;
        return obj;
    }

    @Override
    public Object get(int i) throws OutOfBoundaryException {
        // TODO Auto-generated method stub
        if(i<0||i>size)
            throw new OutOfBoundaryException("越界" );
        return elements[i];
    }

}


策略的实现:

/**
* @ClassName: IntergerStretegy
* @Description: TODO  整数的比较策略
* @author 萨摩耶
* @date 2018年4月30日 上午9:24:42
*
*/
public class IntergerStretegy implements Strategy{

    @Override
    public boolean equal(Object obj1, Object obj2) {
        // TODO Auto-generated method stub
        if(obj1 instanceof Integer&&obj2 instanceof Integer)
        {
            if(obj1==obj2)
                return true;
        }
        return false;
    }

    @Override
    public int compare(Object obj1, Object obj2) {
        // TODO Auto-generated method stub
        return 0;
    }

}


测试类:


public class Test {
    public static void main(String[] args) throws OutOfBoundaryException
    {
        ListArray la=new ListArray(new IntergerStretegy());
        for(int i=0;i<7;i++)
        la.insert(i, i+1);
        System.out.println(la.get(6));
        System.out.println(la.indexOf(5));
    }

}

原文地址:http://blog.51cto.com/12666319/2113786

时间: 2024-10-27 13:34:51

数据结构和算法分析之线性表的相关文章

数据结构与算法分析java——线性表

说到线性结构的话,我们可以根据其实现方式分为三类: 1)顺序结构的线性表 2)链式结构的线性表 3)栈和队列的线性表 1.顺序结构的线性表     所谓顺序存储,指的是两个元素在物理上的存储地址和逻辑上的存储地址是一致的,逻辑上相邻的两个元素,它们在物理中存储的地址 也是相邻的.对于jdk中典型的应用就是List接口的实现类ArrayList和Vector(它们两个的区别在于是否是线程同步的).

数据结构与算法分析java——线性表3 (LinkedList)

1. LinkedList简介 LinkedList 是一个继承于AbstractSequentialList的双向链表.它也可以被当作堆栈.队列或双端队列进行操作.LinkedList 实现 List 接口,能对它进行队列操作.LinkedList 实现 Deque 接口,即能将LinkedList当作双端队列使用.LinkedList 实现了Cloneable接口,即覆盖了函数clone(),能克隆.LinkedList 实现java.io.Serializable接口,这意味着Linked

javascript实现数据结构: 稀疏矩阵之三元组线性表表示

稀疏矩阵(Sparse Matrix):对于稀疏矩阵,目前还没有一个确切的定义.设矩阵A是一个n*m的矩阵中有s个非零元素,设  δ=s/(n*m),称δ为稀疏因子, 如果某一矩阵的稀疏因子δ满足δ≦0.05时称为稀疏矩阵, 稀疏矩阵的压缩存储 对于稀疏矩阵,采用压缩存储方法时,只存储非0元素.必须存储非0元素的行下标值.列下标值.元素值.因此,一个三元组(i, j, aij)唯一确定稀疏矩阵的一个非零元素. 上图的稀疏矩阵A的三元组线性表为: ( (1,2,12), (1,3,9), (3,1

C++数据结构与算法_2_线性表 --顺序表的应用示例

h2.western { font-family: "Liberation Sans",sans-serif; font-size: 16pt; }h2.cjk { font-family: "微软雅黑"; font-size: 16pt; }h2.ctl { font-family: "AR PL UMing CN"; font-size: 16pt; }h1 { margin-bottom: 0.21cm; }h1.western { fon

C++数据结构与算法_1_线性表 --顺序表的实现与分析

顺序表的实现与分析 引 --线性表的抽象基类: template <typename T> class LinearList { public: LinearList(); ~LinearList(); virtual int Size() const = 0; //返回线性表所能够存储的最大长度 virtual int Length() const = 0; //当前线性表的长度 virtual int Search(T &x) const = 0; virtual int Loca

2、蛤蟆的数据结构笔记之二线性表

2.蛤蟆的数据结构笔记之二线性表 到了笔记二了,每个笔记开头都应该弄个语句激励一下自己和小伙伴. "人生中最重要的不是位置,而是前进的方向" 这次咱们学习表,没错是表.什么表?额,汉字真是博大精深,没错,只是个表.不要想歪了. 欢迎转载,转载请标明出处: 1.  定义 线性表(亦作顺序表)是最基本.最简单.也是最常用的一种数据结构.线性表中数据元素之间的关系是一对一的关系,即除了第一个和最后一个数据元素之外,其它数据元素都是首尾相接的.线性表的逻辑结构简单,便于实现和操作.因此,线性表

数据结构(二)——线性表简介

数据结构(二)--线性表简介 一.线性表简介 1.线性表简介 线性表是具有相同类型的n个数据元素的有限序列A0,A1,A2,...,An-1.Ai是表项,n是表的长度. 2.线性表的表现形式 线性表的表现形式:A.零个或多个数据元素组成的集合B.数据元素在位置上是有序排列的C.数据元素的个数是有限的D.数据元素的类型必须相同 3.线性表的性质 线性表的性质:A.A0为线性表的第一个元素,只有一个后继B.An-1为线性表的最后一个元素,只有一个前驱C.除A0与An-1外的其它元素既有前驱又有后继D

数据结构与算法之线性表

前言 上一篇<数据结构和算法之时间复杂度和空间复杂度>中介绍了时间复杂度的概念和常见的时间复杂度,并分别举例子进行了一一说明.这一篇主要介绍线性表. 线性表属于数据结构中逻辑结构中的线性结构.回忆一下,数据结构分为物理结构和逻辑结构,逻辑结构分为线性结构.几何结构.树形结构和图形结构四大结构.其中,线性表就属于线性结构.剩余的三大逻辑结构今后会一一介绍. 线性表 基本概念 线性表(List):由零个或多个数据元素组成的有限序列. 注意: 1.线性表是一个序列. 2.0个元素构成的线性表是空表.

数据结构-王道2017-第2章 线性表

1. 线性表的定义和基本操作 1.1 线性表的定义 线性表电话i具有相同数据类型的n(n >= 0)个数据元素的有限序列.其中n为表长,当n=0时,该线性表是一个空表.若用L命名线性表,则一般表示为: L=(a1,a2,a3...ai,ai+1...an) 其中,a1是唯一的第一个数据元素,又称为表头元素:an是唯一的最后一个数据元素,又称为表尾元素.除第一个元素外,每个元素有且仅有一个直接前驱.除最后一个元素外,每个元素有且仅有一个直接后继.以上就是线性表的逻辑特性,这种线性有序的逻辑结构正是