数据结构-线性表-顺序表的代码详解

数据结构中的一大重点   线性表：

一。顺序表  
   数据存储是连续的，有多少数据开辟多少储存空间，所以不存在资源浪费  

   查找速度快，但是在增删数据的时候可能会移动大量数据，所以增删操作速度慢

二。链表
   数据存储是离散的，所以数据的存储不连续，无规则，可能存在空间大于数据数目，浪费资源  

   但是增加跟删除元素的时候不影响其他元素，速度快

   根据划分条件不同：

   链表结构可分为单向链表，双向链表   循环链表 非循环链表

三。这篇文章详解顺序表！！！！！！代码在最后附上！！！！

 1.代码部分 一包    一接口二类  在学习过程中可以对着左侧行序号更改代码

      

 2.接口类List

3.顺序表类SequenceList

3.测试类

4.运行结果

5.代码部分附上：

List类：

package LinearList;

//定义一个线性表接口
public interface List {
    //定义线性表的长度
    public int Size();
    //判断线性表是否为空
    public boolean IsEmpty();
    //插入元素
    public void Insert(int index,Object object) throws Exception;
    //删除元素
    public void Delete(int index) throws Exception;
    //查找元素
    public Object FindData(int index) throws Exception;
}
 

SequenceList类

package LinearList;

public class SequenceList implements LinearList.List{
    
    
    //设置顺序表默认的最大长度
    final int DefaultSize = 20;
    //设置顺序表的最大长度
    int Maxsize;
    //设置顺序表的当前长度
    int size;
    //存储对象的数组(因为不知道存储的是哪种类型的数据，所以选择object)
    Object OjbArr[];
    
    //初始化顺序表
    public void Init(int size) {
        //设置顺序表长度
        Maxsize = size;
        //设置完之后将顺序表当前的长度size设置为0，因为还未输入数据
        this.size = 0;
        //根据长度实例化对象数组数目
        OjbArr = new Object[size];    
    }
    
    //构造函数，默认最大长度下的构造函数和用户输入最大长度下的构造函数
    //构造函数中创建该表
    public SequenceList() {
        // TODO Auto-generated constructor stub
        Init(DefaultSize);
    }
    public SequenceList(int size) {
        Init(size);
    }
    

    @Override
    //返回顺序表的长度
    public int Size() {
        // TODO Auto-generated method stub
        return size;
    }

    @Override
    //返回对顺序表的判断是否为空
    public boolean IsEmpty() {
        // TODO Auto-generated method stub
        //通过判断当前顺序表的size是否为0   以此判断该顺序表是否为空
        return size == 0;
    }

    @Override
    public void Insert(int index, Object object) throws Exception {
        // TODO Auto-generated method stub
        //判断该表是否已经存满
        if(size>=Maxsize) {
            throw new Exception("该表已经存满");
        }
        //判断插入数据的位置是否合法
        if(index<size||index>Maxsize) {
            throw new Exception("插入位置不合法");
        }
        
        //若上述进程没有被打断，则证明该插入操作是没问题的,继续正常进行
        
        //当前长度++
        size++;    
        //移动元素让出位置使该元素插入
        //移动的原理是将所插位置元素以后的元素全部后移，让出这个位置给新来元素
        for(int j=size;j>=index;j--) {
            OjbArr[size+1] = OjbArr[size];
        }
        //元素加入index位置
        OjbArr[index] = object;    
    }

    @Override
    public void Delete(int index) throws Exception {
        // TODO Auto-generated method stub
        //判断顺序表是否为空，为空没法进行删除操作
        if(IsEmpty()) {
            throw new Exception("该顺序表为空");
        }
        //判断是否有该位置
        if(index<0||index>size) {
            throw new Exception("没有该位置");
        }
        //元素前移顶掉index处的元素
        for(int j=index;j<=size-1;j++){
            OjbArr[j]=OjbArr[j+1];
        }
        //顺序表长度--
        size--;
        
        
    }

    @Override
    public Object FindData(int index) throws Exception {
        // TODO Auto-generated method stub
        //判断顺序表是否为空，为空没法进行查找操作
        if(IsEmpty()) {
            throw new Exception("该顺序表为空");
        }
        //判断是否有该位置
        if(index<0||index>size) {
            throw new Exception("没有该位置");
        }
        
        return OjbArr[index];
    }
        
}
 

 

测试类Test

package LinearList;

public class Test {
    
   public static void main(String args[]) {
       //创建一个顺序表对象
       SequenceList list = new SequenceList(20);
       //为顺序表插入数据
       try {
           //增加
        list.Insert(0, 11);
        list.Insert(1, 22);
        list.Insert(2, 33);
        list.Insert(3, 44);
        
        //删除
        list.Delete(1);
        
        //查找
        for(int i=0;i<list.Size();i++) {
            System.out.println("第"+i+"个元素为"+list.FindData(i));
        }
    
        
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
   }
}