java基础-- 数据结构(线性表实现)

线性表(linear list)
线性表是n个类型相同数据元素的有限序列,通常记作(a 0 , a 1 , …a i-1 , a i , a i+1 …,a n-1 )。

  • 相同数据类型

    在线性表的定义中,我们看到从a 0 到a n-1 的n个数据元素是具有相同属性的元素。
    比如说可以都是数字,例如(23, 14, 66, 5, 99);
    也可以是字符,例如(A, B, C, … Z);
    当然也可以是具有更复杂结构的数据元素,例如学生、商品、装备。
    相同数据类型意味着在内存中存储时,每个元素会占用相同的内存空间,便于后续的查询定位。

  • 序列(顺序性)

    在线性表的相邻数据元素之间存在着序偶关系,
    即a i-1 是a i 的直接前驱,则a i 是a i-1 的直接后续,
    同时a i 又是a i+1 的直接前驱,a i+1 是a i 的直接后续。
    唯一没有直接前驱的元素a 0 一端称为表头,
    唯一没有后续的元素a n-1 一端称为表尾。
    除了表头和表尾元素外,任何一个元素都有且仅有一个直接前驱和直接后继。

  • 有限

    线性表中数据元素的个数n定义为线性表的长度,n是一个有限值。
    当n=0 时线性表为空表。
    在非空的线性表中每个数据元素在线性表中都有唯一确定的 序号, 例如a 0 的序号是 0,a i 的序号是i。
    在一个具有n > 0 个数据元素的线性表中,数据元素序号的范围是[0, n-1]。

生活案例:冰糖葫芦、多个学生分数、多个学生数据

线性表的逻辑结构

在这里插入图片描述

具体描述参看上面线性表的定义

线性表的存储结构

  1. 顺序表----顺序存储结构
    在这里插入图片描述
    特点:在内存中分配连续的空间,只存储数据,不需要存储地址信息。位置就隐含着地址。
    优点:

    1. 节省存储空间,因为分配给数据的存储单元全用存放结点的数据(不考虑c/c++语言中数组需指定大小的情况),结点之间的逻辑关系没有占用额外的存储空间。

    2. 索引查找效率高,即每一个结点对应一个序号,由该序号可以直接计算出来结点的存储地址。

    缺点:

    1. 插入和删除操作需要移动元素,效率较低。

    2. 必须提前分配固定数量的空间,如果存储元素少,可能导致空闲浪费。

    3. 按照内容查询效率低,因为需要逐个比较判断

      举例:长度为n的数组中删除元素,假设每个元素删除的概率是相同的,问时间复杂度是?

      删掉第n个元素,需要移动0个元素
      删掉第n-1个元素,需要移动1个元素
      删掉第n-2个元素,需要移动2个元素
      ....
      删掉第2个元素,需要移动n-2个元素
      删掉第1个元素,需要移动n-1个元素
      
      所以平均时间频度是:0*1/n + 1*1/n  + 2*1/n + 3*1/n +  + (n-1)*1/n = (n-1)*n/2 * 1/n = (n-1)/2
      T(n) = (n-1)/2
      T(n)= O(n)	
      
  2. 链表----链式存储结构

    特点:数据元素的存储对应的是不连续的存储空间,每个存储结点对应一个需要存储的数据元素。
    每个结点是由数据域和指针域组成。 元素之间的逻辑关系通过存储节点之间的链接关系反映出来。
    逻辑上相邻的节点物理上不必相邻。
    在这里插入图片描述
    缺点:

    1. 比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成,所以相同空间内假设全存满的话顺序比链式存储更多)。
    2. 查找结点时链式存储要比顺序存储慢(每个节点地址不连续、无规律,导致按照索引查询效率低下)。

    优点:

    1. 插入、删除灵活 (不必移动节点,只要改变节点中的指针,但是需要先定位到元素上)。
    2. 有元素才会分配结点空间,不会有闲置的结点。

线性表操作

public interface LineList {

    // 返回线性表的大小,即数据元素的个数。
    public int size();

    // 返回线性表中序号为 i 的数据元素
    public Object get(int i) throws Exception;

    // 如果线性表为空返回 true,否则返回 false。
    public boolean isEmpty();

    // 判断线性表是否包含数据元素 e
    public boolean contains(Object e);

    // 返回数据元素 e 在线性表中的序号
    public int indexOf(Object e);

    // 将数据元素 e 插入到线性表中 i 号位置
    public boolean add(int i, Object e) throws Exception;

    // 将数据元素 e 插入到线性表末尾
    public boolean add(Object e) throws Exception;

    // 将数据元素 e 插入到元素 obj 之前
    public boolean addBefore(Object obj, Object e);

    // 将数据元素 e 插入到元素 obj 之后
    public boolean addAfter(Object obj, Object e);

