顺序表(数组)实现

Posted guardwhy

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了顺序表(数组)实现相关的知识，希望对你有一定的参考价值。

1.1 基本介绍

顺序表是在计算机内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元，依次存储线性表中的各个元素、使得线性表中再逻辑结构上响铃的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

数组是最常见的顺序表，数组(Array)是有限个相同类型的变量所组成的有序集合，数组中的每一个变量被称为元素。数组是最为简单、最为常用的数据结构。

1.2 相关原理分析

1、基本概念

数组用一组连续的内存空间来存储一组具有相同类型的数据。

(模拟内存存储)灰色格子：被使用的内存，黄色格子：空闲的内存，蓝色格子：数组占用的内存

2、顺序表API设计

类名SqList
构造方法SqList(int capacity)：创建容量为capacity的SqList对象
成员方法1、public void clear()：清空所有元素。
2、public boolean isEmpty()：判断线性表是否为空，是返回true，否返回false。
3、public int size():获取线性表中元素的个数。
4、public E get(int index): 返回index位置对应的元素。
5、public void add(int index,E data)：在线性表的第i个元素之前插入一个值为t的数据元素。
6、public void add(E data):向线性表中添加一个元素t。
7、public E remove(int index): 删除index位置对应的元素。
8、public int indexOf(E e): 返回线性表中首次出现的指定的数据元素的位序号，若不存在，则返回-1。
9、boolean contains(E data)：是否包含某个元素。
10、public E set(int index, E data)：设置index位置的元素
成员变量1、private E[] data：存储元素的数组。
2、private int size:当前线性表的长度。

1.3 添加元素

1、尾部插入

在数据的实际元素数量小于数组长度的情况下：直接把插入的元素放在数组尾部的空闲位置即可，等同于更新元素的操作。

直接在索引(index = 6)的位置上添加元素10

2、通过数组下标插入

在数据的实际元素数量小于数组长度的情况下：
由于数组的每一个元素都有其固定下标，所以首先把插入位置及后面的元素向后移动腾出地方，再把要插入的元素放到对应的数组位置上。

3、代码实现

顺序表：SqList

package cn.liner.demo01;

