JAVA之顺序表

顺序表

顺序表是按照顺序存储方式存储的线性表，该线性表的节点按照逻辑次序依次存放在计算机的一组连续的存储单位中，所以只要知道了一个顺序表的首地址一席每个数据元素所占用的存储长度，就可以很容易计算出任何一个数据元素（数据结点）的位置

接下来贴具体代码看实现

package List;

import java.util.Scanner;

/**
 * 顺序表
 *@author Mr.weng
 *@version 1.0
 */
class DATA{
    String key;//节点关键字，这里以学号为例
    String name;
    int age;
    @Override
    public String toString() {
        // TODO Auto-generated method stub
        StringBuilder str = new StringBuilder();
        str.append("关键字："+key);
        str.append("\n名字:"+name);
        str.append("\n年龄:"+age);
        return str.toString();
    }
}
//定义顺序表结构
class SLType{
    private static final int MAXLEN = 100;
    DATA[] listData = new DATA[MAXLEN];
    int Listlen;
    /***************初始化空表**************************/
    void init(SLType SL){
        SL.Listlen = 0;
    }
    /****************得到表长**************************/
    int SLength(SLType SL){
        return SL.Listlen;
    }
    /*****************插入节点**************************/
    //第一次添加空表 或者添加表尾
    int SLAdd(SLType SL,DATA data){
        if(SL.Listlen >= MAXLEN){
            System.out.println("表已满");
            return 0;
        }
        SL.listData[SL.Listlen++] = data;
        return 1;
    }
    int SLInsert(SLType SL,int n,DATA data){
        int i;
        if(SL.Listlen >= MAXLEN){
            System.out.println("顺序表已满，不能插入节点");
            return 0;
        }
        //判断位置插入头尾的局限性
        if(n < 0 || n > SL.Listlen+1){
            System.out.println("插入位置有误!!!");
            return 0;
        }
        for(i= SL.Listlen ; i > n ; i--){
            SL.listData[i+1] = SL.listData[i];
        }
        SL.listData[i] = data;
        SL.Listlen++;
        return 1;//返回1表示插入成功，反之失败
    }
    /***********************************删除节点**************************/
    int SLDelete(SLType SL,int n)
    {
        int i;
        if(n < 1 || n >= SL.Listlen ){
            System.out.println("删除位置有误");
            return 0;
        }
        for(i = 0; i< SL.Listlen ; i++){
            SL.listData[i] = SL.listData[i+1];
        }
        SL.Listlen--;
        return 1;
    }

    /***********************************查找节点**************************/
    //按顺序查找
    DATA FindBynum(SLType SL,int n){
        if(n <= 0 || n >= SL.Listlen){
            System.out.println("查找位置有误");
            return null;
        }

        return SL.listData[n-1];
    }
    //按关键字查找
    DATA FindBykey(SLType SL,String key){
        for(int i = 0 ; i < SL.Listlen ; i++){
            if(SL.listData[i].key.equals(key)){
                return SL.listData[i];
            }
        }
        return null;
    }
    /*******************************遍历节点**************************/
    int SLALL(SLType SL){
        int i=0;
        while(SL.listData[i] != null){
            System.out.println(SL.listData[i].toString());
            i++;
            System.out.println("i="+i);
        }

        return 0;

    }

}
public class linear {
        public static void main(String[] args) {
            int i ;
            SLType SL = new SLType();//定义顺序表变量
            DATA Pdata;//定义节点保存引用变量
            String key;//用于保存关键字

            System.out.println("顺序表操作演示:");
            SL.init(SL);
            System.out.println("顺序表初始化完成");

            Scanner input = new Scanner(System.in);//构建扫描器
                System.out.println("请输入添加的节点：学号，名字，年龄:");
                DATA data = new DATA();
                data.key = input.next();
                data.name = input.next();
                data.age = input.nextInt();
                int n = 2;
                if(data.key != null){
                    SL.SLAdd(SL, data);
                }
                //插入一条新数据
                DATA data1 = new DATA();
                data1.key = input.next();
                data1.name = input.next();
                data1.age = input.nextInt();
                SL.SLInsert(SL, n, data1);
                SL.SLALL(SL);
                DATA data3 = SL.FindBynum(SL, 1);
                System.out.println(data3.toString());
        }
}

顺序表是数据结构中相对简单的一个，代码中比较混淆的就是插入位置 n 和 数组下标是以 0 开始的矛盾，不过只要分清了区别也不算很难理解