数据结构之数组底层代码

最新推荐文章于 2022-10-18 15:22:08 发布
最新推荐文章于 2022-10-18 15:22:08 发布
阅读量962 收藏 2
点赞数 1
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43184636/article/details/87202551
版权

 1.整型数组

1)数组的插入、删除、按照下标随机访问操作
2）数组中的数据时Int类型的

package array;
/**
 * 1)数组的插入、删除、按照下标随机访问操作
 * 2）数组中的数据时Int类型的
 *
 */
public class Array {
	//定义保存整型数据data的数组
	private int[] data;
	//定义数组的长度
	private int n;
	//定义数组中元素的个数
	private int count;
	
	//构造方法，定义数组大小
	public Array(int capacity){
		this.data=new int[capacity];
		this.n=capacity;
		this.count=0;//一开始一个数据都没有
	}
	
	//根据索引，找到数据中的元素并返回
	public int find(int index){
		if(index<0 || index>=count)
			return -1;
		return data[index];
	}
	
	//插入元素：头部插入,尾部插入
	public boolean insert(int index,int value){
		//位置不合法
		if(index<0 || index>count){
			System.out.println("插入位置不合法");
			return false;
		}
		//数组为空
//		if(index==count && count==0){
//			data[index]=value;
//			++count;
//			return true;
//		}
		//数组空间已满
		if(count==n){
			System.out.println("空间已满");
			return false;
		}
		//数组空间未满,位置合法
		//将插入位置之后的数据向后搬移一位
		for(int i=count;i>index;--i){
			data[i]=data[i-1];
		}
		data[index]=value;
		++count;
		return true;
	}
	
	//根据索引,删除数组中元素
	public boolean delete(int index){
		if(index<0 || index>=count) return false;
		//位置合法
		//将删除位置之后的元素向前移动一位
		for(int i=index+1;i<count;++i){
			data[i-1]=data[i];
		}
		--count;
		return true;
	}
	
	public void printAll(){
		for(int i=0;i<count;++i){
			System.out.print(data[i]+" ");
		}
		System.out.println();
	}
	
	public static void main(String[] args) {
		Array array=new Array(5);
		array.printAll();
		array.insert(0, 3);
		array.insert(0, 4);
		array.insert(1, 5);
		array.insert(3, 8);
		array.insert(3, 10);
		array.delete(3);
		array.insert(3, 11);
		array.printAll();
	}
}

2.不确定类型数组GenericArray

package array;

public class GenericArray<T> {
	private T[] data;
    private int size;

    // 根据传入容量，构造Array
    @SuppressWarnings("unchecked")
	public GenericArray(int capacity) {
        data = (T[]) new Object[capacity];
        size = 0;
    }

    // 无参构造方法，默认数组容量为10
    public GenericArray() {
        this(10);
    }

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

    // 获取当前元素个数
    public int count() {
        return size;
    }

    // 判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    // 修改 index 位置的元素
    public void set(int index, T e) {
        checkIndex(index);
        data[index] = e;
    }

    // 获取对应 index 位置的元素
    public T get(int index) {
        checkIndex(index);
        return data[index];
    }

    // 查看数组是否包含元素e
    public boolean contains(T e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    // 获取对应元素的下标, 未找到，返回 -1
    public int find(T e) {
        for ( int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }


    // 在 index 位置，插入元素e, 时间复杂度 O(m+n)
    public void add(int index, T e) {
        checkIndex(index);
        // 如果当前元素个数等于数组容量，则将数组扩容为原来的2倍
        if (size == data.length) {
            resize(2 * data.length);
        }

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

    // 向数组头插入元素
    public void addFirst(T e) {
        add(0, e);
    }

    // 向数组尾插入元素
    public void addLast(T e) {
        add(size, e);
    }

    // 删除 index 位置的元素，并返回
    public T remove(int index) {
        checkIndexForRemove(index);

        T ret = data[index];
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size --;
        data[size] = null;

        // 缩容
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }

        return ret;
    }

    // 删除第一个元素
    public T removeFirst() {
        return remove(0);
    }

    // 删除末尾元素
    public T removeLast() {
        return remove(size - 1);
    }

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

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array size = %d, capacity = %d \n", size, data.length));
        builder.append('[');
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i != size - 1) {
                builder.append(", ");
            }
        }
        builder.append(']');
        return builder.toString();
    }


    // 扩容方法，时间复杂度 O(n)
    private void resize(int capacity) {
        T[] newData = (T[]) new Object[capacity];

        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        data = newData;
    }

    private void checkIndex(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed! Require index >=0 and index <= size.");
        }
    }

    private void checkIndexForRemove(int index) {
        if(index < 0 || index >= size) {
            throw new IllegalArgumentException("remove failed! Require index >=0 and index < size.");
        }
    }
}

3.基于数组实现LRU缓存

package linkedlist;

import java.util.HashMap;
import java.util.Map;
/**
 * Created by SpecialYang in 2018/12/7 2:00 PM.
 *
 * 基于数组实现的LRU缓存
 * 1. 空间复杂度为O(n)
 * 2. 时间复杂度为O(n)
 * 3. 不支持null的缓存
 */
