Java数据结构学习DAY2——顺序表

最新推荐文章于 2024-10-20 10:22:02 发布
最新推荐文章于 2024-10-20 10:22:02 发布
阅读量187 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： # Java数据结构 文章标签： java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/graceyun/article/details/114654583

Java数据结构———顺序表

1. 认识线性表和顺序表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串…
线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式储存。
在这里插入图片描述

2. Java中的 List 和 ArrayList

Collection：元素集合
List: 线性表
ArrayList: 顺序表

// 为了便于理解，以下代码并不完全符合语法规则，
package java.util;
import java.util.Collection; 
import java.util.Comparator;
import java.util.Iterator;
import java.util.ListIterator;
/**
* 线性结构
* 特点：
* 1. 元素和元素之间有前后关系
* 2. 元素会有在第几个位置的概念，位置通过下标（index）表示，从 0 开始
* 3. 插入可以根据位置的不同，分为：头插、尾插、按位置插入
* 4. 删除可以根据位置的不同，分为：头删、尾删、按位置删除
* 5. 遍历可以分为从前往后遍历和从后往前遍历
* 6. Java 中，List 是一个接口，并且是 Collection 的子接口
*/
public interface List extends Collection {
    /**
     * 将 e 尾插到线性表中
     * @参数 e 待插入的元素
     * @返回值 一定是 true，表示插入成功。线性表是不会出现插入不成功的情况的
     */
    boolean add(元素类型 e);
    /**
     * 将 e 插入到线性表的 index 位置处；要求原来 index 及之后的元素全部向后移动
     * index 的可选范围是 0 <= index <= size()
     * @参数 index 插入位置（下标）
     * @参数 待插入的元素
     */
    void add(int index, 元素类型 e);
    /**
     * 删除 index 位置的元素，并返回该元素；要求 原来 index + 1 及之后元素全部向前移动
     * index 的可选范围是 0 <= index < size()
     * @参数 index 待删除位置（下标）
     * @返回值 被删除掉的元素
     */
    元素类型 remove(int index);
    /**
     * 删除从前往后遍历时，遇到的第一个相等的（equals）元素
     * @参数 待删除元素
     * @返回值 true：删除成功； false：没有找到相等的元素
     */
    boolean remove(元素类型 e);
    /**
     * 返回 index 位置的元素
     * index 的可选范围是 0 <= index < size()
     * @参数 index 获取元素的位置（下标）
     * @返回值 获取到的元素
     */
    元素类型 get(int index);
    /**
     * 用新的元素 e 替换 index 位置的元素，并返回 index 位置的原来的元素
     * index 的可选范围是 0 <= index < size()
     * @参数 index 待替换元素的位置（下标）
     * @参数 e 要替换的新元素
     * @返回值 index 位置的老元素
     */
    元素类型 set(int index, 元素类型 e);
    /**
     * 通过遍历的方式，判断与元素 e 相等（equals）的元素是否存在于线性表中
     * @参数 e 待查找元素
     * @返回 true：包含；false：不包含
     */
    boolean contains(元素类型 e);
    /**
     * 按照从前往后遍历的方式，找到第一个与元素 e 相等（equals）的元素的下标
     * @param e 待查找元素
     * @return >= 0 表示找到并且返回下标；-1 代表没有找到
     */
    int indexOf(元素类型 e);
    /**
     * 按照从后往前遍历的方式，找到第一个与元素 e 相等（equals）的元素的下标
     * @param e 待查找元素
     * @return >= 0 表示找到并且返回下标；-1 代表没有找到
     */
    int lastIndexOf(元素类型 e);
    /**
     * 清空线性表，也就是，调用 clear() 后，线性表的 size() == 0；isEmpty() == 
true
     */
    void clear();
    /**
     * 返回线性表中已有元素的个数
     * @return 返回元数个数
     */
    int size();
    /**
     * 返回线性表是不是一个空的容器
     * @return true 为空容器
     */
    boolean isEmpty();
    ///// 以下的使用频率略低
    Iterator iterator();
    void sort(Comparator 比较器);
    List subList(int fromIndex, int toIndex);
}

2.1 迭代能力(Iterable) 和 迭代器(Iterator)

每种容器(Collection)都是具备迭代能力(Iterable)的。所以，每种容器都自带一个方法，返回一个合适的
迭代器(Iterator)以对容器进行无视实现差别的迭代。

