1. Toy模板网首页
  2. > Toy博客

java数据结构与算法：顺序表SequentiaList

9月前 作者：林小果1 分类：Toy博客 阅读(39) 违法举报

这篇具有很好参考价值的文章主要介绍了java数据结构与算法：顺序表SequentiaList。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

顺序表SequentiaList

创建List接口并定义方法

package com.lhs;

import java.util.Objects;

public interface List<E> {
    int size();
    boolean isEmpty();

    boolean contains(Object o);

    boolean add(E e);

    E get(int index);

    E set(int index, E e);

    E remove(int index);

    void addFirst(E e);

    void addLast(E e);

    E removeFirst();

    E removeLast();
}

实现方法

package com.lhs;


import java.util.Collection;
import java.util.Iterator;
import java.util.ListIterator;

public class SequentiaList<E> implements List<E> {

    private static final  int DEFAULT_CAPACITY = 10;

    private int size;

    private Object[] elementData;

    public SequentiaList(int capacity) {
        elementData = new Object[capacity];
        size = 0;
    }
    public SequentiaList() {
        this(DEFAULT_CAPACITY);
    }


    // 返回列表中元素的数量
    @Override
    public int size() {
        return size;
    }

    // 判断列表是否为空
    @Override
    public boolean isEmpty() {
        return size == 0;
    }

    // 判断列表中是否包含某个元素
    @Override
    public boolean contains(Object o) {
        if(size == 0){
            return false;
        }
        for (int i = 0; i < size; i++) {
            if(elementData[i] == o)
                return true;
        }
        return false;
    }

    // 向列表中添加一个元素
    @Override
    public boolean add(E e) {
        if(size == elementData.length){
            throw new IndexOutOfBoundsException("list is full");
        }
        elementData[size] = e;
        size++;
        return true;
    }

    // 获取列表中指定索引位置的元素
    @Override
    public E get(int index) {
        if(index >= size){
            throw new IndexOutOfBoundsException(index + " is out of bounds");
        }
        return (E) elementData[index];
    }

    // 设置列表中指定索引位置的元素
    @Override
    public E set(int index, E e) {
        if(index >= size){
            throw new IndexOutOfBoundsException(index + " is out of bounds");
        }
        E oldVal = (E) elementData[index];
        elementData[index] = e;
        return oldVal;
    }

    // 移除列表中指定索引位置的元素
    @Override
    public E remove(int index) {
        if(index >= size){
            throw new IndexOutOfBoundsException(index + " is out of bounds");
        }
        E oldVal = (E) elementData[index];
        for (int i = index ;i < size - 1;i++){
            elementData[i] =  elementData[i+1];
        }
        size--;
        return oldVal;
    }

    // 向列表开头添加一个元素
    @Override
    public void addFirst(E e) {
        if(size == elementData.length){
            throw new IndexOutOfBoundsException("list is full");
        }
        for (int i = size ;i > 0;i--){
            elementData[i] = elementData[i-1];
        }
        elementData[0] = e;
        size++;
    }

    // 向列表结尾添加一个元素
    @Override
    public void addLast(E e) {
        if(size == elementData.length){
            throw new IndexOutOfBoundsException("list is full");
        }
        elementData[size] = e;
        size++;
    }

    // 移除列表开头的一个元素
    @Override
    public E removeFirst() {
        return remove(0);
    }

    // 移除列表结尾的一个元素
    @Override
    public E removeLast() {
        return remove(size-1);
    }
}

测试

package com.lhs;

import org.junit.Test;

import static junit.framework.TestCase.*;
import static org.junit.Assert.assertThrows;

public class SequentiaListTest {

    @Test
    public void testSize() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        assertTrue(list.size() == 0);

