数据结构-线性表(1)

最新推荐文章于 2024-11-04 23:39:13 发布

diaoyong7504

最新推荐文章于 2024-11-04 23:39:13 发布

阅读量60

点赞数

文章标签：数据结构与算法 java

原文链接：http://www.cnblogs.com/Onlywjy/p/6260304.html

版权

线性表

线性表的定义

线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列.
线性表是一种抽象数据类型；数组是一种具体的数据结构。线性表与数组的逻辑结构是不一样的，线性表是元素之间具有1对1的线性关系的数据元素的集合，而数组是一组数据元素到数组下标的一一映射。并且从物理性质来看，数组中相邻的元素是连续地存储在内存中的；线性表只是一个抽象的数学结构，并不具有具体的物理形式，线性表需要通过其它有具体物理形式的数据结构来实现。在线性表的具体实现中，表中相邻的元素不一定存储在连续的内存空间中，除非表是用数组来实现的。对于数组，可以利用其下标在一个操作内随机存取任意位置上的元素；对于线性表，只能根据当前元素找到其前驱或后继，因此要存取序号为i的元素，一般不能在一个操作内实现，除非表是用数组实现的。

线性表的顺序存储与实现

1.1List接口

package cn.wjy.list;

public interface List {

    /**
     * 返回线性表的大小，及数据元素的个数
     *
     * @return
     */
    public int getSize();

    /**
     * 判断线性表是否为空
     *
     * @return
     */
    public boolean isEmpty();

    /**
     * 判断线性表是否包含数据元素e
     *
     * @param e
     * @return
     */
    public boolean contains(Object e);

    /**
     * 返回数据元素e在线性表中的序号
     *
     * @param e
     * @return
     */
    public int indexOf(Object e);

    /**
     * 将数据元素e插入到线性表中i号位置
     *
     * @param i
     * @param e
     * @throws OutOfBoundaryException
     */
    public void insert(int i, Object e) throws OutOfBoundaryException;

    /**
     * 将数据元素e插入到元素obj之前
     *
     * @param obj
     * @param e
     * @return
     */
    public boolean insertBefore(Object obj, Object e);

    /**
     * 将数据元素e插入到元素obj之后
     *
     * @param obj
     * @param e
     * @return
     */
    public boolean insertAfter(Object obj, Object e);

    /**
     * 删除线性表中序号为i的元素,并返回之
     *
     * @param i
     * @return
     * @throws OutOfBoundaryException
     */
    public Object remove(int i) throws OutOfBoundaryException;

    /**
     * 删除线性表中第一个与e相同的元素
     *
     * @param e
     * @return
     */
    public boolean remove(Object e);

    /**
     * 替换线性表中序号为i的数据元素为e，返回原数据元素
     *
     * @param i
     * @param e
     * @return
     * @throws OutOfBoundaryException
     */
    public Object replace(int i, Object e) throws OutOfBoundaryException;

    /**
     * 返回线性表中序号为i的数据元素
     *
     * @param i
     * @return
     * @throws OutOfBoundaryException
     */
    public Object get(int i) throws OutOfBoundaryException;
}

1.2出现序号越界时抛出异常

public class OutOfBoundaryException extends RuntimeException {

    /**
     *
     */
    private static final long serialVersionUID = 1L;

    public OutOfBoundaryException(String err) {
        super(err);
    }

}

1.3 Strategy 接口

所有数据元素的类型都使用 Object 来替代，这样做是为了程序的通用性，即一种抽象数据类型的实现可以用于所有数据元素。但是这样做带来了另一个需要解决的问题，即完成数据元素之间比较大小或是否相等的问题。在使用 Object 类型的变量指代了所有数据类型之后，那么所有种类的数据元素的比较就都需要使用 Object 类型的变量来完成，但是不同数据元素的比较方法或策略是不一样的。例如字符串的比较是使用 java.lang.String 类的 compareTo 和 equals 方法；而基本的数值型数据是使用关系运算符来完成的；其他各种不同的类的比较方法就更加千差万别多种多样了，即使同一个类的比较方法在不同的情况下也会不同，例如两个学生之间的比较有时可以用学号的字典顺序来进行，有时可能又需要使用成绩来比较。因此我们无法简单的在两个 Object 类型的变量之间使用"= ="、"<"等关系运算符来完成各种不同数据元素之间的比较操作，同时 Java 也不提供运算符的重载.
使用 Strategy 接口可以实现各种不同数据元素相互之间独立的比较策略。在实现各种抽象数据类型时，例如线性表，可以使用 Strategy 接口变量来完成形式上的比较，然后在创建每个抽象数据类型的实例时，例如一个具体的用于学生的线性表时，可以引入一个实际实现了 Strategy 接口的策略类对象，例如实现了 Strategy 接口的学生比较策略类对象。使用这一策略的另一优点在于，一旦不想继续使用原先的比较策略对象，随时可以使用另一个比较策略对象将其替换，而不用修改抽象数据类型的具体实现。