3. 自己实现一个 ArrayList

自己实现一个MyArrayList, 并实现以下十二个基本方法

class MyArrayList {
    private String[] array;
    private int size;
    
    boolean add(String e);
    
    void add(int index, String e);
    
    String remove(int index);
    
    boolean remove(String e);
    
    String get(int index);
    String set(int index, String e);
    
    boolean contains(String e);
    
    int indexOf(String e);
    
    int lastIndexOf(String e);
     
    void clear();
    
    int size();
 
    boolean empty();

3.1 创建一个 MyArrayList

  • 代码
//为了代码简单，就不写泛型版本的，直接认为 ArrayList 中存的是 String
public class MyArrayList {
    //确定属性和方法
    //属性
    private String[] data = null;
    private int size = 0;//表示当前数组内的有效数组元素的个数
    private int capacity = 100;//表示当前顺序表最大容纳元素个数，如果 size 超过了 capacity, 就需要扩容

    //方法,增删改查

    //因为 data = null, 所以不能直接引用，这里写一个构造方法.也可以称为实例化
    public MyArrayList(){
        data = new String[capacity];
    }

    //实现扩容
    private void realloc(){

        //先把 capacity 变大(具体变大的公式自己随便定，根据实际要求进行确定)
        capacity = 2 * capacity;
        String[] newData = new String[capacity];
        //把旧的数据组中的数据拷贝到新数组中
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //把新的大的数组赋值给原有  的属性 data ，同时会释放掉旧的数组（GC)
        data = newData;
    }
    //alt + insert 选择 toString 方法。
    // 注意 toString 和 println 不要混为一谈，toSting 只是把对象转化为一个 String 而已
    //具体转化为 toString 之后是保存，是赋值，还是打印，还是写文件等等 都可以。
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for  (int i = 0; i <size; i++) {
            stringBuilder.append(data[i]);
            if (i <size-1) {
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }

3.2 十二个基本方法实现

3.2.1 元素尾插到顺序表末尾
  • 代码
    //1、元素尾插到顺序表末尾
    // O（1）的时间复杂度
    public void add(String elem) {
        if (size >= capacity) {
            //需要先扩容
        }

        //就直接把新的元素放到下标为 size 的位置上即可
        data[size] = elem;
        size++;
    }
3.2.2 把元素插入到任意中间位置
  • 代码
    //2、把元素插入到任意中间位置
    //O（n）的复杂度
    public void add(int index, String elem) {
        //如果 Index == size ，相当于把新元素插入到末尾~
        if (index <= 0 || index > size){
            return;
        }

        if (size >= capacity) {
            realloc();
        }
        //把 elem 放到 index 位置上， 不能覆盖掉已经有的元素
        // 需要把 index 位置的元素，依次往后搬运。给 index 位置腾出一个空闲空间，来放置 elem
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        //搬运完毕，把新的元素放到 index 位置上
        data[index] = elem;
        size++;
    }

结果验证： 写代码一定要测试，每次写一些逻辑，都尽快的进行验证。！！通过一些简单的测试代码，来测试另外一些代码的功能，这种测试我们称为“单元测试”。“单元测试”是开发写的，是一种思想方法的体现，意识。

  • 代码
 private static void testAdd() {
        MyArrayList myArrayList = new MyArrayList();

        //写代码一定要测试，每次写一些逻辑，都尽快的进行验证。！！
        //通过一些简单的测试代码，来测试另外一些代码的功能，这种测试我们称为“单元测试”。
        //“单元测试”是开发写的，是一种思想方法的体现，意识。

        //1. 验证尾插
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("python");
        System.out.println(myArrayList);


        //2，验证中间位置插入
        myArrayList.add(1,"javascript");
        System.out.println(myArrayList);
    }
    
    public static void main(String[] args) {
        testAdd()；
    }

代码运行结果：
在这里插入图片描述

3.2.3 按照下标位置删除元素（这个方法的返回结果就是被删除元素）
  • 代码
    //3. 按照下标位置删除元素,这个方法的返回结果就是被删除元素
    //O（n）的复杂度
    public String remove(int index) {
        //仍然是需要进行搬运，把 index 位置的元素覆盖掉即可
        if (index < 0 || index > size) {
            return null;
        }
        String result = data[index];
        for (int i = index; i < size-1; i++) {
            data[i] = data[i+1];
        }
        //别忘记 size 要更新
        size--;

        return result;
    }
3.3.4 按照元素的值来删除元素（这个方法返回成功/失败）
  • 代码
  //4. 按照元素的值来删除元素，这个方法返回成功/失败
    //O（n）的复杂度
    public boolean remove(String elem) {
        //先找到元素所在的位置
        int index = 0;
        for(; index < size; index++) {
            if (data[index].equals(elem)) {
                break;
            }
        }
        if (index >= size ) {
            //没找到匹配的元素，删除时不黑
            return false;
        }
        //找到匹配的元素了， 从 index 位置开始搬运
        for (int i = index; i < size-1 ; i++) {
            data[i] =  data[i+1];
        }
        size--;
        return true;
    }

结果验证

  • 代码
private static void testRemove(){
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("python");

        myArrayList.remove(1);
        System.out.println(myArrayList);

        myArrayList.remove("java");
        System.out.println(myArrayList);

    }
    public static void main(String[] args) {

    testRemove();
    }

运行结果
在这里插入图片描述

3.2.5 根据下标获取元素
  • 代码
  //5. 根据下标获取元素
    // O（1）的时间复杂度
    public  String get(int index) {
        if (index < 0 || index > size){
            //此处可以返回一个 null； 也可以抛出一个异常
           // return null;
            throw new MyArrayListIndexOutOfRangException("下标越界了！index：" + index);
        }
        return data[index];
    }
3.2.6 根据下标获取元素
  • 代码
//6.按照下标修改元素
    // O（1）的时间复杂度
    public void set(int index, String elem) {
        if (index < 0 || index > size){
            //此处可以返回一个 null； 也可以抛出一个异常
            // return null;
            throw new MyArrayListIndexOutOfRangException("下标越界了！index：" + index);
        }
        data[index] = elem;
    }

注意：这里抛出了一个异常，在最上面要引入 RuntimeException
代码

class MyArrayListIndexOutOfRangException extends RuntimeException{
    public MyArrayListIndexOutOfRangException(String message) {
        super(message);
    }
}

结果验证

  • 代码
 private static void testGetAndSet() {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("python");

        System.out.println(myArrayList.get(1));
        myArrayList.set(1,"javascrept");
        System.out.println(myArrayList);

        myArrayList.get(100);

    }
   public static void main(String[] args) {

       testGetAndSet();
    }

运行结果
在这里插入图片描述

3.2.7 判断元素是否存在
  • 代码
//7.判断元素是否存在
    //O（n）
    public boolean contains(String elem) {
        //此处不太方便用 for each
        //for each 遍历了整个  data 的所有元素
        //实际上只需要遍历前 size 个元素即可
        for (int i = 0; i < size;i++) {
            if (data[i].equals(elem)){
                return true;
            }
        }
        return false;
    }
3.2.8 查找元素位置
  • 代码
   //8. 查找元素位置
    //O(n）
    public int indexOf(String elem) {
        for (int i = 0; i < size; i++) {
            if(data[i].equals(elem)){
                return i;
            }
        }
        return -1;
    }
3.2.9 查找元素位置
  • 代码
    //9. 查找元素位置（从后往前找）
    //O(n)
    public int lastIndexOf(String elem) {
        for (int i = size-1 ; i >=0 ; i--){
            if (data[i].equals(elem)) {
                return i;
            }
        }
        return -1;
    }

结果验证

  • 代码
private static void testContainsAndIndexOf(){
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("c++");
        myArrayList.add("python");

        System.out.println(myArrayList.contains("c++"));

        System.out.println(myArrayList.indexOf("c++"));

        System.out.println(myArrayList.lastIndexOf("c++"));
    }
    
    public static void main(String[] args) {
    testContainsAndIndexOf();
    }

运行结果
在这里插入图片描述

3.2.10 三个方法（SizeEmptyClear）实现
  • 代码
  public void clear() {  //O（1）
        size = 0;
}

    public int size() {     //O（1）
        return size ;
}

    public boolean isEmpty() {  //O（1）

        return size == 0;
}

代码验证

  • 代码
 private static void testSizeEmptyClear() {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("c++");
        myArrayList.add("python");

        System.out.println(myArrayList.size());
        System.out.println(myArrayList.isEmpty());

        myArrayList.clear();

        System.out.println(myArrayList.size());
        System.out.println(myArrayList.isEmpty());
    }
        public static void main(String[] args) {
     testSizeEmptyClear();
    }

运行结果
在这里插入图片描述

完整代码 自己实现一个 ArrayList


package java41_0201;

import java.sql.Struct;
import java.util.Arrays;

class MyArrayListIndexOutOfRangException extends RuntimeException{
    public MyArrayListIndexOutOfRangException(String message) {
        super(message);
    }
}

//为了代码简单，就不写泛型版本的，直接认为 ArrayList 中存的是 String
public class MyArrayList {
    //确定属性和方法
    //属性
    private String[] data = null;
    private int size = 0;//表示当前数组内的有效数组元素的个数
    private int capacity = 100;//表示当前顺序表最大容纳元素个数，如果 size 超过了 capacity, 就需要扩容

    //方法,增删改查

    //因为 data = null, 所以不能直接引用，这里写一个构造方法.也可以称为实例化
    public MyArrayList(){
        data = new String[capacity];
    }

    //实现扩容
    private void realloc(){

        //先把 capacity 变大(具体变大的公式自己随便定，根据实际要求进行确定)
        capacity = 2 * capacity;
        String[] newData = new String[capacity];
        //把旧的数据组中的数据拷贝到新数组中
        for (int i = 0; i < data.length; i++) {
            newData[i] = data[i];
        }
        //把新的大的数组赋值给原有  的属性 data ，同时会释放掉旧的数组（GC)
        data = newData;
    }

    //1、元素尾插到顺序表末尾
    // O（1）的时间复杂度
    public void add(String elem) {
        if (size >= capacity) {
            //需要先扩容
        }

        //就直接把新的元素放到下标为 size 的位置上即可
        data[size] = elem;
        size++;
    }
    //2、把元素插入到任意中间位置
    //O（n）的复杂度
    public void add(int index, String elem) {
        //如果 Index == size ，相当于把新元素插入到末尾~
        if (index <= 0 || index > size){
            return;
        }

        if (size >= capacity) {
            realloc();
        }
        //把 elem 放到 index 位置上， 不能覆盖掉已经有的元素
        // 需要把 index 位置的元素，依次往后搬运。给 index 位置腾出一个空闲空间，来放置 elem
        for (int i = size-1; i >= index; i--) {
            data[i+1] = data[i];
        }
        //搬运完毕，把新的元素放到 index 位置上
        data[index] = elem;
        size++;
    }

    //3. 按照下标位置删除元素,这个方法的返回结果就是被删除元素
    //O（n）的复杂度
    public String remove(int index) {
        //仍然是需要进行搬运，把 index 位置的元素覆盖掉即可
        if (index < 0 || index > size) {
            return null;
        }
        String result = data[index];
        for (int i = index; i < size-1; i++) {
            data[i] = data[i+1];
        }
        //别忘记 size 要更新
        size--;

        return result;
    }

    //4. 按照元素的值来删除元素，这个方法返回成功/失败
    //O（n）的复杂度
    public boolean remove(String elem) {
        //先找到元素所在的位置
        int index = 0;
        for(; index < size; index++) {
            if (data[index].equals(elem)) {
                break;
            }
        }
        if (index >= size ) {
            //没找到匹配的元素，删除时不黑
            return false;
        }
        //找到匹配的元素了， 从 index 位置开始搬运
        for (int i = index; i < size-1 ; i++) {
            data[i] =  data[i+1];
        }
        size--;
        return true;
    }

    //5. 根据下标获取元素
    // O（1）的时间复杂度
    public  String get(int index) {
        if (index < 0 || index > size){
            //此处可以返回一个 null； 也可以抛出一个异常
           // return null;
            throw new MyArrayListIndexOutOfRangException("下标越界了！index：" + index);
        }
        return data[index];
    }

    //6.按照下标修改元素
    // O（1）的时间复杂度
    public void set(int index, String elem) {
        if (index < 0 || index > size){
            //此处可以返回一个 null； 也可以抛出一个异常
            // return null;
            throw new MyArrayListIndexOutOfRangException("下标越界了！index：" + index);
        }
        data[index] = elem;
    }

    //7.判断元素是否存在
    //O（n）
    public boolean contains(String elem) {
        //此处不太方便用 for each
        //for each 遍历了整个  data 的所有元素
        //实际上只需要遍历前 size 个元素即可
        for (int i = 0; i < size;i++) {
            if (data[i].equals(elem)){
                return true;
            }
        }
        return false;
    }

    //8. 查找元素位置
    //O(n）
    public int indexOf(String elem) {
        for (int i = 0; i < size; i++) {
            if(data[i].equals(elem)){
                return i;
            }
        }
        return -1;
    }

    //9. 查找元素位置（从后往前找）
    //O(n)
    public int lastIndexOf(String elem) {
        for (int i = size-1 ; i >=0 ; i--){
            if (data[i].equals(elem)) {
                return i;
            }
        }
        return -1;
    }

    public void clear() {  //O（1）
        size = 0;
}

    public int size() {     //O（1）
        return size ;
}

    public boolean isEmpty() {  //O（1）

        return size == 0;
}

    //alt + insert 选择 toString 方法。
    // 注意 toString 和 println 不要混为一谈，toSting 只是把对象转化为一个 String 而已
    //具体转化为 toString 之后是保存，是赋值，还是打印，还是写文件等等 都可以。
    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("[");
        for  (int i = 0; i <size; i++) {
            stringBuilder.append(data[i]);
            if (i <size-1) {
                stringBuilder.append(",");
            }
        }
        stringBuilder.append("]");
        return stringBuilder.toString();
    }

    private static void testAdd() {
        MyArrayList myArrayList = new MyArrayList();

        //写代码一定要测试，每次写一些逻辑，都尽快的进行验证。！！
        //通过一些简单的测试代码，来测试另外一些代码的功能，这种测试我们称为“单元测试”。
        //“单元测试”是开发写的，是一种思想方法的体现，意识。

        //1. 验证尾插
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("python");
        System.out.println(myArrayList);


        //2，验证中间位置插入
        myArrayList.add(1,"javascript");
        System.out.println(myArrayList);
    }

    private static void testRemove(){
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("python");

        myArrayList.remove(1);
        System.out.println(myArrayList);

        myArrayList.remove("java");
        System.out.println(myArrayList);

    }

    private static void testGetAndSet() {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("python");

        System.out.println(myArrayList.get(1));
        myArrayList.set(1,"javascrept");
        System.out.println(myArrayList);

        myArrayList.get(100);

    }

    private static void testContainsAndIndexOf(){
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("c++");
        myArrayList.add("python");

        System.out.println(myArrayList.contains("c++"));

        System.out.println(myArrayList.indexOf("c++"));

        System.out.println(myArrayList.lastIndexOf("c++"));
    }

    private static void testSizeEmptyClear() {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add("c");
        myArrayList.add("c++");
        myArrayList.add("java");
        myArrayList.add("c++");
        myArrayList.add("python");

        System.out.println(myArrayList.size());
        System.out.println(myArrayList.isEmpty());

        myArrayList.clear();

        System.out.println(myArrayList.size());
        System.out.println(myArrayList.isEmpty());
    }


    public static void main(String[] args) {
//        testAdd();
//     testRemove();
//     testGetAndSet();
//     testContainsAndIndexOf();
     testSizeEmptyClear();

    }

}
java数据结构自定义顺序表
weixin_34352492的博客
08-31 924
自定义顺序表 目录自定义顺序表一、包含功能二、具体实现过程0.0 自定义顺序表0.1 扩容0.2 重写toString1.插入元素1.1 尾插1.2 指定位置插入2.插入元素2.1 按照指定元素删除2.2 按照目标元素删除3.根据下标获取元素4.根据下标修改元素5.判断元素是否存在6.查找元素位置6.1 从前往后6.2 从后往前7.清空元素8.求长度9.判断是否为空10.测试函数10.1 测试增加函数10.2 测试删除函数10.3 测试获取/修改函数10.4 测试存在/元素位置函数10.5 测试清空/长度/
数据结构(Java)——Day10(双向链表，栈)
LengchenAl的博客
11-24 855
数据结构(Java)——Day10(双向链表，栈)
Java实现顺序表
chenzhe2662的博客
10-23 249
目录 1. 顺序表 1.1 顺序及结构 1.2 代码框架 1.3 具体代码 1.3.1 创建类 1.3.2 打印顺序表 1.3.3 新增元素 1.3.4 判定是否包含某个元素 1.3.5 查找到元素位置 1.3.6 获取pos位置的元素 1.3.7 删除第一次出现的关键字key 1.3.8 其他 1.4 顺序表的问题与思考 1. 顺序表 1.1 顺序及结...
数据结构之顺序表（Java实现）
Easenyang的博客
05-10 995
顺序表概述二级目录二级目录二级目录二级目录 顺序表概述 简介： 顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺序存储结构的线性表通常称为顺序表。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。 顺序表存储示意图： 二级目录 二级目录 二级目录 二级目录 ...
数据结构|顺序表及Java实现
Yang_ccH的博客
01-23 571
数据结构|顺序表及Java实现 1. 认识线性表和顺序表 线性表(linear list)是n个具有相同特征的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表有：顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构的，但是在物理结构上并不一定是连续的。 1.1 顺序表 逻辑上线性，在内存中存储时，也是严格按照逻辑上的次序保存起来的。 1.2 链表 逻辑上线性，在内存中存储时，不保证连续性。 1.2 数组 数组就是一种“不是非常完备”的顺序表。 数组中存在的问题： a. 无法严格
顺序表 — Java
m0_54344602的博客
08-01 108
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改
Java基础——链表
qq_52519008的博客
06-14 3392
　　单向链表只有一个指针域，在整个节点中数据域用来存储数据元素，指针域用于指向下一个具有相同结构的节点。 单向链表中，每个节点的数据域都是通过一个 Object 类的对象引用来指向数据元素的，与数组类似，单向链表中的节点也具有一个线性次序，即如果节点 a1 的 next 引用指向节点 a2，则 a1 就是 a2 的直接前驱，a2 是 a1 的直接后续。只能通过前驱节点找到后续节点，而无法从后续节点找到前驱节点。 特点： 　　数据元素的存储对应的是不连续的存储空间，每个存储结点对应一个需要存储的数据元素。每个
Leap Day1——数据结构与算法 抽象数据类型、算法分析和效率(1)
2401_84150154的博客
05-06 1068
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Web前端开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点！
【五月集训】Day07——哈希表
ChaunceyPeng的博客
05-07 876
哈希表 知识管理 五月集训
数据结构与算法——Java实现 39.二叉树②迭代实现
最新发布
m0_73983707的博客
10-20 426
然后先将右子节点入栈（如果存在），再将左子节点入栈（如果存在）。这样就保证了先访问根节点，然后是左子树，最后是右子树。首先将根节点入第一个栈，然后在循环中，如果节点有子节点，先将右子节点入栈，再将左子节点入栈。首先将根节点以及其所有左子节点依次入栈，直到左子节点为空。然后取出栈顶节点并输出其值，接着将当前节点的右子节点作为新的当前节点，重复上述过程。的数据结构，所以先入栈的左子节点会在右子节点之后被处理，从而实现了前序遍历。第一个栈用于将节点按照根、右子节点、左子节点的顺序入栈，第二个栈用于。
java 数据结构之顺序表、ArrayList源码分析
xiaotanke
11-28 536
java 数据结构之顺序表 线性表是最简单的一种数据结构，一个线性表有n个具有相同特性的的数据元素的序列。 1、手写顺序表 前驱元素： 若A元素的前面是B元素，则称B是A的前驱元素。没有前驱元素的元素成为头结点。 后继元素： 若A元素的后面是B元素，则称B是A的后继元素。没有后继元素的元素成为尾结点。 通过存储方式的不同，可以将线性表分为两类，一类是顺序表，另一类是链表。 顺序表的基本实现： 属性 属性名 解释 默认值 elements[] 存放元素的数组 长度为5的一个泛型数组
Java数据结构——顺序表
abc1303007805的博客
05-23 240
一个线性表是由n(n≥0)个数据元素所构成的有限序列。 线性表逻辑地表示为：（a0,a1,…,an-1)。其中，n为线性表的长度，n=0时为空表。i为ai在线性表中的位序号。 存储结构： 1.顺序存储，数据是存放是连续的 2.链式存储，数据存放不是连续的，但之间有联系保证找到下一个数据。 顺序存储的线性列表 存储位置连续，可以很方便计算各个元素的地址 最简单的顺序存储线性表是数组，ArrayList也是基于顺序表的。 顺序表的插入操作 顺序表的删除操作 与链表的主要区别 链式线性表
Java 数据结构与算法 顺序表
Naion的博客
12-28 482
顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。 下面，我们来实现一个动态的顺序表。 1，要实现的接口 public class SeqList { ...
Java实现顺序表（设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序）
qq_49632014的博客
01-14 2114
问题描述 设顺序表A中的数据元素递增有序，试写一程序，将x插入到顺序表的适当位置上，使该表仍然有序 输入 顺序表元素的个数，顺序表中递增有序的多个数，要插入的数 输出 原顺序表的数据，插入一个数后顺序表的数据 存储结构 采用顺序表存储 算法的基本思想 自定义一个类，包含两个属性，一个为数组用来记录数据，一个为int型数据用来记录数组的容量。顺序表的初始化：设置默认值即使用无参构造时会实例化一个默认值大小的数组，数组容量也为默认值，若使用有参构造进行初始化，由使用者决定数组的容量。数组扩容：通过一个新的数组实
数据结构之顺序表Java实现
qq_46620285的博客
12-29 1101
线性表之顺序表 顺序表：把线性表中的所有元素按照顺序存储的方法进行存储，也就是用一组地址连续的存储单元依次存储线性表的数据元素。所以顺序表的逻辑顺序和物理顺序是一致的，但是物理位置比逻辑位置少1（因为逻辑顺序是从0开始的，而物理顺序是从1开始的，这一个细节是很重要的！！！） 顺序表的特点：1.顺序表的逻辑顺序和物理顺序是一致的，但是物理位置比逻辑位置少1（因为逻辑顺序是从0开始的，而物理顺序是从1开始的，这一个细节是很重要的！！！） 2.顺序表中任意一个数据元素可以随机存取，即顺序表是一种随机存取的数据结构
java 泛型构造器_不同Java泛型构造函数的详解
weixin_42506911的博客
02-13 1070
1.概述我们之前讨论过Java Generics的基础知识。在本文中，我们将了解Java中的通用构造函数。泛型构造函数是至少需要有一个泛型类型参数的构造函数。我们将看到泛型构造函数并不都是在泛型类中出现的，而且并非所有泛型类中的构造函数都必须是泛型。2.非泛型类首先，先写一个简单的类:Entry，它不是泛型类：public class Entry {private String data;priv...
顺序表(java)
m0_49042213的博客
09-02 346
一、线性表 线性表是最基本、最简单、也是最常用的一种数据结构。一个线性表是n个具有相同特性的数据元素的有限序列。 前驱元素： 若A元素在B元素的前面，则称A为B的前驱元素 后继元素： 若B元素在A元素的后面，则称B为A的后继元素 线性表的特征：数据元素之间具有一种“一对一”的逻辑关系。 1 . 第一个数据元素没有前驱，这个数据元素被称为头结点； 2. 最后一个数据元素没有后继，这个数据元素被称为尾结点； 3. 除了第一个和最后一个数据元素外，其他数据元素有且仅有一个前驱和一个后继。 如果把线性表用数学语言来
《数据结构》2.2顺序表（sequence list）
aawyxv2369的博客
07-17 450
1 //顺序表节点的定义 2 typedef struct 3 { 4 datatype data[MAXSIZE]; //数组容量的上限 5 int len; //记录最后一个元素的位置，相当于一个指针，表空时len=-1 6 }SeqList; 7 S...
JAVA实现顺序表
zhangdongxuan的博客
07-17 2209
JAVA实现顺序表      花了十来分钟帮同学写了一个顺序表，顺序表是线性表中最简单的，最容易实现的。顺序表中元素在逻辑上的相邻，在物理上也是相邻的。顺序表可以用数组来实现。下面是实现   /** * 顺序表的储存结构：在逻辑上相邻的元素，他们在物理上也是相邻的 所以可以用数组来实现 * * @author ZDX * */ public class SqList
深入理解线性表：数据结构编程实践
标题“数据结构小练习-线性表（下）”表明，这个练习是数据结构学习过程中的一个环节，专门针对线性表这一数据结构进行实操演练。线性表是最简单、最常用的一种数据结构，其特点是个别元素之间的关系是一对一的关系...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值