    // 删除线性表中序号为 i 的元素,并返回之
    public boolean remove(int i) throws Exception;

    // 删除线性表中第一个与 e 相同的元素
    public boolean remove(Object e);

    // 替换线性表中序号为 i 的数据元素为 e,返回原数据元素
    public Object replace(int i, Object e) throws Exception;
}

实现及测试类

package com.dataStructure;
public class LList implements LineList {

private Object[] listElem; // 线性表存储空间
private int curLen; // 当前长度

public LList(int maxSize) {
    curLen = 0;
    listElem = new Object[maxSize];
}


@Override
public int size() {
    return curLen;
}

@Override
public Object get(int i) throws Exception {
    if (i < 0 || i > curLen - 1) // i小于0或者大于表长减1
        throw new Exception("第" + i + "个元素不存在"); // 输出异常
    return listElem[i];
}

@Override
public boolean isEmpty() {
    return listElem.length == 0;
}

@Override
public boolean contains(Object e) {
    for (int i = 0; i < listElem.length; i++) {
        if (listElem[i].equals(e)) {
            return true;
        }
    }
    return false;
}

@Override
public int indexOf(Object e) {
    for (int i = 0; i < listElem.length; i++) {
        if (listElem[i].equals(e)) {
            return i;
        }
    }
    return 0;
}

@Override
public boolean add(int i, Object e) throws Exception {
    if (listElem.length == curLen) {
        throw new Exception("顺序表已满");// 输出异常
    }
    if (i < 0 || i > listElem.length) {
        throw new Exception("插入位置不合理");
    }

    for (int j = curLen; j >= i; j--) {
        listElem[j] = listElem[j - 1];
    }
    listElem[i] = e;
    curLen++;
    return true;
}

@Override
public boolean add(Object e) throws Exception {
    if (listElem.length == curLen) {
        throw new Exception("顺序表已满");// 输出异常
    }
    listElem[curLen + 1] = e;
    curLen++;
    return true;
}

@Override
public boolean addBefore(Object obj, Object e) {
    if (listElem.length == curLen) {
        return false;
    }
    int i = 0;
    for (i = 0; i <= curLen; i++) {
        if (listElem[i]==e) {
            break;
        }
    }
    for (int j = curLen; j >= i; j--) {
        listElem[j + 1] = listElem[j];
    }
    listElem[i] = obj;
    curLen++;
    return true;
}

@Override
public boolean addAfter(Object obj, Object e) {
    if (listElem.length == curLen) {
        return false;
    }
    int i = 0;
    for (i = 0; i <= curLen; i++) {
        if (listElem[i]==e) {
            break;
        }
    }
    for (int j = curLen; j > i; j--) {
        listElem[j + 1] = listElem[j];
    }
    listElem[i+1] = obj;
    curLen++;
    return true;
}

@Override
public boolean remove(int i) throws Exception {
    if (i < 0 || i > curLen - 1) {
        throw new Exception("删除位置不合理");// 输出异常
    }
    for (int j = i + 1; j < curLen; j++) {
        listElem[i] = listElem[j];
    }
    curLen--;
    return true;
}

@Override
public boolean remove(Object e) {
    for (int i = 0; i < curLen; i++) {
        if (listElem[i]==e) {
            listElem[i] = listElem[i + 1];
        }
    }
    curLen--;
    return true;
}

@Override
public Object replace(int i, Object e) throws Exception {
    if (i < 0 || i > curLen) {
        throw new Exception("替换不合理");
    }
    for (int j = 0; j < curLen; j++) {
        if (j == i) {
            listElem[j] = e;
        }
    }
    return e;
}


public void print() throws Exception {
    for (int j = 0; j < curLen; j++) {
        System.out.println(listElem[j]);
    }
}
public static void main(String[] args) throws Exception {
    LList list = new LList(10);
    System.out.println("线性表长度:" + list.size());
    boolean boo = list.add(10);
    System.out.println("添加第一个数据10:返回:" + boo);
    list.add(1, 20);
    System.out.println("添加第二个数据20:线性表长度:" + list.size());
    list.addBefore(15,20);
    System.out.println("在20之前添加15:线性表长度:" + list.size());
    //list.remove(1);
    list.addAfter(25,20);
    System.out.println("在20之后添加25:线性表长度:" + list.size());
    list.remove("10");
    System.out.println("删除10之后:线性表长度:" + list.size());
    list.replace(0,50);
    System.out.println("------------");
    list.print();
    int location = list.indexOf(20);
    System.out.println("返回20在线性表中的位置:"+location);
  }
}

https://www.cnblogs.com/fingerboy/p/5478073.html ( 深入理解java中的ArrayList和LinkedList)

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值