大话数据结构------线性表的顺序存储结构

线性表的顺序存储结构就是一组数据按照逻辑顺序依次排列在一组地址连续的储存空间

先贴上kotlin代码

package com.hefuwei.datastruct

import java.lang.RuntimeException
import java.lang.StringBuilder

@Suppress("UNCHECKED_CAST")
class ArrayList<T> {

    private var mData = Array<Any?>(16) {0}
    var size = 0
        private set

    /**
     * 获取指定位置的数据
     */
    fun get(index: Int): T {
        checkIndex(index)
        return mData[index] as T
    }

    /**
     * 设置指定位置的数据
     */
    fun set(index: Int, data: T) {
        checkIndex(index)
        mData[index] = data
    }

    /**
     * 给List添加一个元素，默认在尾部添加一个
     */
    @JvmOverloads
    fun add(index: Int = size, data: T) {
        checkIndex(index, size)
        ensureCapacity(size + 1)
        for (i in (size-1) downTo index) {
            mData[i+1] = mData[i]
        }
        mData[index] = data!!
        size++
    }

    /**
     * 删除指定位置的元素
     * tip: 要把内容置空，防止造成内存泄露
     */
    fun remove(index: Int) {
        checkIndex(index)
        for (i in (index+1)..(size-1)) {
            mData[i-1] = mData[i]
        }
        mData[--size] = null
    }

    /**
     * 删除所有的元素
     * tip: 要把内容置空，防止造成内存泄露
     */
    fun clear() {
        for (i in 0 until size) {
            mData[i] = null
        }
        size = 0
    }

    /**
     * 检查索引是否合法，默认检查0..(size-1)，添加元素时检查0..size
     */
    private fun checkIndex(index: Int, length: Int = size - 1) {
        if (index !in 0..length) {
            throw RuntimeException("out of range totalLength is $size index is $index")
        }
    }

    /**
     * 确保数组拥有足够的容量，如果不够那么扩大两倍
     */
    private fun ensureCapacity(needCapacity: Int) {
        if (needCapacity > mData.size) {
            println("expand capacity old capacity is ${mData.size} and new capacity is " +
                    "${mData.size * 2}")
            val copyArray = Array<Any?>(mData.size * 2) {0}
            System.arraycopy(mData, 0, copyArray, 0, mData.size)
            mData = copyArray
        }
    }

    override fun toString(): String {
        val sb = StringBuilder("[")
        for (i in 0..(size-1)) {
            if (i != 0) {
                sb.append(", ")
            }
            sb.append(mData[i])
        }
        sb.append("]")
        return sb.toString()
    }
}

• 顺序表数据元素的获取和设置比较简单就是直接修改数组对应下标的数据，时间复杂度为O(1)

• 顺序表的插入步骤add(i, data) 时间复杂度O(n)

  1. 判断插入位置是否正确，不正确就抛出异常
  2. 判断数组容量是否够，不够就扩容成原来的两倍
  3. 从最后一个元素开始到第i个元素依次向后移动一位
  4. 将要插入的元素插入到位置i处
  5. 表长加一

• 顺序表的删除步骤remove(i) 时间复杂度O(n)

  1. 判断删除位置是否正确，不正确就抛出异常
  2. 从第i+1个元素到最后一个元素依次向前移动一位
  3. 将原先的最后一个元素的值置为null
  4. 表长减一