數據結構-JAVA實現數組

時間  2020-11-30
標籤 git 數組 數據結構 app ide 函數 this spa code 欄目 Java 简体版
原文   原文鏈接

這篇文章是展現如何使用JAVA語言實現Array這種數據結構。git

​1.整型數組的實現

public class Array {
    private int[] data;
    private int size;
    /**
     * 構造函數，傳入數組的容量 capacity 構造 Array
     * @param capacity
     */
    public Array(int capacity){
        data = new int[capacity];
        size = 0;
    }
    /**
     * 無參數的構造函數，默認數組的容量 capacity = 10
     */
    public Array(){
        this(10);
    }
    /**
     * 獲取數組大小
     * @return
     */
    public int getSize(){
        return size;
    }
    /**
     * 獲取數組容量
     * @return
     */
    public int getCapacity(){
        return data.length;
    }
    /**
     * 返回數組是否爲空
     * @return
     */
    public boolean isEmpty(){
        return size == 0;
    }
    /**
     * 向數組末尾添加元素
     * @param num
     */
    public void addLast(int num){
        addIndex(size,num);
    }
    /**
     * 向數組開頭添加元素
     * @param num
     */
    public void addFirst(int num){
        addIndex(0,num);
    }
    /**
     * 向數組指定位置添加元素
     */
    public void addIndex(int index,int num){
        if(size == data.length || index > size || index < 0)
            throw new IllegalArgumentException("容量滿了或索引位置超出範圍");
        for(int i = size - 1;i >= index;i--){
            data[i+1] = data[i];
        }
        data[index] = num;
        size++;
    }
    /**
     * 獲取數組中元素
     * @param index
     * @return
     */
    public int getIndex(int index){
        if(index < 0 || index > size - 1)
            throw new IllegalArgumentException("索引超出範圍");
        return data[index];
    }
    /**
     * 判斷數組中是否存在某個元素
     * @param num
     * @return
     */
    public boolean isset(int num){
        for (int i = 0;i < size;i++){
            if(data[i] == num)
                return true;
        }
        return false;
    }
    /**
     * 查找數組中某個值第一次出現的索引
     * @param num
     * @return
     */
    public int find(int num){
        for(int i = 0;i < size;i++){
            if(data[i] == num)
                return i;
        }
        return -1;
    }
    public void findAll(int num){
        int n = 0; //統計data 數組中的 num 的個數
        for (int i = 0;i < size;i++){
            if (data[i] == num)
                n++;
        }
        for (int k = 0;k < n;k++){
            int index = find(num);
           unset(index);
        }
    }
    /**
     * 刪除指定位置的元素
     * @param index
     */
    public int unset(int index){
        if(index < 0 || index > size - 1){
            throw new IllegalArgumentException("索引超出範圍");
        }
        int res = data[index];
        for(int i = index;i < size;i++){
            data[i] = data[i+1];
        }
        size--;
        return res;
    }
    /**
     * 刪除數組中第一個元素
     * @return
     */
    public int unsetFirst(){
      return unset(0);
    }
    /**
     * 刪除數組中最後一個元素
     * @return
     */
    public int unsetLast(){
        return unset(size-1);
    }
    /**
     * 刪除數組中某個值
     * @param num
     */
    public void filterNum(int num){
        int index = find(num);
        unset(index);
    }
    public void filterAllNum(){
    }
    /**
     * 獲取數組信息
     * @return
     */
    @Override
    public String toString(){
        StringBuilder res = new StringBuilder();
        res.append(String.format("Array:size = %d,capacity = %dn",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();
    }
}

2.泛型數組的實現

public class Array<genarr> {
    private genarr[] data;
    private int size;
    /**
     * 構造函數，傳入數組的容量 capacity 構造 Arrayaa
     *
     * @param capacity
     */
    public Array(int capacity) {
        data = (genarr[]) new Object[capacity];
        size = 0;
    }
    /**
     * 無參數的構造函數，默認數組的容量 capacity = 10
     */
    public Array() {
        this(10);
    }
    /**
     * 獲取數組大小
     *
     * @return
     */
    public int getSize() {
        return size;
    }
    /**
     * 獲取數組容量
     *
     * @return
     */
    public int getCapacity() {
        return data.length;
    }
    /**
     * 返回數組是否爲空
     *
     * @return
     */
    public boolean isEmpty() {
        return size == 0;
    }
    /**
     * 向數組末尾添加元素
     *
     * @param num
     */
    public void addLast(genarr num) {
        addIndex(size, num);
    }
    /**
     * 向數組開頭添加元素
     *
     * @param num
     */
    public void addFirst(genarr num) {
        addIndex(0, num);
    }
    /**
     * 向數組指定位置添加元素
     */
    public void addIndex(int index, genarr num) {
        if (index > size || index < 0)
            throw new IllegalArgumentException("容量滿了或索引位置超出範圍");
        if (size == data.length)
            resize(2 * data.length);
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = num;
        size++;
    }
    private void resize(int newCapacity) {
        genarr[] newData = (genarr[]) new Object[newCapacity];
        for(int i=0;i < size;i++)
            newData[i] = data[i];
        data = newData;
    }
    /**
     * 獲取數組中元素
     *
     * @param index
     * @return
     */
    public genarr getIndex(int index) {
        if (index < 0 || index > size - 1)
            throw new IllegalArgumentException("索引超出範圍");
        return data[index];
    }
    public genarr getLast(){
        return getIndex(size - 1);
    }
    /**
     * 判斷數組中是否存在某個元素
     *
     * @param num
     * @return
     */
    public boolean isset(genarr num) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(num))
                return true;
        }
        return false;
    }
    /**
     * 查找數組中某個值第一次出現的索引
     *
     * @param num
     * @return
     */
    public int find(genarr num) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(num))
                return i;
        }
        return -1;
    }
    public void findAll(genarr num) {
        int n = 0; //統計data 數組中的 num 的個數
        for (int i = 0; i < size; i++) {
            if (data[i].equals(num))
                n++;
        }
        for (int k = 0; k < n; k++) {
            int index = find(num);
            unset(index);
        }
    }
    /**
     * 刪除指定位置的元素
     *
     * @param index
     */
    public genarr unset(int index) {
        if (index < 0 || index > size - 1) {
            throw new IllegalArgumentException("索引超出範圍");
        }
        genarr res = data[index];
        for (int i = index; i < size - 1; i++) {
            data[i] = data[i + 1];
        }
        size--;
        data[size] = null;  //loitering objects ! =memory
        /** 若當前數組大小，小於容量的一半，則從新分配一半的數組空間大小 **/
        if(size <= data.length / 4 && data.length > 1){
            int leng;
            if(data.length % 2 == 0){
                resize(data.length / 2);
            }else{
                resize((data.length + 1) / 2);
            }
        }
        return res;
    }
    /**
     * 刪除數組中第一個元素
     *
     * @return
     */
    public genarr unsetFirst() {
        return unset(0);
    }
    /**
     * 刪除數組中最後一個元素
     *
     * @return
     */
    public genarr unsetLast() {
        return unset(size - 1);
    }
    /**
     * 刪除數組中某個值
     *
     * @param num
     */
    public void filterNum(genarr num) {
        int index = find(num);
        unset(index);
    }
    public void filterAllNum() {
    }
    /**
     * 獲取數組信息
     *
     * @return
     */
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        res.append(String.format("Arrayaa:size = %d,capacity = %dn", 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();
    }
}