public class LRUBasedArray<T> {
	private static final int DEFAULT_CAPACITY = (1 << 3);

    private int capacity;

    private int count;

    private T[] value;

    private Map<T, Integer> holder;

    public LRUBasedArray() {
        this(DEFAULT_CAPACITY);
    }

    public LRUBasedArray(int capacity) {
        this.capacity = capacity;
        value = (T[]) new Object[capacity];
        count = 0;
        holder = new HashMap<T, Integer>(capacity);
    }

    /**
     * 模拟访问某个值
     * @param object
     */
    public void offer(T object) {
        if (object == null) {
            throw new IllegalArgumentException("该缓存容器不支持null!");
        }
        Integer index = holder.get(object);
        if (index == null) {
            if (isFull()) {
                removeAndCache(object);
            } else {
                cache(object, count);
            }
        } else {
            update(index);
        }
    }

    /**
     * 若缓存中有指定的值，则更新位置
     * @param end
     */
    public void update(int end) {
        T target = value[end];
        rightShift(end);
        value[0] = target;
        holder.put(target, 0);
    }

    /**
     * 缓存数据到头部，但要先右移
     * @param object
     * @param end 数组右移的边界
     */
    public void cache(T object, int end) {
        rightShift(end);
        value[0] = object;
        holder.put(object, 0);
        count++;
    }

    /**
     * 缓存满的情况，踢出后，再缓存到数组头部
     * @param object
     */
    public void removeAndCache(T object) {
        T key = value[--count];
        holder.remove(key);
        cache(object, count);
    }

    /**
     * end左边的数据统一右移一位
     * @param end
     */
    private void rightShift(int end) {
        for (int i = end - 1; i >= 0; i--) {
            value[i + 1] = value[i];
            holder.put(value[i], i + 1);
        }
    }

    public boolean isContain(T object) {
        return holder.containsKey(object);
    }

    public boolean isEmpty() {
        return count == 0;
    }

    public boolean isFull() {
        return count == capacity;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < count; i++) {
            sb.append(value[i]);
            sb.append(" ");
        }
        return sb.toString();
    }

    static class TestLRUBasedArray {

        public static void main(String[] args) {
            testDefaultConstructor();
            testSpecifiedConstructor(4);
//            testWithException();
        }

        private static void testWithException() {
            LRUBasedArray<Integer> lru = new LRUBasedArray<Integer>();
            lru.offer(null);
        }

        public static void testDefaultConstructor() {
            System.out.println("======无参测试========");
            LRUBasedArray<Integer> lru = new LRUBasedArray<Integer>();
            lru.offer(1);
            lru.offer(2);
            lru.offer(3);
            lru.offer(4);
            lru.offer(5);
            System.out.println(lru);
            lru.offer(6);
            lru.offer(7);
            lru.offer(8);
            lru.offer(9);
            System.out.println(lru);
        }

        public static void testSpecifiedConstructor(int capacity) {
            System.out.println("======有参测试========");
            LRUBasedArray<Integer> lru = new LRUBasedArray<Integer>(capacity);
            lru.offer(1);
            System.out.println(lru);
            lru.offer(2);
            System.out.println(lru);
            lru.offer(3);
            System.out.println(lru);
            lru.offer(4);
            System.out.println(lru);
            lru.offer(2);
            System.out.println(lru);
            lru.offer(4);
            System.out.println(lru);
            lru.offer(7);
            System.out.println(lru);
            lru.offer(1);
            System.out.println(lru);
            lru.offer(2);
            System.out.println(lru);
        }
    }
}

 

