数据结构-----顺序表的实现

数据结构：

　　数据按逻辑结构分类有：

　　　　线性结构（队列，栈，串）：有且仅有一个开始结点和一个终端结点，并且所有结点都最多只有一个直接前趋和一个直接后继

　　　　非线性结构：一个结点可能有多个直接前趋和直接后继，如树，图，广义表

　　数据的四种基本存储方法：

　　　　（1）顺序存储方法：该方法把逻辑上相邻的结点存储在物理位置上相邻的存储单元里，结点间的逻辑关系由存储单元的邻接关系来体现。（多用数组表示）

　　　　（2）链接存储方法：该方法不要求逻辑上相邻的结点在物理位置上亦相邻，结点间的逻辑关系由附加的指针字段表示。

　　　　（3）索引存储方法：该方法通常在储存结点信息的同时，还建立附加的索引表。分稠密索引和稀疏索引

　　　　（4）散列存储方法：该方法的基本思想是：根据结点的关键字直接计算出该结点的存储地址。

　　　线性结构之顺序结构：

　　　　插入和删除操作：平均要移动一半元素，时间复杂度为O（n），其中插入移动位置为n/2；而删除移动次数为（n-1）/2

　　　　　　①有且仅有一个开始结点a₁，没有直接前趋，有且仅有一个直接后继a₂；　　
　　　　　　②有且仅有一个终结结点a_n，没有直接后继，有且仅有一个直接前趋a_n-1；
　　　　　　③其余的内部结点a_i（2≤i≤n-1）都有且仅有一个直接前趋a_i-1和一个a_i+1。

　　　　　顺序表的基本功能有：1，InitList（L）2，ListLength（L）3，GetNode（L，i） 4，LocateNode（L，x）；

　　　　　　　　　　　　　　　5，InsertList（L，x，i）；6，DeleteList（L，i）（其实在Java中ArrayList已经实现，下面是我实现的简单的例子O(∩_∩)O）

Java（java8）代码实现如下：

package dataStructByJava;
/*
 * @author zjL
 * @顺序表实现
 * 实现功能：1，InitList（L）2，ListLength（L）3，GetNode（L，i）
 * 4，LocateNode（L，x）；5，InsertList（L，x，i）；6，DeleteList（L，i）
 */
import java.util.Arrays;
public class SeqList<T> {
    //声明默认容量
    private final int Default_Size=32;
    //声明全局顺序表
    private Object[] MySeq;
    //声明顺序表中元素的个数
    private int size;
    //声明容量大小，用于动态扩展容量，即顺序表的初始长度
    private int capacity;
    //InitList(L)
    public SeqList(){
        capacity=Default_Size;
        MySeq=new Object[capacity];
    }
    //指定长度初始化
    public SeqList(int initSize){
        capacity=1;while(capacity<initSize)
            capacity<<=1;
        MySeq=new Object[capacity];
    }
    //初始化顺序表
    public void setValue(T element,int index){
        if(index<0||index>size-1)
            throw new IndexOutOfBoundsException("IndexOutOfYourSeqList");
        MySeq[index]=element;
    }
    //ListLength(L);
    public int length(){
        return size;
    }
    //GetNode（L，i）
    public T getNod(int index){
        if(index<0||index>size-1)
            throw new IndexOutOfBoundsException("IndexOutOfYourSeqList");
        return (T)MySeq[index];
    }
    //LocateNode（L，x）
    public int getIndex(T element){
        for(int i=0;i<size;++i)
            if(MySeq[i]==element)
                return i;
        return -1;
    }
    //InsertList（L，x，i）
    public void insertMySeq(T element,int index){
        if(index<0||index>size)//为size是为了能插入到最后一位空白位，而非size-1位
            throw new IndexOutOfBoundsException("IndexOutOfYourSeq");
        ensureCapacity(size+1);
        for(int i=size;i>index;--i)
            MySeq[i]=MySeq[i-1];
        MySeq[index]=element;
        size++;
    }
    private void ensureCapacity(int minCapacity) {
        // TODO Auto-generated method stub
        if(minCapacity>capacity)
            capacity>>=1;
        MySeq=Arrays.copyOf(MySeq,capacity);
    }
    public void add(T element){
        insertMySeq(element,size);
    }
    //DeleteList（L，i）
    public void DeleteMySeq(int index){
        if(index<0||index>size-1)
            throw new IndexOutOfBoundsException("IndexOutOfYourSeq");
        for(int i=index;i<size;++i)
            MySeq[i]=MySeq[i+1];
        MySeq[size-1]=null;//便于GC回收
        size--;
    }
    public String toString(){
        if(size==0)
            return "[]";
        else{
            StringBuilder str=new StringBuilder("[");
            for(int i=0;i<size;++i)
                str.append(MySeq[i].toString()+", ");//逗号加空格
            int len=str.length();
            return str.delete(len-2,len).append("]").toString();
        }
    }
}

测试用例：

public class TestDemo {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        SeqList<Integer> seq=new SeqList<Integer>(6);//调用T泛的方法
        int leng=seq.length();
        for(int i=0;i<leng;i++)//初始化数组元素
            seq.setValue(i+1, i);
        System.out.println(seq.toString());
        //输出[1, 2, 3, 4, 5, 6]
        seq.add(9);//添加
        System.out.println(seq.toString());
        //输出[1, 2, 3, 4, 5, 6, 9]
        seq.DeleteMySeq(3);//删除
        System.out.println(seq.toString());
        //输出[1, 2, 3, 5, 6, 9]
    }