线性表——顺序表

顺序表特点

1. 逻辑上相邻的数据元素，在物理存储位置上也相邻

2. 存储密度高，需预先分配 “足够应用” 的存储空间，这可能将会造成存储空间的浪费

3. 便于随机存取

4. 不便于插入和删除操作，会引起大量数据元素的移动

5. “静态” 线性表

---

顺序存储局限性

1. 若要为线性表扩充存储空间，则需重新创建一个地址连续的更大的存储空间，并把原有的数据元素都复制到新的存储空间中
2. 增删数据元素会引起平均约一半的数据元素的移动

---

第一次编写——照猫画虎

IList 接口

package com.qszl;

/**
 * @author Bourbon
 * @version 1.0
 */
public interface IList {
    public void clear();

    public boolean isEmpty();

    public int length();

    public Object get(int i);

    public void insert(int i, Object x);

    public void remove(int i);

    public int indexOf(Object x);

    public void display();
}

SqList 类

package com.qszl.SqList;

import com.qszl.IList;

/**
 * @author Bourbon
 * @version 1.0
 * 线性表——顺序表的实现
 */
public class SqList implements IList {
    private Object[] listElem;//线性表 “足够大” 的存储空间
    private int curLen;//线性表当前实际长度

    //初始化顺序表
    //构造一个存储空间容量为 maxSize 的线性表
    public SqList(int maxSize) {
        curLen = 0;//设置顺序表的当前长度为 0
        listElem = new Object[maxSize];//为顺序表分配 maxSize 个存储单元
    }


    @Override
    //清空已存在的线性表
    //将一个已存在的线性表设置成空表
    public void clear() {
        curLen = 0;
    }

    @Override
    //判断线性表中数据元素是否为空
    public boolean isEmpty() {
        return curLen == 0;
    }

    @Override
    //线性表实际长度
    //线性表中数据元素的个数
    public int length() {
        return curLen;
    }

    @Override
    //获取第 i 个数据元素，i 为数组索引
    public Object get(int i) {
        if (i < 0 || i > curLen - 1) {//i 超出搜索范围
            System.out.println("第" + i + "个元素不存在");
            return null;
        }
        return listElem[i];
    }

    @Override
    public void insert(int i, Object x) {
        if (curLen == listElem.length) {
            System.out.println("顺序表已满");
            return;
        }
        if (i < 0 || i > curLen) {
            System.out.println("插入位置不合法");
            return;
        }

        //(j-1)>=i，所以最后原本第 i 个数据元素也后移一位，空出第 i 位的空间
        for (int j = curLen; j > i; j--) {
            //插入位置及其之后所有数据元素后移一位
            listElem[j] = listElem[j - 1];
        }
        listElem[i] = x;//插入数据
        curLen++;//表实际长度变化
    }

    @Override
    public void remove(int i) {
        if (i < 0 || i > curLen - 1) {//i 不合法
            System.out.println("删除位置不合法");
            return;
        }

        //第 i 位数据元素 被 第 (i+1) 位数据元素覆盖
        for (int j = i; j < curLen - 1; j++) {
            //被删除元素之后的所有数据元素左移一个存储位置
            listElem[j] = listElem[j + 1];
        }
        curLen--;//表实际长度变化
    }

    @Override
    //书本上写得真不怎么样，真就是一步一步
    //判断一次不就行了嘛，还判断了 3 次，逻辑上是肯定对的
    //public int indexOf(Object x) {
    //    int j=0;
    //    while(j<curLen&&!listElem[j].equals(x))
    //        j++;
    //    if(j<curLen)
    //        return j;
    //    else
    //        return -1;
    //}
    public int indexOf(Object x) {
        for (int i = 0; i < curLen; i++) {
            if (x.equals(listElem[i])) {
                return i;
            }
        }
        return -1;
    }

    @Override
    //输出线性表中的数据元素
    public void display() {
        for (int i = 0; i < curLen; i++) {
            System.out.println(listElem[i] + " ");
        }
        System.out.println();
    }
}

总体来讲，不算难，就是书本上写得有些晦涩，不太明白为什么一定要写成这个样子，可读性强的表现不该是只要有点底子就该看得懂吗？！

---

 第二次编写——编译成功

SqList 类

package com.qszl.SqList;

import com.qszl.IList;

/**
 * @author Bourbon
 * @version 2.0
 * 线性表——顺序表的实现
 */
public class SqList implements IList {
    private Object listElem[];
    private int curLen;

    public SqList(int maxSize) {
        curLen = 0;
        listElem = new Object[maxSize];
    }

    @Override
    public void clear() {
        curLen = 0;
    }

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

    @Override
    public int length() {
        return curLen;
    }

    @Override
    public Object get(int i) {
        if (i < 0 || i > curLen - 1) {
            System.out.println("第" + i + "数据元素不存在");
            return null;
        }
        return listElem[i];
    }

    @Override
    //插入操作是从后往前逐个移动
    public void insert(int i, Object x) {
        if (curLen == listElem.length) {
            System.out.println("顺序表已满");
            return;
        }
        if (i < 0 || i > curLen) {
            System.out.println("插入位置不合法");
            return;
        }
        for (int j = curLen; j > i; j--) {
            listElem[j] = listElem[j - 1];
        }
        listElem[i] = x;
        curLen++;
    }

    @Override
    //删除操作是从前往后逐个移动
    public void remove(int i) {
        if (i < 0 || i > curLen - 1) {
            System.out.println("第" + i + "个数据元素不存在");
            return;
        }
        for (int j = i; j < curLen - 1; j++) {
            listElem[j] = listElem[j + 1];
        }
        curLen--;
    }

    @Override
    public int indexOf(Object x) {
        for (int i = 0; i < curLen; i++) {
            if (x.equals(listElem[i])) {
                return i;
            }
        }
        System.out.println("未找到该数据元素");
        return -1;
    }

    @Override
    public void display() {
        for (int i = 0; i < curLen; i++) {
            System.out.println(listElem[i] + " ");
        }
        System.out.println();
    }
}

没什么好改动的，也就是有些注意点罢了

1. 插入和删除前，其它数据元素的移动方向，即，从左边开始移动还是从右边开始移动
2. 在插入前，需要先判断顺序表是否已满
3. 插入和删除后，需要将顺序表长度相应增加和减小

原本还想用 Python语言再写一遍的，但因为相较之下，还是 Java语言用得顺很多，所以从 Java强调类型的角度去看 Python，Python真是个 “任性” 的语言。。。

之后再试一试吧，虽然看 Python的写法，还是很不舒服。。。