数据结构-线性表之顺序储存(Java实现)

本文介绍了线性表的顺序储存结构,通过数组实现数据的插入和移除。详细阐述了线性表为空时、插入到末尾以及一般情况下的插入操作,并解析了移除数据的末尾移除和一般情况。最后提供了Java代码实现和演示。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

理解

顺序储存结构是用数组来保存数据的。用图来表示如下:
点击这里查看大图
这里写图片描述

说明:线性表也就是数组的一种特殊储存方式:从头到尾依次储存数据。

下面这种情况就不是线性表:
点击这里查看大图
这里写图片描述

插入数据

1. 线性表为空的情况

点击这里查看大图
这里写图片描述
很简单,当线性表为空时,将数据放到0的位置上就可以了

2. 插入到末尾

点击这里查看大图
这里写图片描述

说明:1和2是一种情况,都是将数据直接添加到线性表的末尾。

3. 一般情况

点击这里查看大图
这里写图片描述

说明:简单来理解,就是腾出地方,然后插入。

移除数据

1. 末尾的数据移除

点击这里查看大图
这里写图片描述

说明:很简单,直接置空就可以了。

2.一般情况

点击这里查看大图
这里写图片描述

说明:跟插入的一般操作相反,先移除,再把坑填上。

Java代码实现及演示

实现代码

以下代码是一个简单的实现

//顺序存储结构
public class MyArray {
    //用来保存数据的数组
    private String[] arrs;
    //数组的默认大小
    private static final int DEFAULT_SIZE = 10;
    //数组的大小
    private int maxSize;
    //线性表的大小
    private int size;

    public MyArray() {
        this(DEFAULT_SIZE);
    }

    public MyArray(int size) {
        maxSize = size;
        arrs = new String[maxSize];
    }

    //往线性表中指定位置插入数据
    public void insert(int i, String str) {
        //1.参数校验
        if (i < 0) {
            throw new IllegalArgumentException("i不能小于0");
        }
        if (i > size) {
            throw new IllegalArgumentException("当前线性表的大小为" + size + ",i的最大值不能超过" + size + ",i目前是" + i);
        }

        //2.根据情况改变数组长度
        String[] newArrs;
        String[] oldArrs;
        if (size == maxSize) {
            //数组已经满了,需要改变长度
            oldArrs = arrs;
            newArrs = new String[(int) (maxSize * 1.5)];
            for (int j = 0; j < size; j++) {
                newArrs[j] = oldArrs[j];
            }
            maxSize = (int) (maxSize * 1.5);
            arrs = newArrs;
        }

        //3.插入到末尾的处理
        if (i == size) {
            arrs[i] = str;
            size++;
            look();
            return;
        }

        //3.移动位置
        for (int j = size; j > i; j--) {
            arrs[j] = arrs[j - 1];
        }

        //4.插入数据
        arrs[i] = str;
        size++;
        look();
    }

    //移除线性表指定位置上的数据
    public void remove(int i) {
        //1.参数校验
        if (i < 0) {
            throw new IllegalArgumentException("i不能小于0");
        }
        if (i >= size) {
            throw new IllegalArgumentException("当前线性表的大小为" + size + ",i的最大值不能大于等于" + size + ",i目前是" + i);
        }
        //2.移除
        arrs[i] = null;
        //3.末尾的处理
        if (i == size - 1) {
            size--;
            look();
            return;
        }
        //3.一般情况的处理
        for (int j = i; j < size - 1; j++) {
            arrs[j] = arrs[j + 1];
        }
        //4.最后一位置空
        arrs[size - 1] = null;
        size--;
        look();
    }

    //情况数据
    public void clear() {
        if (arrs != null) {
            for (int i = 0; i < size; i++) {
                arrs[i] = null;
            }
        }
        size = 0;
        look();
    }

    //查看数据
    private void look() {
        if (arrs != null) {
            System.out.println("");
            for (int i = 0; i < arrs.length; i++) {
                System.out.print(" " + arrs[i]);
            }
        }
    }
}

插入操作演示

public class Main {
    public static void main(String[] args) {
        MyArray array = new MyArray(4);
        array.insert(0,"1");
        array.insert(1,"2");
        array.insert(0,"3");
        array.insert(0,"4");
        array.insert(0,"5");
        array.insert(3,"6");
        array.insert(5,"7");
        array.insert(6,"8");
        array.insert(7,"9");
    }
}

