数据结构——顺序表

本是古典何须时尚 2024-03-30 13:38 66阅读 0赞

#### 文章目录 ####

*  1.线性表
 *   *  1.1定义
 *  2.顺序表
 *   *  2.1 基本介绍
     *  2.2 代码实现

## 1.线性表 ##

### 1.1定义 ###

1.线性表是具有n个相同特性的数据元素的有限序列，线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列…  
2.线性表在逻辑上是线性结构，但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组（顺序存储）和链表（链式结构）的形式存储。

## 2.顺序表 ##

### 2.1 基本介绍 ###

1.顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。  
2.缺点：插入删除元素时需要挪动元素，复杂度O(n)。  
顺序表适用于，给定下标查找元素，不适合频繁对数据进行插入删除。

### 2.2 代码实现 ###

package demo2;
    
    import demo2.IndexOutOfExpetion;
    
    import java.util.Arrays;
    
    /**
     * @author zq
     * 自定义顺序表，底层是数组形式存储
     */
    public class MyArrayList {
        public int[] elem;
        public int usedSize;//存储了多少个有效数据
        public static final int DEFAULT_SIZE = 10;
    
        public MyArrayList(){
            this.elem = new int[DEFAULT_SIZE];
        }
    
    // 新增元素,默认在数组最后新增（考虑数组容量问题，用Arrays.copyOf()
        public void add(int data) {
            if (this.isFull()){
                this.resize();
            }
            this.elem[this.usedSize] = data;
            this.usedSize++;
    
        }
    
        //判断是否为满
        public boolean isFull(){
            return this.usedSize == elem.length;
        }
    
        //扩容方法，封装为private
        private void resize(){
            this.elem = Arrays.copyOf(this.elem,2*this.usedSize);
        }
    
        //在pos位置添加元素（重载添加元素方法）
        //存在pos是否合法的问题
        public void add(int pos, int data) {
           checkAddIndex(pos);
           if (isFull()){
               this.resize();
           }
    
           for (int i = usedSize - 1; i >= pos ; i--) {
               elem[i+1] = elem[i];
    
           }
           elem[pos] = data;
           usedSize ++;
        }
        /*检查插入元素，pos位置是否合法
        @param pos
         */
        private void checkAddIndex(int pos){
            //顺序表连续，不能大于usedSize
            if (pos < 0 || pos > usedSize) {
                throw new IndexOutOfExpetion("add元素是位置不合法");
            }
        }
    
        // 判定是否包含某个元素
        public boolean contains(int toFind) {
            for (int i = 0; i < this.usedSize; i++) {
                if (toFind == this.elem[i]){
                    return true;
                }
            }
            return false;
        }
    
        // 查找某个元素对应的位置
        public int indexOf(int toFind) {
            for (int i = 0; i < this.usedSize; i++) {
                if (toFind == this.elem[i]){
                    return i;
                }
            }
            return -1;
        }
    
        // 获取 pos 位置的元素
        public int get(int pos) {
            checkGetIndex(pos);
            return elem[pos];
        }
        /*
        检查获取元素时，pos的合法性
         */
        private void checkGetIndex(int pos){
            throw new IndexOutOfExpetion("get元素时不合法");
        }
    
    
        // 给 pos 位置的元素设为 value
        public void set(int pos, int value) {
            checkGetIndex(pos);
            elem[pos] = value;
    
        }
    
        //删除第一次出现的关键字key
        public boolean remove(int toRemove) {
            int index = indexOf(toRemove);
            if (index == -1){
                System.out.println("没有这个数据");
                return false;
            }
            for (int i = index; i < usedSize -1; i++) {
                elem[i] = elem[i+1];
            }
            usedSize--;
            //如果是引用类型则需要手动置空
            //elem[usedSize] = null;
            elem[usedSize] = 0;
            return true;
    
        }
    
        // 获取顺序表长度
        public int size() {
            return this.usedSize;
        }
    
        // 清空顺序表
        public void clear() {
            //引用数据类型需要全部置空
    //        for (int i = 0; i < usedSize; i++) {
    //            elem[i] = null;
    //        }
    //        usedSize = 0;
            usedSize = 0;
    
    
        }
    
        // 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
        public void display() {
            for (int i = 0; i < this.usedSize; i++) {
                System.out.println(elem[i]);
    
            }
        }
    }