数据结构第一篇——手把手教你顺序表

本篇文章主要讲了对顺序表的基本操作。

1 java数据结构中第一种结构就是：线性表。那么什么是线性表？

线性表：是n个具有相同特性的元素的有限序列。在逻辑结构上连续，但是在物理结构上不一定连续的数据结构，常见的

有：顺序表、链表、栈、队列等。

2 顺序表：逻辑结构连续，物理结构也连续的有限序列。本质上就是通过数组和有效个数组成，有效个数控制顺序表的长度。可能在这里你会给我杠，嘿！杠就对了，顺序表和数组的不同就在于可以控制顺序表的长度。比如：对于数组来说，要打印，则会打印整个数组，但是对于顺序表来说，可以实现一个“动态”的数组。

3 顺序表的基本操作：

 废话不多说，咱们直接上代码来解释。

（1）建立一个顺序表：核心就是定义一个数组，然后定义有效长度。

public class myArray3 {
 public int[] elem;
    public int usedSize = 0;
    public static final int constant = 3;

    public myArray3() {
        this.elem = new int[constant];
    }
}

（2）判断顺序表是否为满：其实满当就是等于数组本身的长度，但是顺序表的长度是usedSize,当

顺序表的长度等于数组的长度时，就表示满了。然后注意，数组.length，字符串.length(),就巧记：字符串是有引号的，这各括号也自然多出来是字符串的。

 public boolean isFull() {
        return usedSize == elem.length;
    }

（3）判断顺序表是否为空：为空，就是顺序表长度为0，而顺序表为0即是长度为0。

 public boolean isEmpty() {
        return usedSize == 0;
    }

（4）判断位置的合法性，对于顺序表来说，下标是：[0,usedSize-1],但是有时候像插入元素到顺序表中，usedSize是可取的，因此，不合法的就是：pose<0或者pose>usedSize;至于usedSize我们分开来说即可。

 public int isIndex(int pose) {
        if (pose < 0 || pose > usedSize) {
            return -1;
        }
        if (pose == usedSize) {
            return 0;
        }
        return 1;
    }

（5）添加元素e到pose位置，小编认为插入元素是最难理清逻辑，也是很容易错的。但是咱们可以想想：Java中顺序表是可以扩容的，因此我们不会因为空间问题而不插入元素的，因此先判断直接扩容，然后对下标进行划分。在这个地方插入Usedsize和中间位置是吧不一样的额，因此我们单独讨论即可，对于插入中间位置，index之后的元素是需要向后面挪动的，时间复杂度为O(n).

 public void Add(int pose, int e) {
        if (isFull() == true) {
            //满了就需要扩容
            this.elem = Arrays.copyOf(elem, elem.length + constant);
            System.out.println("扩容成功了");
            System.out.println(this.elem.length);
        }

        if (isIndex(pose) == 0) {
            this.elem[usedSize] = e;
            usedSize++;
            return;
        }
        if (isIndex(pose) == 1) {
            for (int i = usedSize - 1; i >= pose; i--) {
                elem[i + 1] = elem[i];
            }
            elem[pose] = e;
            usedSize++;
            return;
        }
        if (isIndex(pose) == -1) {
            throw new RuntimeException("下标有问题");
        }
    }

(6)删除pose下标的元素：对于添加元素，要判断顺序表是否为满，满了就需要扩容；对于删除元素，需要判断顺序表是否为空，为空的话就不能删除。然后分情况，pose在中间，pose在usedSize位置以及下标有问题

  public void remove(int pose) {
        if(isEmpty() == true) {
            throw new RuntimeException("顺序表为空，不能删除");
        } else {
            if (isIndex(pose) == -1) {
                throw new RuntimeException("下标有问题");
            }
            if (isIndex(pose) == 0) {
                usedSize--;
                return;
            }
            if (isIndex(pose) == 1) {
                for (int i = pose; i < usedSize - 1; i++) {
                    this.elem[i] = this.elem[i + 1];
                }
                usedSize--;
                return;
            }
        }
    }

 （7）打印顺序表：这个比较简单，只需要注意是usedSize，而不是数组的长度

 public void print() {
        for (int i = 0; i < usedSize; i++) {
            System.out.println(this.elem[i]);
        }
    }

（8）判断是否包含某个元素，直接遍历判断即可

 public int isContain(int e) {
        for (int i = 0; i < usedSize; i++) {
            if (this.elem[i] == e) {
                return i;
            }
        }return -1;
    }

（9）删除遇到的第一个元素e，无不就是遍历找该元素，找到了就把后面的元素移动前进一位。

 public void remove1(int e){
        int a=isContain(e);
        if (a!=-1){
            for(int i=a;i<usedSize-1;i++){
                System.out.println("e元素的下标是: " + a);
                this.elem[i]=this.elem[i+1];
                usedSize--;
            }

            }
        else{
            System.out.println("e元素不存在");
        }

    }

（10）得到pose位置的元素：首先必须判断下标是否合理，然后获取元素即可

 public int getElem(int pose){
        if(isIndex(pose)==0||isIndex(pose)==1){
             return elem[pose];
        }
        else{
            return -1;
        }
    }

(11)设置pose位置的元素为e:首先得判断下标是否合理，其次合理然后改就行

 public void setIndex(int pose,int e){
        if(isIndex(pose)==0||isIndex(pose)==1){
            this.elem[pose]=e;

        }
        else{
            return ;
        }
    }

(12)清空顺序表，直接把长度置为0即可，不像链表需要Null.

public void clear(){
        usedSize=0;
    }

最后，顺序表的基本操作就结束了，对于顺序表后面用的不多，但是得把里面的逻辑理清，容易忽略的点考虑到，逻辑需要严谨。这篇文章可以作为以后的复习，那就关注起来更方便。