package cn.wjy.list;
public interface Strategy {
    /**
     * 判断两个数据元素是否相等
     *
     * @param obj1
     * @param obj2
     * @return
     */
    public boolean equal(Object obj1, Object obj2);

    /**
     * 判断两个数据元素的大小 obj1>obj2 return -1; obj1=obj2 return 0; obj1<obj2 reurn 1
     *
     * @param obj1
     * @param obj2
     * @return
     */
    public int compare(Object obj1, Object obj2);

}


package cn.wjy.list;

public class DefaultStrategy implements Strategy {

    @Override
    public boolean equal(Object obj1, Object obj2) {
        return obj1.toString().equals(obj2.toString());
    }

    @Override
    public int compare(Object obj1, Object obj2) {
        int temp = obj1.toString().compareTo(obj2.toString());
        if (temp == 0) {
            return 0;
        } else if (temp > 0) {
            return 1;
        } else {
            return -1;
        }

    }

}


package cn.wjy.list;

public class StudentStrategy implements Strategy {

    @Override
    public boolean equal(Object obj1, Object obj2) {
        if (obj1 instanceof Student && obj2 instanceof Student) {
            Student s1 = (Student) obj1;
            Student s2 = (Student) obj2;
            return s1.getSId().equals(s2.getSId());
        } else {
            return false;
        }
    }

    @Override
    public int compare(Object obj1, Object obj2) {
        if (obj1 instanceof Student && obj2 instanceof Student) {
            Student s1 = (Student) obj1;
            Student s2 = (Student) obj2;
            return s1.getSId().compareTo(s2.getSId());
        } else {
            return obj1.toString().compareTo(obj2.toString());
        }
    }

}

2.线性表的数组实现

public class ListArray implements List {

    private final int LEN = 9;// 数组的默认大小
    private Strategy strategy; // 数据元素比较策略
    private int size;// 线性表中数据元素的个数
    private Object[] elements; // 数据元素数组

    public ListArray() {
        this(new DefaultStrategy());
    }

    public ListArray(Strategy strategy) {
        this.strategy = strategy;
        size = 0;
        elements = new Object[LEN];
    }

    @Override
    public int getSize() {
        return size;
    }

    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    @Override
    public boolean contains(Object e) {
            return indexOf(e) != -1;
    }

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

    /**
     * 扩充数组
     */
    private void expandSpace() {
        Object[] a = new Object[elements.length * 2];
        for (int i = 0; i < elements.length; i++)
            a[i] = elements[i];
        elements = a;
    }

    @Override
    public 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++;
        return;
    }

    @Override
    public boolean insertBefore(Object obj, Object e) {
        int i = indexOf(obj);
        if (i < 0)
            return false;
        insert(i, e);
        return true;
    }

    @Override
    public boolean insertAfter(Object obj, Object e) {
        int i = indexOf(obj);
        if (i < 0)
            return false;
        insert(i + 1, e);
        return true;
    }

    @Override
    public Object remove(int i) throws OutOfBoundaryException {
        if (i < 0 || i >= size)
            throw new OutOfBoundaryException("错误，指定的插入序号越界");
        Object obj = elements[i];
        for (int j = i; j < size - 1; j++)
            elements[j] = elements[j + 1];
        elements[--size] = null;
        return obj;
    }

    @Override
    public boolean remove(Object e) throws OutOfBoundaryException {
        int i = indexOf(e);
        if (i < 0)
            return false;
        remove(i);
        return true;
    }

    @Override
    public Object replace(int i, Object e) throws OutOfBoundaryException {
        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 {
        if (i < 0 || i >= size)
            throw new OutOfBoundaryException("错误，指定的序号越界");
        return elements[i];
    }

}

转载于:https://www.cnblogs.com/Onlywjy/p/6260304.html