数据结构篇-数组(TypeScript版+Java版)
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:N搜索开源版-Java版(文末附开源地址)
一.人脸检测相关概念 人脸检测(Face Detection)是检测出图像中人脸所在位置的一项技术,是人脸智能分析应用的核心组成部分,也是最基础的部分.人脸检测方法现在多种多样,常用的技术或工具大 ...
- 微信支付java版V3验证数据合法性
[TOC] 1. 微信支付java版V3验证数据合法性 概要:使用微信支付接口时,微信会返回或回调给商户XML数据,开发者需要验证微信返回的数据是否合法. 特别提醒:商户系统对于支付结果通知的内容一定 ...
- java版数据结构与算法第二章数组
数组由一组具有相同类型的数据元素组成,并存储在一组连续存储单元中.一维数组是常量. 二维数组:若一维数组中的数据元素又是一堆数据结构,我们称之为二维数组.二维数组可以看成是n个列向量组成的线性表. 数 ...
- 第八篇 :微信公众平台开发实战Java版之如何网页授权获取用户基本信息
第一部分:微信授权获取基本信息的介绍 我们首先来看看官方的文档怎么说: 如果用户在微信客户端中访问第三方网页,公众号可以通过微信网页授权机制,来获取用户基本信息,进而实现业务逻辑. 关于网页授权回调域 ...
- 第七篇 :微信公众平台开发实战Java版之如何获取微信用户基本信息
在关注者与公众号产生消息交互后,公众号可获得关注者的OpenID(加密后的微信号,每个用户对每个公众号的OpenID是唯一的.对于不同公众号,同一用户的openid不同). 公众号可通过本接口来根据O ...
- 第六篇 :微信公众平台开发实战Java版之如何自定义微信公众号菜单
我们来了解一下 自定义菜单创建接口: http请求方式:POST(请使用https协议) https://api.weixin.qq.com/cgi-bin/menu/create?access_to ...
- 第五篇 :微信公众平台开发实战Java版之如何获取公众号的access_token以及缓存access_token
一.access_token简介 为了使第三方开发者能够为用户提供更多更有价值的个性化服务,微信公众平台 开放了许多接口,包括自定义菜单接口.客服接口.获取用户信息接口.用户分组接口.群发接口等, 开 ...
- Protocol Buffer序列化/反序列化---初体验(java版)
今天闲遐时学习了 Protocol Buffer 在网上看到了许多资料,其中不泛精品,想要详细了解的请看文章结尾的友情链接,我这里就做加深印象,快速入门的一个完整的demo,仅此而已. 学完你可以得到 ...
- 排序算法Java版,以及各自的复杂度,以及由堆排序产生的top K问题
常用的排序算法包括: 冒泡排序:每次在无序队列里将相邻两个数依次进行比较,将小数调换到前面, 逐次比较,直至将最大的数移到最后.最将剩下的N-1个数继续比较,将次大数移至倒数第二.依此规律,直至比较结 ...
随机推荐
- 【转】sublime text 2 快捷键大全
Ctrl+L 选择整行(按住-继续选择下行) Ctrl+KK 从光标处删除至行尾 Ctrl+Shift+K 删除整行 Ctrl+Shift+D 复制光标所在整行,插入在该行之前 Ctrl+J 合并行( ...
- linux无文件执行— fexecve 揭秘
前言 良好的习惯是人生产生复利的有力助手. 继续2020年的flag,至少每周更一篇文章. 无文件执行 之前的文章中,我们讲到了无文件执行的方法以及混淆进程参数的方法,今天我们继续讲解一种linux上 ...
- java之AQS和显式锁
本次内容主要介绍AQS.AQS的设计及使用.ReentrantLock.ReentrantReadWriteLock以及手写一个可重入独占锁 1.什么是AQS? AQS,队列同步器AbstractQu ...
- Redis启动服务和String常用命令
Redis启动服务和String常用命令 1. 启动Redis服务 E:\redis>redis-server.exe redis.windows.conf _._ _.-``__ ''-._ ...
- Python Django撸个WebSSH操作Kubernetes Pod(下)- 终端窗口自适应Resize
追求完美不服输的我,一直在与各种问题斗争的路上痛并快乐着 上一篇文章Django实现WebSSH操作Kubernetes Pod最后留了个问题没有解决,那就是terminal内容窗口的大小没有办法调整 ...
- Java并发编程之支持并发的list集合你知道吗
Java并发编程之-list集合的并发. 我们都知道Java集合类中的arrayList是线程不安全的.那么怎么证明是线程不安全的呢?怎么解决在并发环境下使用安全的list集合类呢? 本篇是<凯 ...
- UNIX环境高级编程——TCP/IP网络编程 常用网络信息检索函数
UNIX环境高级编程——TCP/IP网络编程 常用网络信息检索函数 gethostname() getppername() getsockname() gethostbyname() ...
- react 周期函数
1.constructor():构造函数执行时间:组件被加载前最先调用,并且仅调用一次作用:定义状态机变量注意:第一个语句必须是super(props),正确定义状态机代码如下constructor( ...
- Activiti7流程定义
一.什么是流程定义 流程定义是线下bpmn2.0标椎去描述业务流程,通常使用activiti-explorer(web控制台)或 activiti-eclipse-designer 插件对业务流程进行 ...
- 二分搜索树(Binary Search Tree)
目录 什么是二叉树? 什么是二分搜索树? 二分搜索树的基本操作 二分搜索树添加新元素 二分搜索树的遍历(包含非递归实现) 删除二分搜索树中的元素 什么是二叉树? 在实现二分搜索树之前,我们先思考一 ...