        list.add("Java");
        assertTrue(list.size() == 1);
    }

    @Test
    public void testIsEmpty() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        assertTrue(list.isEmpty());

        list.add("Java");
        assertFalse(list.isEmpty());
    }

    @Test
    public void testContains() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.add("Java");
        list.add("C++");
        list.add("C");
        list.add("Python");
        list.add("TypeScript");

        // 判断存在
        assertTrue(list.contains("Java"));

        // 判断不存在
        assertFalse(list.contains("Java++"));
    }

    @Test
    public void testAdd() {
        // 实例化SequentialList
        List<Integer> list = new SequentiaList<>(5);
        list.add(1);
        list.add(2);
        list.add(3);
        list.add(4);
        list.add(5);

        Throwable excpetion = assertThrows(IndexOutOfBoundsException.class, () -> {
            list.add(6); // 抛异常
        });

        assertEquals("list is full", excpetion.getMessage());
    }

    @Test
    public void testGet() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.add("Java");
        list.add("C++");
        list.add("C");

        // 判断存在
        assertEquals("C++", list.get(1));

        // 判断不存在
        assertNull(list.get(4));
    }

    @Test
    public void testSet() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.add("Java");
        list.add("C++");
        list.add("C");

        // 判断存在
        assertEquals("C", list.set(2, "Python"));

        // 判断不存在
        assertEquals(null, list.set(4, "TypeScript"));
    }

    @Test
    public void testRemove() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.add("Java");
        list.add("C++");
        list.add("C");

        // 判断存在
        assertEquals("C", list.remove(2));

        // 判断不存在
        int index = 6;
        Throwable excpetion = assertThrows(IndexOutOfBoundsException.class, () -> {
            list.remove(index); // 抛异常
        });

        assertEquals(index + " is out of bounds", excpetion.getMessage());
    }

    @Test
    public void testAddFirst() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.addFirst("Java");
        list.addFirst("C++");
        list.addFirst("C");

        // 判断存在
        assertEquals("C", list.get(0));
        assertEquals("C++", list.get(1));
        assertEquals("Java", list.get(2));
    }

    @Test
    public void testAddLast() {
        // 实例化SequentialList
        List<String> list =new SequentiaList<>(5);
        list.addLast("Java");
        list.addLast("C++");
        list.addLast("C");

        // 判断存在
        assertEquals("Java", list.get(0));
        assertEquals("C++", list.get(1));
        assertEquals("C", list.get(2));
    }


    @Test
    public void testRemoveFirst() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.add("Java");
        list.add("C++");
        list.add("C");

        // 判断存在
        assertEquals("Java", list.removeFirst());
        assertEquals("C++", list.removeFirst());
        assertEquals("C", list.removeFirst());
    }

    @Test
    public void testRemoveLast() {
        // 实例化SequentialList
        List<String> list = new SequentiaList<>(5);
        list.add("Java");
        list.add("C++");
        list.add("C");

        // 判断存在
        assertEquals("C", list.removeLast());
        assertEquals("C++", list.removeLast());
        assertEquals("Java", list.removeLast());
    }
}

java数据结构与算法：顺序表SequentiaList,算法,java,数据结构,算法文章来源地址https://www.toymoban.com/news/detail-788232.html

到了这里，关于java数据结构与算法：顺序表SequentiaList的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处： 如若内容造成侵权/违法违规/事实不符，请点击违法举报进行投诉反馈，一经查实，立即删除！

分享到：
领支付宝红包 赞助服务器费用