摸鱼大侠
关注
专栏目录
【数据结构】数组：如何实现基于索引的查找
Robin的博客
08-27 831
由于数组中没有栈和队列那样对于线性表的限制，所以增删查操作变得灵活很多，代码实现的方法也更多样，所以我们要根据实际需求选择适合的方法进行操作。在实际操作中，我们还要注意根据数组的优缺点合理区分数组和链表的使用。数组定义简单，访问方便，但在数组中所有元素类型必须相同，数组的最大长度必须在定义时给出，数组使用的内存空间必须连续等。相对而言，数组更适合在数据数量确定，即较少甚至不需要使用新增数据、删除数据操作的场景下使用，这样就有效地规避了数组天然的劣势。...
数据结构-数组代码实现(C语言)
最新发布
A2423624364的博客
11-03 395
【代码】数据结构-数组代码实现(C语言)
ArrayList底层代码
阳哥的博客
09-09 265
1、首先我们创建一个ArrayList数组 ArrayList a=new ArrayList(); 2、点到底层后，发现我们需要的属性： transient Object[] elementData; // non-private to simplify nested class access 这是一个瞬态对象的元素数据、非私有以简化嵌套类访问 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}
java数据结构03_ArrayList底层源码实现（数组）
安德的博客
02-27 238
ArrayList是基于数组实现的，是一个动态数组，其容量能自动增长，类似于C语言中的动态申请内存，动态增长内存。 特点：查询效率高，增删效率低，线程不安全。 查看源码，我们可以看出ArrayList底层使用Object数组来存储元素数据。所有的方法，都围绕这个核心的Object数组来开展。 对ArrayList的操作，其实就是对数组的操作，下面我们来分析ArrayList的底层实现： 私有属...
数据结构之数组代码实现
孤岛的鲸
02-25 451
数据结构之数组代码实现 package com.algorithm.array; /** * @author ：Vimonster * @date： 2019-12-04 22:58:13 * @slogan: 任时间再怎样低头呢喃，也要不挥泪后风雨兼程 * @description: * 数据结构之数据组实现 **/ public class ArrayImpl { ...
数据结构：浅谈数组(代码主要以Java形式展开)
pickLing_的博客
04-21 422
有过代码基础的同学应该都知道：数组是任何一门编程中语最基本的数据结构，可以说数组几乎能表示一切数据结构。其中的重要性不必我多说。每种语言对数组的处理也是有着不同的处理，但是其本质还是对数据的存放，这一点是毋庸置疑的。 先说一下数组的简单声明，每一种编程语言对数组的声明也有着细微的区别，在这里我们主要说的是Java。在Java中，数组的声明主要有两种： 第一种： 数据类型 [] 数组名 = new ...
JavaScript数据结构之数组的表示方法示例
10-20
数据结构中的数组通常具有固定大小且不支持动态增删，而JavaScript数组虽然在底层可能实现为类似数据结构，但其在编程语言层面提供了更多的灵活性和便利性。 总之，JavaScript数组是一种强大的工具，它结合了数据...
学习数据结构——数组的底层实现
BeHappy2333的博客
09-02 2808
简单的记录一下学习数据结构的过程与心得，也算是对知识再进行一次整理和复习 数据结构：数组 一、实现内容： 1.Array类里面实现的众多数组的基本操作，包括增、删、查、改等方法； 2.main函数里面完成了对Array方法的测试，并通过println显示测试结果； 3.补充了动态数组以及泛型的方法，使得功能更加全面。 二、代码 1、Array类，数组底层，实现了数组的增删改查以及动态数组。 pub...
陈越老师《数据结构》第二版所有程序源代码
09-08
陈越老师的《数据结构》第二版是一本深受学生和专业人士欢迎的教材，其配套的源代码为学习者提供了实践和理解数据结构算法的宝贵资源。在这个压缩包中，包含了书中的所有程序源代码，分为.txt（伪代码）和.c（C语言...
数据结构 数组
03-31
数据结构 数组源代码 程序 数组的使用
自己的底层代码库（十六）——数组模板
zilaishuichina的专栏
07-09 1432
这里放上一个数组模板，主要是封装了一下一维数组，和二维数组的
数据结构——数组长代码实现
君陌的博客
11-22 225
此为本人在学习数据结构时将所学所想进行代码实现后所写成的代码，功能均能实现，仅供参考学习 #include <iostream> #include <iomanip> #include <assert.h> using namespace std; template <typename E>class list{ private: void ope...
数据结构数组
成长日记的博客
05-21 627
数组就是把数据码成一排进行存放 数组有可遍历、可迭代的特性，可以用foreach来实现 数组的最大优点是能快速查询 我们的索引有两种情况：有语意、无语意 我们在插入中间元素的时候把插入位置之后的数字往后移一位的时候我们插入位置的元素实际上还是存着原来的数字，我们往后移的不是空间而是数字的副本。 package www.zxx; public class Array { priva...
底层实现数据结构：动态数组、链表、栈、队列
ChanYipFan的博客
04-12 647
public class LinkedList<E> { private class Node { //内部类 public E e; public Node next; public Node(E e, Node next) { this.e = e; this....
数据结构 - 数组
如图所示
10-18 388
第四章 数组
数据结构之数组
hty46565的博客
10-29 645
数组的三种操作时间复杂度 按下标随机查找时间复杂度：O(1) 插入时间复杂度：O(n) 删除时间复杂度：O(n) 查找操作 因为数组是一种线性表数据结构，它用一组连续的内存空间，来存储一组具有相同类型的数据。所以，我们在通过下标i查找某个元素的时候，通过计算a[i]_address = base_address + i * data_type_size就可以查到该元素的偏移地址了。因为只需要经过有...
数据结构自学——（1）数组的代码实现
qq_40945225的博客
06-26 277
#include<stdio.h> #include<malloc.h> #include<stdlib.h> //包含了exit函数 //1.第一步我们先定义一个指针结构体 （ 结构体只是定义了一个数据类型） struct Arr { int * pBase; //该指针用来存储数组第一个元素的地址 int len; //数组能够容纳的最大元素的个数 int cnt; //当前数组有效元素的个数 }; /
数据结构代码实现1 —— 数组（Array）
11-11 955
template class Array { public: //Two things pop immediately into mind: //a pointer to the array and the length of the array. DataType* m_array; int m_size; public: //Constructor Ar
C语言实现的数据结构：线性表操作源代码
"该资源提供的是C语言实现的数据结构源代码，主要针对线性表的顺序存储结构进行了详细实现，包括初始化、判断空表、清除表、获取表长、获取指定位置元素等功能。" 在数据结构中，线性表是一种基本且重要的数据组织...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值