java 实现线性表

线性表（linear list）是我写的第一个数据结构，又叫表，顾名思义，线性的数据结构。（元素之间一对一，除头尾外，每个元素有一个前驱，有一个后继），可以随便插入值，随便删除值。好了，下面我们来实现它。

基于顺序存储结构的线性表—顺序表

java怎么实现顺序存储结构？很简单，直接用数组。但表的下标从1开始，而数组下标从0开始，故我们写的时候，要注意一下细节。

public class SeqList {
    private int length;// 顺序表的长度
    private Object[] list;// 表
    private int size;// 表的大小

    /**
     * 创建线性表
     * 
     * @param szie
     *            指定表的大小
     * 
     */
    public void init(int mSize) {
        length = 0;
        this.size = mSize;
        list = new Object[size];
    }

    /**
     * 销毁线性表
     */
    public void destory() {
        for (int i = 0; i < length; i++) {
            list[i] = null;
        }
        length = 0;
    }

    /**
     * 得到线性表的长度
     * 
     * @return 表的长度
     */
    public int getLength() {
        return length;
    }

    /**
     * 按位置查找
     * 
     * @param index 位置
     *            
     * @return 所查找位置的元素
     */
    public Object locale(int index) {
        if ((index < 1) || (index > length)) {
            System.out.println("输入位置有误!");
            return null;
        }
        return list[index - 1];
    }

    /**
     * 插入一个元素，这里默认插在表的最后，大家可以自行写根据指定位置插入
     * 
     * @param element  要插入数据
     *            
     */
    public void insert(Object element) {
        if (isFull()) {
            System.out.println("表已满，无法插入");
        } else {
            list[length] = element;
            length++;
        }
    }

    /**
     * 删除指定位置的元素
     * 
     * @param index 要删除的位置
     *            
     * 
     */
    public void delete(int index) {
        if ((index < 1) || (index > length)) {
            System.out.println("输入位置有误!");
            return;
        }
        if (isEmpty()) {
            System.out.println("表已为空，无法删除");
        } else {
            for (int i = index - 1; i < length - 1; i++) {// 数组下标比表的下标少1
                list[i] = list[i + 1];
            }
            length--;
        }

    }

    /**
     * 判空
     * 
     * @return 判空结果
     */
    public boolean isEmpty() {
        if (length == 0)
            return true;
        return false;
    }

    /**
     * 判满
     * 
     * @return 判满结果
     */
    public boolean isFull() {
        if (length == size)
            return true;
        return false;
    }

    /**
     * 遍历链表
     */
    public void print() {
        if (isEmpty()) {
            System.out.println("表为空");
            return;
        }
        for (int i = 0; i < length; i++) {
            System.out.print(list[i] + " ");
        }
        System.out.println("");// 占一行
    }
}

//使用该表

//java入口
public class Main {
    public static void main(String[] args) {
        SeqList list = new SeqList();
        list.init(100);// 初始化一个能够存放100对象的顺序表
        list.insert(1);// 添加元素
        list.insert(2);// 添加元素
        list.insert("hello");// 添加元素
        list.insert("world");// 添加元素
        list.print();
        System.out.println("2号位的元素为:"+list.locale(2));//查找2号位的元素
        System.out.println("顺序表的长度为:" + list.getLength());// 打印长度
        list.delete(2);// 删除2号为的元素
        list.print();
        System.out.println("顺序表的长度为:" + list.getLength());// 打印长度
        list.destory();// 销毁
        list.print();
        list.delete(1);// 销毁后再删元素
    }
}

运行结果

基于链式存储结构的线性表—链表

java的强大之处就在于拥有大量的封装好的类库供大家使用，当然一些数据结构上的东西也是如此，java本身就提供了线性表的数据结构，如顺序表就是ArrayList，链表就使用LinkedList。其优点如下：

1. 可以指定泛型
2. 能动态的改变表的长度
3. 支持增强for循环与Iterator，遍历十分方便

既然这样，我们就直接使用就是了，岂不是美滋滋！

import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;

public class LinkList {
    public static void main(String[] args) {
        // 不使用泛型
        List list = new LinkedList();
        list.add("aaa");
        list.add("bbb");
        list.add(3);
        list.add(4);
        for (Object obj : list) {
            System.out.print(obj + " ");
        }
        list.remove("bbb");
        System.out.println("");
        for (Object obj : list) {
            System.out.print(obj + " ");
        }
        // 使用泛型
        System.out.println("\n使用泛型：");
        List<String> list2 = new LinkedList<String>();
        list2.add("aaa");
        list2.add("bbb");
        list2.add("ccc");
        Iterator<String> iter = list2.iterator();
        while (iter.hasNext()) {
            System.out.print(iter.next()+" ");
        }
        list2.removeAll(list2);
        if(!iter.hasNext()){
            System.out.println("\nlist2已经为空");
        }
    }
}

运行结果

同样，java也提供了顺序表ArrayList，这个大家可以自行练习。

对于线性表的实现到此结束，建议大家以后使用java的时候，就直接使用jdk提供的LinkedList与ArrayList，特别是链表，java不像C++那样有指针可用，故以后用到链表这个数据结构的时候，我都将采用java自己提供的LinkedList来进行，十分的方便。

顺序表与链表使用时如何抉择

笔者总结如下：

1. 如果需要大量的add与remove,建议使用LinkedList，因为ArrayList需要移动数据。
2. 如果需要大量的随机访问，建议ArrayLst，因为LinkedList需要移动指针。

好了，这一篇就结束了，下一篇将会大家带来栈的数据结构，敬请期待！