1.TypeScript版本

export default class MyArray<E> {

  public data: E[];
public size: number = 0; /**
* 构造函数,传入数组的容量capacity
* @param {number} capacity 数组容量,默认10
*/
constructor(capacity = 10) {
this.data = new Array(capacity);
} /**
* 获取数组容量(数组能总共能包含多少元素)
* Time Complexity O(1)
* @return {number}
*/
getCapacity(): number {
return this.data.length;
} /**
* 获取数组中当前存储元素的个数
* Time Complexity O(1)
* @return {number}
*/
getSize(): number {
return this.size;
} /**
* 判断数组是否为空,即元素的个数是否为0
* Time Complexity O(1)
* @return {boolean}
*/
isEmpty(): boolean {
return this.size === 0;
} /**
* 在数组中index位置添加一个元素
* 考虑到这里不是每次操作都会触发扩容,这里均摊到每次操作上的时间复杂度为O(1)
* @param {number} index 要插入的位置
* @param {E} e 要插入的元素
* @return {void}
*/
add(index: number, e: E): void {
if (index < 0 || index > this.size) {
throw new Error('Add failed. Required index >= 0 and index <= size');
} // 将数组的容量扩大为之前的二倍
if (this.size === this.data.length) {
this.resize(this.data.length * 2);
}
for (let i = this.size - 1; i >= index; i--) {
this.data[i + 1] = this.data[i];
}
this.data[index] = e;
this.size++;
} /**
* 向所有元素之后添加一个元素
* Time Complexity O(1)
* @param {E} e 要插入的元素
* @return {void}
*/
addLast(e: E): void {
this.add(this.size, e);
} /**
* 向所有元素之前添加一个元素
* Time Complexity O(n)
* @param {E} e 要插入的元素
* @return {void}
*/
addFirst(e: E): void {
this.add(0, e);
} /**
* 修改index索引位置元素为e
* Time Complexity O(1)
* @param {number} index 要插入元素的位置
* @param {E} e 要插入的元素
* @return {void}
*/
set(index: number, e: E) {
if (index < 0 || index >= this.size) {
throw new Error('Set failed. Index is illegal.');
}
this.data[index] = e;
} /**
* 查找数组中是否含有元素e
* Time Complexity O(n)
* @param {E} e 要查找的元素
* @return {boolean}
*/
contains(e: E): boolean {
for (let i = 0; i < this.size; i++) {
if (e === this.data[i]) {
return true;
}
}
return false;
} /**
* 查找数组中元素e所在的索引,如果不存在,则返回-1
* Time Complexity O(n)
* @param {E} e 要查找的元素
* @return {boolean}
*/
find(e: E): number {
for (let i = 0; i < this.size; i++) {
if (e === this.data[i]) {
return i;
}
}
return -1;
} /**
* 从数组中删除index位置的元素,并且返回删除元素
* Time Complexity O(n)
* @param {number} index 要删除的元素位置的索引
* @return {E}
*/
remove(index: number): E {
if (index < 0 || index > this.size) {
throw new Error('Remove failed. index is illegal')
} let ret: E = this.data[index];
for (let i = index + 1; i < this.size; i++) {
this.data[i - 1] = this.data[i];
}
this.size--;
this.data[this.size] = null;
// 当size == capacity / 4时,才将capacity减半。防止复杂度震荡
// data.length != 0 是因为不能常见capacity为0的数组
if (this.size === Math.floor(this.data.length / 4) && Math.floor(this.data.length / 2) !== 0) {
this.resize(Math.floor(this.data.length / 2));
}
return ret;
} /**
* 删除数组中的最后一个元素
* Time Complexity O(1)
* @return {E}
*/
removeLast(): E {
return this.remove(this.size - 1);
} /**
* 删除数组中的第一个元素
* Time Complexity O(n)
* @return {E}
*/
removeFirst(): E {
return this.remove(0);
} /**
* 获取index索引的元素
* Time Complexity O(1)
* @param {number} index 要获取元素的索引
* @return {E}
*/
get(index: number): E {
if (index < 0 || index >= this.size) {
throw new Error('Get failed. Index is illegal...')
}
return this.data[index];
} /**
* 获取数组中的第一个元素
* Time Complexity O(1)
* @return {E}
*/
getFirst() {
return this.get(0);
} /**
* 获取数组中的最后一个元素
* Time Complexity O(1)
* @return {E}
*/
getLast() {
return this.get(this.size - 1);
} /**
* 数组扩容,或者缩容操作
* Time Complexity O(n)
* @param {number} newCapacity 新的数组的容量
* @return {void}
*/
resize(newCapacity: number): void {
let newData: E[] = new Array(newCapacity);
for (let i = 0; i < this.size; i++) {
newData[i] = this.data[i];
} this.data = newData;
} /**
* 交换数组中的i, j两个元素
* Time Complexity O(1)
* @param {number} i 第i位置的元素
* @param {number} j 第j位置的元素
* @return {void}
*/
swap(i: number, j: number): void {
if (i < 0 || j < 0 || i >= this.size || j >= this.size) {
throw new Error('Index is illegal.');
}
let temp = this.data[i];
this.data[i] = this.data[j];
this.data[j] = temp;
} toString(): string {
let res = '';
res += `Array: size = ${this.size}, capacity = ${this.getCapacity()}\n`;
res += '[';
for (let i = 0; i < this.size; i++) {
res += this.data[i];
if (i !== this.size - 1)
res += ', '
}
res += ']';
return res;
}
}

