java数组实现_数据结构-JAVA实现数组

这篇文章是展示如何使用JAVA语言实现Array这种数据结构。

​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 {

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.Mainpublic 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] }

}

如下图所示：

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 容量的时候才缩小容量。

扫码关注爱因诗贤