线性表的顺序存储之java实现

线性表有两种存储结构：顺序存储结构和链式存储结构。用顺序存储结构实现的线性表称为顺序表，用链式存储结构实现的线性表是链式表。

顺序表是用一组连续的存储单元顺序存放线性表的数据元素，数据元素在内存的物理存储次序与他们在线性表中的逻辑次序是一致的，即数据元素a_i与其前驱a_i-1以及后继元素a_i+1的位置相邻。

在高级程序设计语言中，我们使用数组来存储顺序表，因为数组在物理结构上属于一组连续存储单元。

package com.zbt.seqlList;

public class SeqLinearList {

    /**
     * 顺序表的java实现
     * 
     * @param args
     */

    private static int table[];// 使用一位数组来存储
    private static int n; // 记载顺序表长度

    public static void main(String[] args) {
        SeqLinearList sl = new SeqLinearList(10);
        // // System.out.println(table.length);
        // // System.out.println(sl.isEmpty());
        sl.setElement(1, 5);
        sl.setElement(2, 4);
        sl.setElement(3, 3);
        sl.setElement(4, 2);
        sl.setElement(5, 1);
        sl.setElement(6, 1);
        sl.printElement();
        sl.setElement(6, 10);
        sl.printElement();
        // sl.insertElement(7, 11);
        // sl.printElement();
        // sl.deleElement(7);
        // sl.printElement();
        // sl.deleElement(1);
        // sl.printElement();
        // System.out.println(sl.findElement(5));
        sl.deleElement(1);
        sl.printElement();
    }

    /**
     * 顺序表的初始化 为顺序表分配n个存储单元；顺序表初始长度为0；
     * 
     * @param n
     */
    public SeqLinearList(int n) {
        table = new int[n];
        this.n = 0;
    }

    /**
     * 判断顺序表是否为空
     * 
     * @return
     */
    public boolean isEmpty() {
        return n == 0;
    }

    /**
     * 判断顺序表是否为满
     * 
     * @return
     */
    public boolean isFull() {
        return n >= table.length;
    }

    /**
     * 获取顺序表长度
     * 
     * @return
     */
    public int getLength() {
        return n;
    }

    /**
     * 获得顺序表的第i个元素
     * 
     * @param i
     * @return
     */
    public int getElement(int i) {
        if (i > 0 && i <= n)
            return table[i - 1];
        else
            return -1;
    }

    /**
     * 设置顺序表第i位置元素值
     * 
     * @param i
     */
    public void setElement(int i, int k) {
        try {
            if (i > 0 && i <= (n + 1)) {
                table[i - 1] = k;
                if (i == n + 1)
                    n++;
            }
        } catch (Exception e) {
            System.out.println("您设置的第" + i + "个元素数组越界");
        }
        // else
        // System.out.println("第" + i + "个元素数组越界");
    }

    /**
     * 打印顺序表
     */
    public void printElement() {
        for (int i = 0; i < n; i++) {
            System.out.print(table[i] + " ");
        }
        System.out.println("
");
    }

    /**
     * 查找元素
     * 
     * @param k
     * @return
     */
    public boolean findElement(int k) {
        boolean flag = false;
        for (int i = 0; i < n; i++) {
            if (table[i] == k)
                flag = true;
        }
        return flag;
    }

    /**
     * 在第i个位置插入元素k
     * 
     * @param i
     * @param k
     */
    public void insertElement(int i, int k) {
        if (!isFull()) {
            if (i <= 0)
                i = 1;
            if (i > n)
                i = n + 1;
            for (int j = n; j > i - 1; j--) {
                table[j] = table[j - 1];
            }
            table[i - 1] = k;
            n++;
        } else
            System.out.println("数组已满，无法插入K值");
    }

    /**
     * 删除第i位置元素
     */
    public void deleElement(int i) {
        if (!isEmpty()) {

            if (i <= 0 || i > n) {
                System.out.println("输入不合法");
                return;
            }

            for (int j = i - 1; j < n; j++) {
                table[j] = table[j + 1];
            }
            n--;

        } else
            System.out.println("顺序表为空");
    }
}