2.Java版本

public class Array<E> {
private E[] data;
private int size; // 构造函数,传入数组的容量capacity
public Array(int capacity) {
data = (E[])new Object[capacity];
size = 0;
} // 无参数构造函数,默认数组的容量capacity=10
public Array() {
this(10);
} // 构函函数,传进来的是数组
public Array(E[] arr) {
data = (E[])new Object[arr.length];
for (int i = 0; i < arr.length; i++)
data[i] = arr[i];
size = arr.length;
} // 获取数组中有效元素的个数
public int getSize() {
return size;
} // 获取数组的容量
public int getCapacity() {
return data.length;
} // 判断数组是否为空
public boolean isEmpty() {
return size == 0;
} // Time Complexity O(1)
// 向数组的末尾添加一个元素e
public void addLast(E e) {
add(size, e);
} // Time Complexity O(n)
// 向数组的头部添加一个元素e
public void addFirst(E e) {
add(0, e);
} // Time Complexity O(n)
// 在第index位置插入一个新元素e
// 均摊时间复杂度
// 假设capacity=n, 经过n+1次的addLast操作,触发resize,总共进行2n+1次基本操作
// 因此平均每次addLast操作,进行2次的基本操作
public void add(int index, E e) {
if (index < 0 || index > size)
throw new IllegalArgumentException("AddLast failed. Require index >=0 and index <= size"); // 如果数组已满,则扩容1倍
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++;
} // Time Complexity O(1)
// 获取index索引位置的元素
public E get(int index) {
if (index < 0 || index > size)
throw new IllegalArgumentException("Get failed. Index is illegal.");
return data[index];
} // 获取数组的第一个元素
public E getFirst() {
return get(0);
} // 获取数组的最后一个元素
public E getLast() {
return get(size - 1);
} // Time Complexity O(1)
// 修改index位置的元素为e
public void set(int index, E e) {
if (index < 0 || index > size)
throw new IllegalArgumentException("Set failed. Index is illegal.");
data[index] = e;
} // Time Complexity O(n)
// 查找数组中是否包含元素e
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e))
return true;
}
return false;
} // Time Complexity O(n)
// 查找数组中元素e所在的索引,如果不存在元素e,就返回-1
public int find(E e) {
for (int i = 0; i < size; i++) {
if (data[i].equals(e))
return i;
}
return -1;
} // Time Complexity O(n)
// 删除指定位置index的元素,并返回删除的元素
public E remove(int index) {
if (index < 0 || index > size)
throw new IllegalArgumentException("Remove failed. Index is illegal."); E ret = data[index];
for (int i = index + 1; i < size; i++)
data[i - 1] = data[i]; size--;
data[size] = null; // 当size == capacity / 4时,才将capacity减半。防止复杂度震荡
// data.length != 0 是因为不能常见capacity为0的数组
if (size == data.length / 4 && data.length / 2 != 0)
resize(data.length / 2);
return ret;
} // Time Complexity O(n)
// 从数组中删除第一个元素,并返回删除的元素
public E removeFirst() {
return remove(0);
} // Time Complexity O(1)
// 从数组中删除最后一个元素,并返回删除的元素
public E removeLast() {
return remove(size - 1);
} // Time Complexity O(n)
// 从数组中删除元素e
public void removeElement(E e) {
int index = find(e);
if (index != -1)
remove(index);
} private void resize(int newCapacity) {
E[] newData = (E[])new Object[newCapacity];
for (int i = 0; i < size; i++) {
newData[i] = data[i];
}
data = newData;
} public void swap(int i, int j) {
if (i < 0 || i >= size || j < 0 || j >= size)
throw new IllegalArgumentException("Index is illegal.");
E ret = data[i];
data[i] = data[j];
data[i] = ret;
} // 覆盖父类的toString方法
@Override
public String toString() {
StringBuilder res = new StringBuilder();
res.append(String.format("Array: size = %d, capacity = %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();
}
}

更多数据结构和leetcode解法问题,请参考我的githubhttps://github.com/GuoLizhi/algorithm

数据结构篇-数组(TypeScript版+Java版)的更多相关文章

  1. 阿里云人脸1:N搜索开源版-Java版(文末附开源地址)

    ​ 一.人脸检测相关概念 人脸检测(Face Detection)是检测出图像中人脸所在位置的一项技术,是人脸智能分析应用的核心组成部分,也是最基础的部分.人脸检测方法现在多种多样,常用的技术或工具大 ...

  2. 微信支付java版V3验证数据合法性

    [TOC] 1. 微信支付java版V3验证数据合法性 概要:使用微信支付接口时,微信会返回或回调给商户XML数据,开发者需要验证微信返回的数据是否合法. 特别提醒:商户系统对于支付结果通知的内容一定 ...

  3. java版数据结构与算法第二章数组

    数组由一组具有相同类型的数据元素组成,并存储在一组连续存储单元中.一维数组是常量. 二维数组:若一维数组中的数据元素又是一堆数据结构,我们称之为二维数组.二维数组可以看成是n个列向量组成的线性表. 数 ...

  4. 第八篇 :微信公众平台开发实战Java版之如何网页授权获取用户基本信息

    第一部分:微信授权获取基本信息的介绍 我们首先来看看官方的文档怎么说: 如果用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑. 关于网页授权回调域 ...

  5. 第七篇 :微信公众平台开发实战Java版之如何获取微信用户基本信息

    在关注者与公众号产生消息交互后,公众号可获得关注者的OpenID(加密后的微信号,每个用户对每个公众号的OpenID是唯一的.对于不同公众号,同一用户的openid不同). 公众号可通过本接口来根据O ...

  6. 第六篇 :微信公众平台开发实战Java版之如何自定义微信公众号菜单

    我们来了解一下 自定义菜单创建接口: http请求方式:POST(请使用https协议) https://api.weixin.qq.com/cgi-bin/menu/create?access_to ...

  7. 第五篇 :微信公众平台开发实战Java版之如何获取公众号的access_token以及缓存access_token

    一.access_token简介 为了使第三方开发者能够为用户提供更多更有价值的个性化服务,微信公众平台 开放了许多接口,包括自定义菜单接口.客服接口.获取用户信息接口.用户分组接口.群发接口等, 开 ...

  8. Protocol Buffer序列化/反序列化---初体验(java版)

    今天闲遐时学习了 Protocol Buffer 在网上看到了许多资料,其中不泛精品,想要详细了解的请看文章结尾的友情链接,我这里就做加深印象,快速入门的一个完整的demo,仅此而已. 学完你可以得到 ...

  9. 排序算法Java版,以及各自的复杂度,以及由堆排序产生的top K问题

    常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结 ...

随机推荐

  1. node.js中http.respone.end方法概述

    方法说明: 结束响应,告诉客户端所有消息已经发送.当所有要返回的内容发送完毕时,该函数必须被调用一次. 如果不调用该函数,客户端将永远处于等待状态. 语法: response.end([data], ...

  2. docker redis安装及配置(外网访问 关闭安全限制 设置密码)

    docker run -p 6379:6379 --name redis -v /usr/local/redis/etc/redis.conf:/etc/redis/redis.conf -v /us ...

  3. 大数据软件安装之Hadoop(Apache)(数据存储及计算)

    大数据软件安装之Hadoop(Apache)(数据存储及计算) 一.生产环境准备 1.修改主机名 vim /etc/sysconfig/network 2.修改静态ip vim /etc/udev/r ...

  4. Java容器的常见问题

    记录Java容器中的常见概念和原理 参考: https://github.com/wangzhiwubigdata/God-Of-BigData#三Java并发容器 https://blog.csdn ...

  5. P2341 [USACO03FALL][HAOI2006]受欢迎的牛 G 题解

    原题链接 POJ的链接 简要题意: 给定一张图,求多少个点,每个点都能到达它. 本题作为强连通分量的入门题. 何为强连通分量?有什么用? 下面一一解释. 首先,我们要确认,这道题目如果不用强连通分量而 ...

  6. 【Unity游戏开发】跟着马三一起魔改LitJson

    一.引子 在游戏开发中,我们少不了和数据打交道,数据的存储格式可谓是百花齐放,xml.json.csv.bin等等应有尽有.在这其中Json以其小巧轻便.可读性强.兼容性好等优点受到广大程序员的喜爱. ...

  7. 16. nested exception is com.fasterxml.jackson.databind.exc.UnrecognizedPropertyException: Unrecognized field "auditUnitName"

    org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver:handleHttpMessageNotRead ...

  8. 微信APP支付-java后台实现

    不说废话,直接上代码 先是工具类(注意签名时要排序): import java.io.BufferedReader; import java.io.ByteArrayInputStream; impo ...

  9. css 重排与重绘

    css 重绘与重排 我们要知道当浏览器下载完页面的所有资源后,就会开始解析源代码. HTML 会被解析成 DOM Tree,Css 则会被渲染成 CSSOM Tree,最后它们会附加到一起,形成渲染树 ...

  10. 粒子群优化算法(PSO)之基于离散化的特征选择(FS)(一)

    欢迎大家关注我们的网站和系列教程:http://www.tensorflownews.com/,学习更多的机器学习.深度学习的知识! 作者:Geppetto 在机器学习中,离散化(Discretiza ...