public class SqList
    // 顺序表的元素
    private int[] data;
    // 顺序表元素的数量
    private int size;

    // 构造函数，传入数组的容量capacity构造SqList
    public SqList(int capacity)
        data = new int[capacity];
        size = 0;
    

    // 无参数的构造函数，默认数组的容量capacity=10
    public SqList()
        this(10);
    

    // 获取数组的容量
    public int getCapacity()
        return data.length;
    

    // 获取数组中的元素个数
    public int getSize()
        return size;
    

    // 返回数组是否为空
    public boolean isEmpty()
        return size == 0;
    

    // 向所有元素后添加一个新元素
    public void addLast(int e)
        add(size, e);
    

    // 在所有元素前添加一个新元素
    public void addFirst(int e)
        add(0, e);
    

    // 在index索引的位置插入一个新元素e
    public void add(int index, int e)

        if(size == data.length)
            throw new IllegalArgumentException("数组已满，添加失败！！");
        

        if(index < 0 || index > size)
            throw new IllegalArgumentException("添加失败，索引值不符合添加范围！！");
        

        for(int i = size - 1; i >= index ; i --)
            data[i + 1] = data[i];
        

        data[index] = e;
        size ++;
    

    @Override
    public String toString()
        StringBuilder res = new StringBuilder();
        res.append(String.format("顺序表(SqList)长度:%d, 容器:%d\\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i ++)
            res.append(data[i]);
            if(i != size - 1)
                res.append(", ");
        
        res.append(']');
        return res.toString();

测试类：SqListDemo01

package cn.liner.demo01;
/**
 * 顺序表测试类
 */
public class SqListDemo01 
    public static void main(String[] args) 
        //1.1 创建顺序表对象
        SqList list = new SqList(20);
        for (int i = 0; i < 10; i++)
            list.addLast(i);
        System.out.println(list);
        System.out.println("=====");

        list.add(1, 100);
        System.out.println(list);
        System.out.println("=====");

        list.addFirst(-1);
        System.out.println(list);

3、执行结果

1.4 查询和修改元素

1、代码实现

顺序表：SqList

package cn.liner.demo01;

public class SqList
    // 顺序表的元素
    private int[] data;
    // 顺序表元素的数量
    private int size;

    // 构造函数，传入数组的容量capacity构造SqList
    public SqList(int capacity)
        data = new int[capacity];
        size = 0;
    

    // 无参数的构造函数，默认数组的容量capacity=10
    public SqList()
        this(10);
    

    // 获取数组的容量
    public int getCapacity()
        return data.length;
    
    // 获取index索引位置的元素
    public int get(int index)
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("获取失败！！该索引值不存在！！");
        return data[index];
    

    // 修改index索引位置的元素为e
    public void set(int index, int e)
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("设置失败，该索引值不存在");
        
        data[index] = e;
    

    // 查找数组中是否有元素e
    public boolean contains(int e)
        for(int i = 0 ; i < size ; i ++)
            if(data[i] == e)
                return true;
        
        return false;
    

    // 查找数组中元素e所在的索引，如果不存在元素e，则返回-1
    public int find(int e)
        for(int i = 0 ; i < size ; i ++)
            if(data[i] == e)
                return i;
        
        return -1;
    

    @Override
    public String toString()
        StringBuilder res = new StringBuilder();
        res.append(String.format("顺序表(SqList)长度:%d, 容器:%d\\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i ++)
            res.append(data[i]);
            if(i != size - 1)
                res.append(", ");
        
        res.append(']');
        return res.toString();

测试类：SqListDemo01

package cn.liner.demo01;
/**
 * 顺序表测试类
 */
public class SqListDemo01 
    public static void main(String[] args) 
        //1.1 创建顺序表对象
        SqList list = new SqList(20);
        System.out.println("===顺序表添加===");
        for (int i = 0; i < 10; i++)
            list.addLast(i);
        
        System.out.println(list);
        System.out.println("===顺序表(获取索引位置的元素)===");
        int index = list.get(2);
        System.out.println("查找到的元素是:" +index);

        System.out.println("===顺序表(修改索引位置的元素)===");
        list.set(3,100);
        System.out.println(list);

        System.out.println("===顺序表(查找数组中是否有该元素)===");
        boolean flag = list.contains(4);
        System.out.println("是否存在:" + flag);

        System.out.println("===顺序表(查找数组中元素e所在的索引)===");
        int i = list.find(100);
        System.out.println(i);

2、执行结果

1.5 删除元素

1、代码实现

顺序表：SqList

package cn.liner.demo01;

public class SqList
    // 顺序表的元素
    private int[] data;
    // 顺序表元素的数量
    private int size;

    // 构造函数，传入数组的容量capacity构造SqList
    public SqList(int capacity)
        data = new int[capacity];
        size = 0;
    

    // 无参数的构造函数，默认数组的容量capacity=10
    public SqList()
        this(10);
    

    // 获取数组的容量
    public int getCapacity()
        return data.length;
    

    // 从数组中删除index位置的元素, 返回删除的元素
    public int remove(int index)
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("移除失败，索引值不存在！！！");
        
        int ret = data[index];
        for(int i = index + 1 ; i < size ; i ++)
            data[i - 1] = data[i];
        

        size --;
        return ret;
    

    // 从数组中删除第一个元素, 返回删除的元素
    public int removeFirst()
        return remove(0);
    

    // 从数组中删除最后一个元素, 返回删除的元素
    public int removeLast()
        return remove(size - 1);
    

    // 从数组中删除元素e
    public void removeElement(int e)
        int index = find(e);
        if(index != -1) 
            remove(index);
        
    

    @Override
    public String toString()
        StringBuilder res = new StringBuilder();
        res.append(String.format("顺序表(SqList)长度:%d, 容器:%d\\n", size, data.length));
        res.append('[');
        for(int i = 0 ; i < size ; i ++)
            res.append(data[i]);
            if(i != size - 1)
                res.append(", ");
        
        res.append(']');
        return res.toString();

测试类：SqListDemo01

package cn.liner.demo01;
/**
 * 顺序表测试类
 */
public class SqListDemo01 
    public static void main(String[] args) 
        //1.1 创建顺序表对象
        SqList list = new SqList(20);
        System.out.println("===顺序表添加===");
        for (int i = 0; i < 10; i++)
            list.addLast(i);
        
        System.out.println(list);
        System.out.println("===删除元素操作====");
        // 从数组中删除index位置的元素
        list.remove(2);
        System.out.println(list);
        // 从数组中删除元素e
        list.removeElement(4);
        System.out.println(list);
         // 删除第一个元素
        list.removeFirst();
        System.out.println(list);
        // 从数组中删除最后一个元素
        list.removeLast();
        System.out.println(list);

3、执行结果

1.6 泛型技术

使用泛型技术可以让数组更加通用，可以存放任何数据类型。

1、代码实现

顺序表：SqList

package cn.liner.demo01;

import java.util.Iterator;

public class SqList<E> implements Iterable<E>
    // 顺序表的元素
    private E[] data;
    // 顺序表元素的数量
    private int size;

    // 定义常量
    private static final int ELEMENT_NOT_FOUND = -1;

 	 // 构造函数，传入数组的容量capacity构造SqList
    public SqList(int capacity)
        data = (E[]) new Object[capacity];
        size = 0;
    

    // 无参数的构造函数，默认数组的容量capacity=10
    public SqList()
        this(10);
    

    // 获取数组的容量
    public int getCapacity()
        return data.length;
    

    // 获取数组中的元素个数
    public int getSize()
        return size;
    

    // 返回数组是否为空
    public boolean isEmpty()
        return size == 0;
    

    // 向所有元素后添加一个新元素
    public void addLast(E e)
        add(size, e);
    

    // 在所有元素前添加一个新元素
    public void addFirst(E e)
        add(0, e);
    

    // 在index索引的位置插入一个新元素e
    public void add(int index, E e)

        if(size == data.length)
            throw new IllegalArgumentException("数组已满，添加失败！！");
        

        for(int i = size - 1; i >= index ; i --)顺序表(数组)实现


 数据结构顺序表—纯C实现顺序表


 ❤❤❤❤顺序表的实现（c语言）----数据结构


 ❤❤❤❤顺序表的实现（c语言）----数据结构


 ❤❤❤❤顺序表的实现（c语言）----数据结构


 Java语言 建立含有n个元素的顺序表，实现插入、删除操作，同时length表示数组容量。（数据结构）