MyArraylist的优势
时间: 2024-01-07 12:23:11 浏览: 43
MyArrayList的优势主要体现在以下几个方面:
1. 动态扩容:MyArrayList可以根据需要动态地调整容量,当元素数量超过当前容量时,会自动进行扩容操作。这样可以避免手动管理容量带来的麻烦,提高了代码的灵活性和可维护性。
2. 高效的随机访问:MyArrayList内部使用数组来存储元素,通过索引可以直接访问数组中的元素,因此在查找和访问元素时具有较高的效率。相比于链表等其他数据结构,MyArrayList在随机访问方面具有明显的优势。
3. 支持快速的插入和删除操作:MyArrayList在尾部插入和删除元素的操作效率很高,时间复杂度为O(1)。而在其他位置插入和删除元素时,虽然需要移动一部分元素,但由于数组的连续存储特性,移动的元素数量相对较少,因此效率也较高。
4. 支持泛型:MyArrayList使用泛型来实现,可以存储任意类型的元素。这样可以提高代码的复用性和安全性,避免了类型转换的麻烦。
5. 提供丰富的操作方法:MyArrayList提供了一系列常用的操作方法,如添加元素、删除元素、获取元素、判断是否包含某个元素等。这些方法使得对线性表的操作更加方便和灵活。
总之,MyArrayList作为一种线性表的实现方式,在动态扩容、随机访问、插入删除操作、泛型支持和操作方法等方面具有明显的优势,适用于各种场景下的数据存储和操作需求。
相关问题
c++实现的一个MyArrayList
好的,下面是C++实现的一个MyArrayList,其中包含了常见的数组操作函数:
```c++
#include <iostream>
#include <stdexcept>
template <typename T>
class MyArrayList {
private:
T *data;
int size;
int capacity;
public:
MyArrayList(int capacity = 10) {
this->capacity = capacity;
data = new T[capacity];
size = 0;
}
~MyArrayList() {
delete[] data;
}
int getSize() const {
return size;
}
bool isEmpty() const {
return size == 0;
}
void add(int index, T e) {
if (index < 0 || index > size)
throw std::invalid_argument("Add failed. Index is invalid.");
if (size == capacity)
resize(2 * capacity);
for (int i = size - 1; i >= index; i--)
data[i + 1] = data[i];
data[index] = e;
size++;
}
void addLast(T e) {
add(size, e);
}
void addFirst(T e) {
add(0, e);
}
T get(int index) const {
if (index < 0 || index >= size)
throw std::invalid_argument("Get failed. Index is invalid.");
return data[index];
}
void set(int index, T e) {
if (index < 0 || index >= size)
throw std::invalid_argument("Set failed. Index is invalid.");
data[index] = e;
}
bool contains(T e) const {
for (int i = 0; i < size; i++) {
if (data[i] == e)
return true;
}
return false;
}
int find(T e) const {
for (int i = 0; i < size; i++) {
if (data[i] == e)
return i;
}
return -1;
}
T remove(int index) {
if (index < 0 || index >= size)
throw std::invalid_argument("Remove failed. Index is invalid.");
T ret = data[index];
for (int i = index + 1; i < size; i++)
data[i - 1] = data[i];
size--;
if (size == capacity / 4 && capacity / 2 != 0)
resize(capacity / 2);
return ret;
}
T removeFirst() {
return remove(0);
}
T removeLast() {
return remove(size - 1);
}
void removeElement(T e) {
int index = find(e);
if (index != -1)
remove(index);
}
private:
void resize(int newCapacity) {
T *newData = new T[newCapacity];
for (int i = 0; i < size; i++)
newData[i] = data[i];
delete[] data;
data = newData;
capacity = newCapacity;
}
};
int main() {
MyArrayList<int> arr;
for (int i = 0; i < 10; i++)
arr.addLast(i);
arr.add(1, 100);
std::cout << arr.get(1) << std::endl;
arr.remove(2);
arr.removeElement(4);
for (int i = 0; i < arr.getSize(); i++)
std::cout << arr.get(i) << " ";
std::cout << std::endl;
return 0;
}
```
这个MyArrayList实现了动态扩展,可以在插入元素时自动扩容,也可以在删除元素时自动缩容。同时,还实现了常见的数组操作函数,例如在指定位置插入元素、在末尾添加元素、在头部添加元素、获取指定位置的元素、修改指定位置的元素、查找指定元素是否存在、查找指定元素的位置、删除指定位置的元素、删除第一个元素、删除最后一个元素、删除指定元素等。
java使用泛型实现一个MyArrayList类
以下是使用泛型实现的MyArrayList类的示例代码:
```java
public class MyArrayList<E> {
private static final int DEFAULT_CAPACITY = 10;
private int size;
private E[] elements;
public MyArrayList() {
elements = (E[]) new Object[DEFAULT_CAPACITY];
}
public MyArrayList(int capacity) {
elements = (E[]) new Object[capacity];
}
public void add(E e) {
if (size == elements.length) {
resize();
}
elements[size++] = e;
}
public E get(int index) {
checkIndex(index);
return elements[index];
}
public void set(int index, E e) {
checkIndex(index);
elements[index] = e;
}
public E remove(int index) {
checkIndex(index);
E element = elements[index];
for (int i = index; i < size - 1; i++) {
elements[i] = elements[i + 1];
}
elements[--size] = null;
return element;
}
public boolean contains(E e) {
for (int i = 0; i < size; i++) {
if (elements[i].equals(e)) {
return true;
}
}
return false;
}
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}
private void resize() {
E[] newElements = (E[]) new Object[elements.length * 2];
System.arraycopy(elements, 0, newElements, 0, size);
elements = newElements;
}
private void checkIndex(int index) {
if (index < 0 || index >= size) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + size);
}
}
}
```
使用示例:
```java
MyArrayList<String> list = new MyArrayList<>();
list.add("hello");
list.add("world");
System.out.println(list.get(0)); // output: hello
list.set(1, "java");
System.out.println(list.get(1)); // output: java
System.out.println(list.remove(0)); // output: hello
System.out.println(list.contains("java")); // output: true
System.out.println(list.size()); // output: 1
System.out.println(list.isEmpty()); // output: false
```