线性表与顺序表

线性表
线性表是n个具有相同属性的有限数列，常见的线性表有：顺序表，链表，栈，队列，字符串…

线性表在逻辑上是线性结构，也就是说连成一条直线，但是在物理结构上不一定连续，线性表在物理上存储是，通常以数组和链式结构的形式进行存储。

值得注意的是：

1. 线性表示一个序列
2. 0个元素构成的线性表是空表
3. 线性表的第一个元素无前驱，最后一个元素无后继，其他元素只有一个前驱和后继
4. 线性表是有长度的，其长度就是元素个数，且其元素个数是有限的，也是就说线性表的长都是有限的。

顺序表
顺序表是用一段物理地址连续的存储数据元素的线性结构，一般情况下采用数组，在数组上完成数据的增删改查。

顺序表一般可以分文

• 静态顺序表：使用定长数组存储。
• 动态顺序表：使用动态开辟的数组存储。

杂记：
原码：原码的最高位是符号位，0代表正数，1代表负数，非符号位为该数字的绝对值二进制
反码：正数的反码与原码一致，负数的反码是最高位（符号位）不变，非符号位按位取反
补码：正数的补码与原码一致，负数的补码是反码+1

顺序表的Java实现：
我用类SeqList来定义顺序表
顺序表的底层是由数组来实现的，因此类的成员变量要有一个未初始化的数组，该数组在实例化时被构造方法初始化为默认长度的一个数组
还需要定义一个变量 usedSize 来记录当前数组存入元素的个数，另外默认长度设置为 DEFULT_SIZE = 10；

在此基础上，实现顺序表的增删改查操作。

构建顺序表：

public class SeqList {
	private int[] elem;
	//数组已用个数
	private int usedSize;
	//默认长度
	private static int DEFULT_SIZE = 10;
	//构造方法
	public SeqList() {
		this.elem = new int[DEFULT_SIZE];
		this.usedSize = 0;
	}
}

下面实现顺序表的一些操作

import java.util.Arrays;

public class SeqList {
    private int[] elem;
    private int usedSize;
    private static int DEFULT_SIZE = 10;
    public SeqList() {
        this.elem = new int[DEFULT_SIZE];
        this.usedSize = 0;
    }
    //扩容
    private void grow(){
        this.elem =Arrays.copyOf(this.elem,this.elem.length*2);
    }
    //打印顺序表
    public void display() {
        for(int i = 0; i < this.usedSize ; i++) {
            System.out.println(this.elem[i]);
        }
        System.out.println();
    }
    //判断顺序表是否已满
    private void isFull() {
        if(this.usedSize == this.elem.length){
            //此处进行扩容处理；
            grow();
            //或者可以直接不进行扩容：
            //throw new ArrayIndexOutOfBoundsException("该顺序表已满！");
        }
    }
    //判断是否为空
    private void isEmpty() {
        if(this.usedSize == 0) {
            throw new ArrayIndexOutOfBoundsException("该数组为空");
        }
    }
    //检查pos位置是否合法
    private void checkPos(int pos) {
        // 此判断条件只适合在 pos位置插入元素使用，因为pos可以等于usedSize,此时插入元素时相当于进行尾插
        //而检查某位置是谁时，pos就不能等于usedSize，条件应该为 if(pos <0 || pos>= this,usedSize);
        //这里个人为了体现方法的调用就不再改变条件。
        if(pos<0 || pos > this.usedSize) {
            throw new ArrayIndexOutOfBoundsException("位置不正确！");
        }
    }
    //在pos位置新增元素
    public void add (int pos,int data) {
        //检查顺序表是否已满，满了则扩容
        isFull();
        //检查pos位置合法性
        checkPos(pos);
        for(int i = this.usedSize -1 ; i >= pos; i--) {
            this.elem[i+1] = this.elem[i];
        }
        this.elem[pos] = data;
        this.usedSize++;
    }
    //查看是否包含某个元素
    public boolean contains(int toFind){
        isEmpty();
        for(int i = 0 ;i < this.usedSize; i++) {
            if(this.elem[i] == toFind) {
                return true;
            }
        }
        return false;
    }
    //查看某个元素对应的位置
    public int search(int toFind) {
        isEmpty();
        for(int i = 0 ;i < this.usedSize; i++) {
            if(this.elem[i] == toFind) {
                return i;
            }
        }
        return-1;
    }
    //获取pos位置的元素
    public int getPos(int pos) {
        isEmpty();
        checkPos(pos);
        return this.elem[pos];
    }
    //删除第一次出现的元素
    public void remove (int key) {
        int index = search(key);
        for(int i = index; i < this.usedSize-1; i++){
            this.elem[i] = this.elem[i+1];
        }
        this.usedSize--;
    }
    //获取长度
    public int size() {
        return this.usedSize;
    }
    //清空顺序表
    public void clear() {
        this.usedSize = 0;
    }
}

因为顺序表容易理解，所以这次笔记没有过多注解，直接刷题