3.Main

public class Main {
    public static void main(String[] args) {
        Array arrayStruct = new Array(10);
 arrayStruct.addLast(1);
 arrayStruct.addLast("aa");
 arrayStruct.addLast(1);
 arrayStruct.addLast("cc");
 arrayStruct.addFirst("cc");
 arrayStruct.addLast(100);
 arrayStruct.addLast("aa");
 arrayStruct.addLast("aa");
 arrayStruct.addLast("aa");
 arrayStruct.addLast("aa");
 arrayStruct.addLast("aa");
 arrayStruct.addLast("aa");
 arrayStruct.addLast("aa");
 arrayStruct.addFirst("ss");
 arrayStruct.addFirst("nn");
 arrayStruct.addFirst("mm");
 System.out.println(arrayStruct.toString());
 //打印結果 [mm,nn,ss,cc,1,aa,1,cc,100,aa,aa,aa,aa,aa,aa,aa] }
}

以下圖所示：
image.png數組

4.簡單的複雜度分析

4.1 添加操做

addLast(num)   O(1)
addFirst(num)  O(n)
addIndex(index，num)  O(n)   嚴格計算須要一些機率論知識
resize(size)  O(n)

4.2 刪除操做

unsetLast(num)   O(1)
unsetFisrt()     O(n)
unset(index，num)   O(n/2) = O(n)
resize(size)  O(n)

4.3 查找操做

getIndex(index)    O(1)
isset(num)          O(n)
find(num)            O(n)

4.4 均攤複雜度

addLast(num)    O(1)
resize()   O(n)
上述兩個組合在一塊兒均攤在一塊兒複雜度至關於 O(1)

4.5 防止複雜度的震盪

addLast(num)   O(1)
resize    O(n)
unsetLast(num)    O(1)
Tips:當容量滿了的時候可能存在一直觸發 resize() ，使得時間複雜度變爲 O(n)，這種狀況稱爲複雜度震盪，解決辦法是，當 size 小於等於 1/4 容量的時候才縮小容量。

代碼倉庫 ：https://gitee.com/love-for-po...數據結構

掃碼關注愛因詩賢
​app

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程