结果:

 1 null null null
 1 2 null null
 3 1 2 null
 4 3 1 2
 5 4 3 1 2 null
 5 4 3 6 1 2
 5 4 3 6 1 7 2 null null
 5 4 3 6 1 7 8 2 null
 5 4 3 6 1 7 8 9 2

移除及清空代码演示

public class Main {
    public static void main(String[] args) {
        MyArray array = new MyArray(4);
        array.insert(0,"1");
        array.insert(1,"2");
        array.insert(2,"3");
        array.insert(3,"4");
        array.insert(4,"5");
        array.insert(5,"6");

        array.remove(5);
        array.remove(0);
        array.remove(1);

        array.clear();
    }
}

结果:

1 null null null
1 2 null null
1 2 3 null
1 2 3 4
1 2 3 4 5 null
1 2 3 4 5 6
1 2 3 4 5 null
2 3 4 5 null null
2 4 5 null null null
null null null null null null

结语

Java中,ArrayList已经进行了封装,我们直接使用就可以了。
点击这里查看ArrayList源码的相关理解

转载请标明出处:http://blog.youkuaiyun.com/qq_26411333/article/details/51809550

### Java 线性表数据结构设计与实现 #### 一、线性表概述 线性表是一种基本数据结构,其特点是元素之间存在一对一的关系。在线性表中,除了第一个和后一个元素外,其他每个元素都有唯一的一个前驱和后继。 #### 二、顺序实现 顺序表是线性表的一种存储方式,在内存中占用连续的空间来保存各个节点的信息。下面是一个简单的顺序表示例: ```java public class ArrayLinearList { private Object[] elements; private int size; public ArrayLinearList() { this.elements = new Object[10]; this.size = 0; } // 添加元素到列表末尾 public boolean add(Object element) { ensureCapacity(size + 1); elements[size++] = element; return true; } // 获取指定位置上的元素 public Object get(int index) { checkIndex(index, false); return elements[index]; } // 移除并返回指定索引处的元素 public Object remove(int index){ rangeCheck(index); Object oldValue = elements[index]; int numMoved = size - index - 1; if (numMoved > 0) System.arraycopy(elements, index+1, elements, index, numMoved); elements[--size] = null; // Let gc do its work return oldValue; } // 扩展数组容量以容纳更多元素 private void ensureCapacity(int minCapacity) { if(minCapacity >= elements.length){ @SuppressWarnings("unchecked") Object[] oldElements = elements; elements = new Object[Math.max(2 * elements.length,minCapacity)]; System.arraycopy(oldElements, 0, elements, 0,oldElements.length ); } } // 检查给定索引是否有效 private void checkIndex(int index,boolean isAddOperation){ if(isAddOperation &&index>size || !isAddOperation&&index>=size||index<0){ throw new IndexOutOfBoundsException(); } } } ``` 此代码展示了如何创建一个基于数组的顺序表类 `ArrayLinearList`[^1]。 #### 三、链表实现 链表也是一种常见的线性表实现形式,它由一系列结点组成,这些结点不必在物理上相邻存放在一起;而是通过指针链接起来形成逻辑上的序列关系。以下是单向链表的具体实现: ```java class Node<T>{ T data; Node next; public Node(T data){ this.data=data; this.next=null; } } public class SinglyLinkedList<T> { private Node head; private int length; public SinglyLinkedList(){ this.head=null; this.length=0; } // 向链表头部插入新节点 public void insertAtBeginning(T newData){ Node newNode=new Node(newData); newNode.next=head; head=newNode; length++; } // 删除头节点 public T deleteFromBeginning(){ if(head==null)return null; T temp=(T)(head.data); head=head.next; length--; return temp; } // 显示整个链表的内容 public String toString(){ StringBuilder sb=new StringBuilder("["); Node current=head; while(current!=null){ sb.append(current.data.toString()); if(current.next != null)sb.append(", "); current=current.next; } sb.append("]"); return sb.toString(); } } ``` 这段代码定义了一个泛型化的单向链表类 `SinglyLinkedList`, 并实现了几个常用的操作函数[^2]. 对于双向链表,则是在上述基础上增加了对前后两个方向的支持,即每个节点不仅有指向下一个节点的引用(`next`)还有指向前一个节点的引用(`prev`). 这样可以更方便地遍历链表以及执行某些特定操作. 后需要注意的是,无论是哪种类型的线性表,在实际应用过程中都需要考虑边界条件处理(比如越界访问)、异常情况下的健壮性和性能优化等问题.
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值