相关文章

  • 数据结构算法--1 顺序查找二分查找

    顺序查找时间复杂度为O(n) 我们可以借助Python中的函数enumerate,通过enumerate遍历列表返回其索引和值 也可以通过列表长度依次遍历: 但是二分查找时间复杂度为O(logn):

    2024年02月12日
    浏览(52)
  • 顺序表（更新版）——“数据结构与算法”

    顺序表（更新版）——“数据结构与算法”

    各位CSDN的uu们你们好呀，今天小雅兰又来更新新专栏啦，其实之前我就已经写过了顺序表的内容，只是之前的内容不是最新版的顺序表，现在，我来更新一下最新版的顺序表，下面，就让我们进入更新版的顺序表的世界吧 顺序表和小雅兰之前写的三子棋、扫雷、通讯录一样，

    2023年04月23日
    浏览(30)
  • 【数据结构与算法】之顺序表及其实现！

    【数据结构与算法】之顺序表及其实现！

    目录 ​编辑 1. 顺序表的概念及结构 2. 接口的实现 2.1 顺序表的初始化 2.2 检查顺序表容量是否已满 2.3 顺序表的尾插 ​编辑 2.4 顺序表的尾删 2.5 顺序表的头插 2.6  顺序表的头删 2.7 顺序表在pos位置插入 2.8  顺序表在pos位置删除 2.9 顺序表的查找 2.10 顺序表的销毁 2.1

    2024年04月28日
    浏览(32)

  • 数据结构与算法 --顺序表的创建

    1. 顺序表（Sequence List）是一种线性表的实现方式，通过连续的内存空间存储元素，按照顺序排列。 顺序表的特点包括： 元素在内存中的存储是连续的，通过数组实现。 元素之间的逻辑顺序与物理顺序一致。 可以根据元素的索引直接访问和修改元素。 需要预先分配足够的内

    2024年03月26日
    浏览(48)
  • 【数据结构】：实现顺序表各种基本运算的算法

    【数据结构】：实现顺序表各种基本运算的算法

    领会顺序表存储结构和掌握顺序表中各种基本运算算法设计。 编写一个程序sqlist.cpp，实现顺序表的各种基本运算和整体建表算法（假设顺序表的元素类型ElemType为char），并在此基础上设计一个主程序，完成如下功能： 初始化顺序表L 依次插入a,b,c,d,e元素 输出顺序表L 输出顺

    2024年02月07日
    浏览(43)
  • 【Java 数据结构】顺序表

    【Java 数据结构】顺序表

    篮球哥温馨提示：编程的同时不要忘记锻炼哦！ 目录 1、什么是顺序表？ 2、模拟实现ArrayList 2.1 模拟实现前的约定 2.2 构造方法 2.3 add方法 2.4 contains 方法 2.5 indexOf 方法 2.6 get 方法 2.7 set 方法 2.8 remove 方法 2.9 getSize 和 clear 方法 3、ArrayList 的学习 3.1 ArrayList的成员属性 3.2 Arr

    2024年02月20日
    浏览(31)

  • 数据结构与算法-头歌【1】顺序线性表--课上练

      本意是整理和复习，理解不深或者有错误的评论区提出即可。 只有第一关的代码里面有结构体的定义，其余我只放了功能函数。 任务描述 本关要求按照完成顺序表数据类型定义，并初始化一个顺序线性表。 编程要求 顺序线性表数据结构定义如下： 本关的编程任务是补全

    2023年04月25日
    浏览(40)
  • 【数据结构与算法】掌握顺序栈：从入门到实践

    【数据结构与算法】掌握顺序栈：从入门到实践

       🌱博客主页：青竹雾色间. 🌱系列专栏：数据结构与算法 😘博客制作不易欢迎各位👍点赞+⭐收藏+➕关注 目录 前言 顺序栈的实现 初始化栈 判断栈空 判断栈满 入（进）栈 出栈 获取栈顶元素 示例代码 顺序栈的应用前景 当你学习数据结构和算法时，顺序栈（Sequential

    2024年02月08日
    浏览(64)

  • 数据结构与算法之查找: 顺序查找 (Javascript版)

    顺序查找 思路 遍历数组 找到跟目标值相等元素，就返回它的下标 没有找到，返回-1 算法实现 总结 非常低效，算是入门搜索 时间复杂度：O(n) 对于数组结构或链表结构而言，没什么太多可说的

    2024年02月05日
    浏览(47)
  • 【数据结构与算法】：手搓顺序表（Python篇）

    【数据结构与算法】：手搓顺序表（Python篇）

    一、顺序表的概念 顺序表是一种线性的数据结构，其中数据元素按照特定的顺序依次存储在连续的内存空间中。它由一系列元素组成，每个元素都与唯一的索引（或者叫下标）相关联，索引从 0 开始递增。 顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结

    2024年04月28日
    浏览(33)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包，优惠每天领

二维码1

领取红包

二维码2

领红包