数组
- 实现一个支持动态扩容的数组
- 实现一个大小固定的有序数组，支持动态增删改操作
- 实现两个有序数组合并为一个有序数组
总结：数组扩容优先考虑使用Array的静态方法Resize,其次考虑把一个扩容的、临时的数组赋值给原数组。
一、数组
1.实现一个支持动态扩容的数组
class Array():
def __init_(self):
'''数组类初始化方法.'''
self.__data = [] # 数据存储List
def add_space(self, n):
'''数组的扩容方法.
参数：
n:扩容量
返回：
如果扩容成功，则返回True
如果扩容失败，则返回False
'''
if n < 0:
return False
else:
self.__data += [0]*n
return True
def printAll(self):
'''打印当前数组所有数据'''
print(self.__data)
2.实现一个大小固定的有序数组，支持动态增删改操作
class Array():
def __init__(self):
'''数组类初始化方法.'''
self.__data = [] # 数据存储List
def find(self, index):
'''数组的查找方法.
参数：
index:将要查找的数据的下标
返回：
如果查找成功，则返回找到的数据
如果查找失败，则返回False
'''
if index >= len(self.__data) or index < 0:
return False
else:
return self.__data[index]
def delete(self, index):
'''数组的删除方法.
参数：
index:将要删除的数据的下标
返回：
如果删除成功，则返回True
如果删除失败，则返回False
'''
if index >= len(self.__data) or index < 0:
return False
else:
self.__data.pop(index)
return True
def insert(self, index, value):
'''数组插入数据操作.
参数：
index:将要插入的下标
value：将要插入的数据
返回：
如果插入成功，则返回True
如果插入失败，则返回False
'''
if index > len(self.__data) or index < 0:
return False
else:
self.__data.insert(index, value)
return True
def insertToTail(self, value):
'''直接在数组尾部插入数据.
参数：
value:将要插入的数据
'''
self.__data.append(value)
def alt(sel, index, value):
'''数组插入数据操作.
参数：
index:将要插入的下标
value：将要插入的数据
返回：
如果插入成功，则返回True
如果插入失败，则返回False
'''
if index >= len(self.__data) or index < 0:
return False
else:
self.__data[index] = value
return True
def printAll(self):
'''打印当前数组所有数据'''
print(self.__data)
3.实现两个有序数组合并为一个有序数组
def merge(nums1, m, nums2, n):
if m==0:
return nums2
if n==0:
return nums1
nums1 += [0]*n
while m>0 and n>0:
if nums1[m-1]>nums2[n-1]:
#若nums1中最后一个元素大于nums2[]中最后一个元素
nums1[m+n-1]=nums1[m-1]#则扩展后的列表最后一个元素是俩元素中最大的
m-=1
#nums1中元素-1
else:
nums1[m+n-1]=nums2[n-1]
n-=1
if n>0:
#若nums1完了，nums2还没完
nums1[:n]=nums2[:n]
#把剩下nums2加在最开始
return nums1
if __name__ =='__main__':
nums1 = [1, 3, 7] # 0的位置用来方nums2
m = 3
nums2 = [2, 5, 6]
n = 3
nums = merge(nums1,m,nums2,n)
print(nums)
# 输出 [1, 2, 3, 5, 6, 7]
什么是数据结构？
- 数据结构是计算机存储、组织数据的方式；
- 在实际应用中，根据使用场景来选择最合适的数据结构；
线性表
线性表是具有 n 个相同类型元素的有限序列（ n ≥ 0 ）
a1是首节点（首元素），an是尾结点（尾元素）
a1是a2的前驱，a2是a1的后继
常见的线性表有：
- 数组
- 链表
- 栈
- 队列
- 哈希表（散列表）
数组（Array）
数组是一种顺序存储的线性表，所有元素的内存地址是连续的；
在很多编程语言中，数组都有个致命的缺点 ：
- 无法动态修改容量
实际开发中，我们更希望数组的容量是可以动态改变的；
动态数组（Dynamic Array）
动态数组接口设计
添加元素 - add(E element)、add(int index, E element)
add(E element)：默认往数组最后添加元素；
add(int index, E element)：在 index 位置插入一个元素；
比如要往 index = 2 的地方添加元素：
正确的顺序应当是：从后往前开始将 index = 2 以后的元素依次后移，然后赋值：
如果从前往后开始移动元素，会造成如下错误的后果：
删除元素 - remove(int index)、清空数组 - clear()
例如，删除 index = 3 的数组元素，应当从前往后开始移动，用后面的元素覆盖前面的元素。
思考：最后一个元素如何处理？
- 如果存放
int类型，size--后，最后一个元素已经无法访问了。 - 如果使用泛型，数组要注意内存管理（将元素置
null）。
使用泛型技术可以让动态数组更加通用，可以存放任何数据类型：
是否包含某个元素 - contains(E element)
关于 null 的处理主要看你的业务需求：是否可以存储 null 数据？
扩容 - ensureCapacity(int capacity)
打印数组（toString）
- 重写
toString方法 - 在
toString方法中将元素拼接成字符串 - 字符串拼接建议使用
StringBuilder
int型动态数组源码（JAVA）
int型动态数组源码（Java）
public class ArrayList {
private int size; // 元素数量
private int[] elements; // 所有的元素
private static final int DEFAULT_CAPACITY = 10; // 初始容量
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayList(int capacity) { // 容量小于10一律扩充为10
capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
elements = new int[capacity];
}
public ArrayList(){
this(DEFAULT_CAPACITY);
}
/**
* 元素的数量
* @return
*/
public int size(){
return size;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 是否包含某个元素
* @param element
* @return
*/
public boolean contains(int element){
return indexOf(element) != ELEMENT_NOT_FOUND; //找的到该元素则返回True
}
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, int element){
rangeCheckForAdd(index); // 检查下标越界
ensureCapacity(size + 1); // 确保容量够大
// 0 1 2 3 4 5 6 7 8 9 (index)
// 1 2 3 4 5 6 x x x x (原数组)
// 在index=2处，插入9，元素全部后移
// 1 2 9 3 4 5 6 x x x (add后数组)
// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
for (int i = size - 1; i > index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element; // 赋值
size++;
}
/**
* 添加元素到最后面
*/
public void add(int element){
add(size, element);
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public int get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public int set(int index, int element){
rangeCheck(index);
int old = elements[index];
elements[index] = element;
return old;
}
/**
* 删除index位置的元素
* @param index
* @return
*/
public int remove(int index){
rangeCheck(index);
// 0 1 2 3 4 5 (index)
// 1 2 3 4 5 6 (原数组)
// 删除index为2的元素，元素前移
// 1 2 4 5 6 (remove后的数组)
int old = elements[index];
// 从前往后开始移, 用后面的元素覆盖前面的元素
for (int i = index; i < size-1; i++) {
elements[i] = elements[i + 1];
}
size--;
return old;
}
/**
* 查看元素的索引
* @param element
* @return
*/
public int indexOf(int element){
for (int i = 0; i < size; i++) {
if(elements[i] == element) return i;
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
size = 0;
}
/*
* 扩容操作
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
if(oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5
int[] newElements = new int[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
}
/****************封装好的功能函数*******************************/
// 下标越界抛出的异常
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 检查下标越界(不可访问或删除size位置)
private void rangeCheck(int index){
if(index < 0 || index >= size){
outOfBounds(index);
}
}
// 检查add()的下标越界(可以在size位置添加)
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
/****************封装好的功能函数*******************************/
@Override
public String toString() {
// 打印形式为: size=5, [99, 88, 77, 66, 55]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if(0 != i) string.append(", ");
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
泛型动态数组源码（Java）
@SuppressWarnings("unchecked")
public class ArrayList<E> {
private int size; // 元素的数量
private E[] elements; // 所有的元素
private static final int DEFAULT_CAPACITY = 10; // 初始容量
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayList(int capacity) { // 容量小于10一律扩充为10
capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
elements = (E[])new Object[capacity];
}
public ArrayList(){
this(DEFAULT_CAPACITY);
}
/**
* 元素的数量
* @return
*/
public int size(){
return size;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 是否包含某个元素
* @param element
* @return
*/
public boolean contains(E element){
return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True
}
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, E element){
rangeCheckForAdd(index); // 检查下标越界
ensureCapacity(size + 1); // 确保容量够大
// 0 1 2 3 4 5 6 7 8 9 (index)
// 1 2 3 4 5 6 x x x x (原数组)
// 在index=2处，插入9，元素全部后移
// 1 2 9 3 4 5 6 x x x (add后数组)
// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
for (int i = size - 1; i > index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element; // 复制
size++;
}
/**
* 添加元素到最后面
*/
public void add(E element){
add(size, element);
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public E get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public E set(int index, E element){
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 删除index位置的元素
* @param index
* @return
*/
public E remove(int index){
rangeCheck(index);
// 0 1 2 3 4 5 (index)
// 1 2 3 4 5 6 (原数组)
// 删除index为2的元素，元素前移
// 1 2 4 5 6 (remove后的数组)
// 从前往后开始移, 用后面的元素覆盖前面的元素
E old = elements[index];
for (int i = index; i < size - 1; i++) {
elements[i] = elements[i + 1];
}
elements[--size] = null; // 删除元素后, 将最后一位设置为null
return old;
}
/**
* 查看元素的索引
* @param element
* @return
*/
public int indexOf(E element){
/*
// 不对 null 进行处理也可以，但是健壮性不够
for (int i = 0; i < size; i++) {
if(elements[i].equals(element)) return i;
}
*/
if(element == null){ // 对 null 进行处理
for (int i = 0; i < size; i++) {
if(elements[i] == null) return i;
}
}else{
for (int i = 0; i < size; i++) {
if(elements[i].equals(element)) return i;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
// 使用泛型数组后要注意内存管理(将元素置null)
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
/**
* 扩容操作
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
if(oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[])new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i]; // 拷贝原数组元素到新数组
}
elements = newElements;
System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
}
/****************封装好的功能函数**************************/
// 下标越界抛出的异常
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 检查下标越界(不可访问或删除size位置)
private void rangeCheck(int index){
if(index < 0 || index >= size){
outOfBounds(index);
}
}
// 检查add()的下标越界(可以在size位置添加元素)
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
/****************封装好的功能函数***************************/
@Override
public String toString() {
// 打印形式为: size=5, [99, 88, 77, 66, 55]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if(0 != i) string.append(", ");
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
int型动态数组源码（Java）
public class ArrayList {
private int size; // 元素数量
private int[] elements; // 所有的元素
private static final int DEFAULT_CAPACITY = 10; // 初始容量
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayList(int capacity) { // 容量小于10一律扩充为10
capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
elements = new int[capacity];
}
public ArrayList(){
this(DEFAULT_CAPACITY);
}
/**
* 元素的数量
* @return
*/
public int size(){
return size;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 是否包含某个元素
* @param element
* @return
*/
public boolean contains(int element){
return indexOf(element) != ELEMENT_NOT_FOUND; //找的到该元素则返回True
}
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, int element){
rangeCheckForAdd(index); // 检查下标越界
ensureCapacity(size + 1); // 确保容量够大
// 0 1 2 3 4 5 6 7 8 9 (index)
// 1 2 3 4 5 6 x x x x (原数组)
// 在index=2处，插入9，元素全部后移
// 1 2 9 3 4 5 6 x x x (add后数组)
// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
for (int i = size - 1; i > index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element; // 赋值
size++;
}
/**
* 添加元素到最后面
*/
public void add(int element){
add(size, element);
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public int get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public int set(int index, int element){
rangeCheck(index);
int old = elements[index];
elements[index] = element;
return old;
}
/**
* 删除index位置的元素
* @param index
* @return
*/
public int remove(int index){
rangeCheck(index);
// 0 1 2 3 4 5 (index)
// 1 2 3 4 5 6 (原数组)
// 删除index为2的元素，元素前移
// 1 2 4 5 6 (remove后的数组)
int old = elements[index];
// 从前往后开始移, 用后面的元素覆盖前面的元素
for (int i = index; i < size-1; i++) {
elements[i] = elements[i + 1];
}
size--;
return old;
}
/**
* 查看元素的索引
* @param element
* @return
*/
public int indexOf(int element){
for (int i = 0; i < size; i++) {
if(elements[i] == element) return i;
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
size = 0;
}
/*
* 扩容操作
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
if(oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1); // 1.5
int[] newElements = new int[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i];
}
elements = newElements;
System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
}
/****************封装好的功能函数*******************************/
// 下标越界抛出的异常
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 检查下标越界(不可访问或删除size位置)
private void rangeCheck(int index){
if(index < 0 || index >= size){
outOfBounds(index);
}
}
// 检查add()的下标越界(可以在size位置添加)
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
/****************封装好的功能函数*******************************/
@Override
public String toString() {
// 打印形式为: size=5, [99, 88, 77, 66, 55]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if(0 != i) string.append(", ");
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
泛型动态数组源码（Java）
@SuppressWarnings("unchecked")
public class ArrayList<E> {
private int size; // 元素的数量
private E[] elements; // 所有的元素
private static final int DEFAULT_CAPACITY = 10; // 初始容量
private static final int ELEMENT_NOT_FOUND = -1;
public ArrayList(int capacity) { // 容量小于10一律扩充为10
capacity = (capacity < DEFAULT_CAPACITY) ? DEFAULT_CAPACITY : capacity;
elements = (E[])new Object[capacity];
}
public ArrayList(){
this(DEFAULT_CAPACITY);
}
/**
* 元素的数量
* @return
*/
public int size(){
return size;
}
/**
* 是否为空
* @return
*/
public boolean isEmpty(){
return size == 0;
}
/**
* 是否包含某个元素
* @param element
* @return
*/
public boolean contains(E element){
return indexOf(element) != ELEMENT_NOT_FOUND; // 找的到该元素则返回True
}
/**
* 在index位置插入一个元素
* @param index
* @param element
*/
public void add(int index, E element){
rangeCheckForAdd(index); // 检查下标越界
ensureCapacity(size + 1); // 确保容量够大
// 0 1 2 3 4 5 6 7 8 9 (index)
// 1 2 3 4 5 6 x x x x (原数组)
// 在index=2处，插入9，元素全部后移
// 1 2 9 3 4 5 6 x x x (add后数组)
// 先从后往前开始, 将每个元素往后移一位, 然后再赋值
for (int i = size - 1; i > index; i--) {
elements[i + 1] = elements[i];
}
elements[index] = element; // 复制
size++;
}
/**
* 添加元素到最后面
*/
public void add(E element){
add(size, element);
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public E get(int index){
rangeCheck(index);
return elements[index];
}
/**
* 设置index位置的元素
* @param index
* @param element
* @return 原来的元素ֵ
*/
public E set(int index, E element){
rangeCheck(index);
E old = elements[index];
elements[index] = element;
return old;
}
/**
* 删除index位置的元素
* @param index
* @return
*/
public E remove(int index){
rangeCheck(index);
// 0 1 2 3 4 5 (index)
// 1 2 3 4 5 6 (原数组)
// 删除index为2的元素，元素前移
// 1 2 4 5 6 (remove后的数组)
// 从前往后开始移, 用后面的元素覆盖前面的元素
E old = elements[index];
for (int i = index; i < size - 1; i++) {
elements[i] = elements[i + 1];
}
elements[--size] = null; // 删除元素后, 将最后一位设置为null
return old;
}
/**
* 查看元素的索引
* @param element
* @return
*/
public int indexOf(E element){
/*
// 不对 null 进行处理也可以，但是健壮性不够
for (int i = 0; i < size; i++) {
if(elements[i].equals(element)) return i;
}
*/
if(element == null){ // 对 null 进行处理
for (int i = 0; i < size; i++) {
if(elements[i] == null) return i;
}
}else{
for (int i = 0; i < size; i++) {
if(elements[i].equals(element)) return i;
}
}
return ELEMENT_NOT_FOUND;
}
/**
* 清除所有元素
*/
public void clear(){
// 使用泛型数组后要注意内存管理(将元素置null)
for (int i = 0; i < size; i++) {
elements[i] = null;
}
size = 0;
}
/**
* 扩容操作
*/
private void ensureCapacity(int capacity){
int oldCapacity = elements.length;
if(oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E[] newElements = (E[])new Object[newCapacity];
for (int i = 0; i < size; i++) {
newElements[i] = elements[i]; // 拷贝原数组元素到新数组
}
elements = newElements;
System.out.println("size="+oldCapacity+", 扩容到了"+newCapacity);
}
/****************封装好的功能函数**************************/
// 下标越界抛出的异常
private void outOfBounds(int index) {
throw new IndexOutOfBoundsException("Index:" + index + ", Size:" + size);
}
// 检查下标越界(不可访问或删除size位置)
private void rangeCheck(int index){
if(index < 0 || index >= size){
outOfBounds(index);
}
}
// 检查add()的下标越界(可以在size位置添加元素)
private void rangeCheckForAdd(int index) {
if (index < 0 || index > size) {
outOfBounds(index);
}
}
/****************封装好的功能函数***************************/
@Override
public String toString() {
// 打印形式为: size=5, [99, 88, 77, 66, 55]
StringBuilder string = new StringBuilder();
string.append("size=").append(size).append(", [");
for (int i = 0; i < size; i++) {
if(0 != i) string.append(", ");
string.append(elements[i]);
}
string.append("]");
return string.toString();
}
}
测试运行：
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person(10, "jack"));
list.add(new Person(20, "rose"));
list.add(null);
list.add(null);
System.out.println("add()添加元素: " + list);
System.out.println("get()获取元素: " + list.get(0));
list.set(0, new Person(99, "ghost"));
System.out.println("set()设置元素值: " + list);
list.remove(0);
System.out.println("remove()删除元素: " + list);
list.clear();
System.out.println("clear()清空数组: " + list);
}
add()添加元素: size=4, [Person [age=10, name=jack], Person [age=20, name=rose], null, null]
get()获取元素: Person [age=10, name=jack]
set()设置元素值: size=4, [Person [age=99, name=ghost], Person [age=20, name=rose], null, null]
remove()删除元素: size=3, [Person [age=20, name=rose], null, null]
clear()清空数组: size=0, []
泛型动态数组源码（C++）
一时兴起写了个C++版本的动态数组。。。如果可以的话，希望后面的数据结构都可以用C++自己实现一遍。。（目前只写了这个）
#include<iostream>
using namespace std;
#define ELEMENT_NOT_FOUND -1;
template<typename E>
class Array
{
private:
int m_size; // 元素数量
int m_capacity; // 数组容量
E * m_elements; // 指向首地址
void outOfBounds(int index) {
throw index;
}
void rangeCheck(int index); // 检查下标(get,set)
void rangeCheckForAdd(int index); // 检查下标(add)
void ensureCapacity(int capacity); // 检查容量及扩容
public:
Array(int capacity = 10);
~Array();
int size(); // 元素的数量
bool isEmpty(); // 是否为空
int indexOf(E element); // 查看元素的位置
bool contains(E element); // 是否包含某个元素
E set(int index, E element); // 设置index位置的元素
E get(int index); // 返回index位置对应的元素
void add(int index, E element); // 往index位置添加元素
void add(E element); // 添加元素到最后面
E remove(int index); // 删除index位置对应的元素
void clear(); // 清除所有元素
};
template<typename E>
void Array<E>::rangeCheck(int index) {
if (index < 0 || index >= m_size)
outOfBounds(index);
}
template<typename E>
void Array<E>::rangeCheckForAdd(int index) {
if(index < 0 || index > m_size)
outOfBounds(index);
}
template<typename E>
void Array<E>::ensureCapacity(int capacity) {
int oldCapacity = m_capacity;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E *newElements = new E[newCapacity];
for (int i = 0; i < m_size; i++) {
newElements[i] = m_elements[i];
}
delete[] m_elements; // 释放原空间
m_elements = newElements;
m_capacity = newCapacity;
cout << oldCapacity << "扩容为" << newCapacity << endl;
}
template<typename E>
Array<E>::Array(int capacity) {
m_capacity = (capacity < 10) ? 10 : capacity;
m_elements = new E[m_capacity];
}
template<typename E>
Array<E>::~Array() {
delete[] m_elements;
}
template<typename E>
int Array<E>::size(){
return m_size;
}
template<typename T>
bool Array<T>::isEmpty() {
return m_size == 0;
}
template<typename E>
int Array<E>::indexOf(E element) {
for (int i = 0; i < m_size; i++) {
if (m_elements[i] == element) return i;
}
return ELEMENT_NOT_FOUND;
}
template<typename E>
bool Array<E>::contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
template<typename E>
E Array<E>::set(int index, E element) {
rangeCheck(index);
E old = element;
m_elements[index] = element;
return old;
}
template<typename E>
E Array<E>::get(int index) {
rangeCheck(index);
return m_elements[index];
}
template<typename E>
void Array<E>::add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacity(m_size + 1);
// 0 1 2 3 4 5
// 1 2 3 5 6 7
// index=3, element=4
for (int i = m_size; i > index; i--) {
m_elements[i] = m_elements[i-1];
}
m_elements[index] = element;
m_size++;
}
template<typename E>
void Array<E>::add(E element) {
add(m_size, element);
}
template<typename E>
E Array<E>::remove(int index) {
rangeCheck(index);
E old = m_elements[index];
// 0 1 2 3 4 5
// 1 2 3 5 6 7
// index=2
for (int i = index; i < m_size; i++) {
m_elements[i] = m_elements[i + 1];
}
m_elements[--m_size] = NULL;
return old;
}
template<typename E>
void Array<E>::clear() {
// m_elements = nullptr; // 不可行，直接清除了整个指针指向的地址
for (int i = 0; i < m_size; i++) {
m_elements[i] = NULL;
}
m_size = 0;
}
int main() {
Array<int> array;
for (int i = 0; i < 30; i++) {
array.add(i);
}
cout << "array.set(0, 99): " << array.set(0, 99) << endl;
cout << "array.remove(0): " << array.remove(0) << endl;
cout << "array.isEmpty(): " << array.isEmpty()<< endl;
cout << "array.cotains(5): " << array.contains(5) << endl;
cout << "size = " << array.size() << endl;
array.add(10, 99);
cout << "array.add(10, 99), size = " << array.size() << endl;
for (int i = 0; i < array.size() ; i++) {
if (i != 0) {
cout << ", ";
}
cout << array.get(i);
}
}
10扩容为15
15扩容为22
22扩容为33
array.set(0, 99): 99
array.remove(0): 99
array.isEmpty(): 0
array.cotains(5): 1
size = 29
array.add(10, 99), size = 30
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 99, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
测试运行：
public static void main(String[] args) {
ArrayList<Person> list = new ArrayList<>();
list.add(new Person(10, "jack"));
list.add(new Person(20, "rose"));
list.add(null);
list.add(null);
System.out.println("add()添加元素: " + list);
System.out.println("get()获取元素: " + list.get(0));
list.set(0, new Person(99, "ghost"));
System.out.println("set()设置元素值: " + list);
list.remove(0);
System.out.println("remove()删除元素: " + list);
list.clear();
System.out.println("clear()清空数组: " + list);
}
add()添加元素: size=4, [Person [age=10, name=jack], Person [age=20, name=rose], null, null]
get()获取元素: Person [age=10, name=jack]
set()设置元素值: size=4, [Person [age=99, name=ghost], Person [age=20, name=rose], null, null]
remove()删除元素: size=3, [Person [age=20, name=rose], null, null]
clear()清空数组: size=0, []
1
2
3
4
5
泛型动态数组源码（C++）
一时兴起写了个C++版本的动态数组。。。如果可以的话，希望后面的数据结构都可以用C++自己实现一遍。。（目前只写了这个）
#include<iostream>
using namespace std;
#define ELEMENT_NOT_FOUND -1;
template<typename E>
class Array
{
private:
int m_size; // 元素数量
int m_capacity; // 数组容量
E * m_elements; // 指向首地址
void outOfBounds(int index) {
throw index;
}
void rangeCheck(int index); // 检查下标(get,set)
void rangeCheckForAdd(int index); // 检查下标(add)
void ensureCapacity(int capacity); // 检查容量及扩容
public:
Array(int capacity = 10);
~Array();
int size(); // 元素的数量
bool isEmpty(); // 是否为空
int indexOf(E element); // 查看元素的位置
bool contains(E element); // 是否包含某个元素
E set(int index, E element); // 设置index位置的元素
E get(int index); // 返回index位置对应的元素
void add(int index, E element); // 往index位置添加元素
void add(E element); // 添加元素到最后面
E remove(int index); // 删除index位置对应的元素
void clear(); // 清除所有元素
};
template<typename E>
void Array<E>::rangeCheck(int index) {
if (index < 0 || index >= m_size)
outOfBounds(index);
}
template<typename E>
void Array<E>::rangeCheckForAdd(int index) {
if(index < 0 || index > m_size)
outOfBounds(index);
}
template<typename E>
void Array<E>::ensureCapacity(int capacity) {
int oldCapacity = m_capacity;
if (oldCapacity >= capacity) return;
// 新容量为旧容量的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
E *newElements = new E[newCapacity];
for (int i = 0; i < m_size; i++) {
newElements[i] = m_elements[i];
}
delete[] m_elements; // 释放原空间
m_elements = newElements;
m_capacity = newCapacity;
cout << oldCapacity << "扩容为" << newCapacity << endl;
}
template<typename E>
Array<E>::Array(int capacity) {
m_capacity = (capacity < 10) ? 10 : capacity;
m_elements = new E[m_capacity];
}
template<typename E>
Array<E>::~Array() {
delete[] m_elements;
}
template<typename E>
int Array<E>::size(){
return m_size;
}
template<typename T>
bool Array<T>::isEmpty() {
return m_size == 0;
}
template<typename E>
int Array<E>::indexOf(E element) {
for (int i = 0; i < m_size; i++) {
if (m_elements[i] == element) return i;
}
return ELEMENT_NOT_FOUND;
}
template<typename E>
bool Array<E>::contains(E element) {
return indexOf(element) != ELEMENT_NOT_FOUND;
}
template<typename E>
E Array<E>::set(int index, E element) {
rangeCheck(index);
E old = element;
m_elements[index] = element;
return old;
}
template<typename E>
E Array<E>::get(int index) {
rangeCheck(index);
return m_elements[index];
}
template<typename E>
void Array<E>::add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacity(m_size + 1);
// 0 1 2 3 4 5
// 1 2 3 5 6 7
// index=3, element=4
for (int i = m_size; i > index; i--) {
m_elements[i] = m_elements[i-1];
}
m_elements[index] = element;
m_size++;
}
template<typename E>
void Array<E>::add(E element) {
add(m_size, element);
}
template<typename E>
E Array<E>::remove(int index) {
rangeCheck(index);
E old = m_elements[index];
// 0 1 2 3 4 5
// 1 2 3 5 6 7
// index=2
for (int i = index; i < m_size; i++) {
m_elements[i] = m_elements[i + 1];
}
m_elements[--m_size] = NULL;
return old;
}
template<typename E>
void Array<E>::clear() {
// m_elements = nullptr; // 不可行，直接清除了整个指针指向的地址
for (int i = 0; i < m_size; i++) {
m_elements[i] = NULL;
}
m_size = 0;
}
int main() {
Array<int> array;
for (int i = 0; i < 30; i++) {
array.add(i);
}
cout << "array.set(0, 99): " << array.set(0, 99) << endl;
cout << "array.remove(0): " << array.remove(0) << endl;
cout << "array.isEmpty(): " << array.isEmpty()<< endl;
cout << "array.cotains(5): " << array.contains(5) << endl;
cout << "size = " << array.size() << endl;
array.add(10, 99);
cout << "array.add(10, 99), size = " << array.size() << endl;
for (int i = 0; i < array.size() ; i++) {
if (i != 0) {
cout << ", ";
}
cout << array.get(i);
}
}
10扩容为15
15扩容为22
22扩容为33
array.set(0, 99): 99
array.remove(0): 99
array.isEmpty(): 0
array.cotains(5): 1
size = 29
array.add(10, 99), size = 30
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 99, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21,
#include <iostream>
#include <vector>
#include <map>
using namespace std;
class Solution{
public:
vector<int> TwoSum(vector<int> &nums, int target){
int nums_size = nums.size();
vector<int> sss;
map<int, int> nums_map; //定义哈希表
nums_map[nums[0]] = 0;
for(int i = 1; i < nums_size; i++){
if(nums_map.count(target - nums[i]) > 0){ //查找哈希表中元素，当找到返回数组下标
//return vector<int>({nums_map[target - nums[i]], i});
sss.push_back(nums_map[target - nums[i]]);
sss.push_back(i);
return sss;
}
else //未找到，将当前值放入哈希表
nums_map[nums[i]] = i;
}
//return vector<int>({});
return sss;
}
};
int main()
{
Solution big;
int flag, t;
int temp;
vector<int> a;
//输入数组大小
cout << "please input the size of array:" << endl;
cin >> flag;
//输入数组元素
cout << "please input array elements: " << endl;
for(int i=0; i < flag; i++)
{
cin >> temp;
a.push_back(temp);
}
//输入目标值
cout << "please input target :" << endl;
cin >> t;
vector<int> b = big.TwoSum(a, t);
if(b.size() != 0) //判断是否找到
cout << "[" << b[0] << "," << b[1] << "]" << endl;
else
cout << "No match" << endl;
}
#include <iostream>
#include <vector>
#include <map>
using namespace std;
vector <int> twoSum(vector<int>num ,int target)
{
map <int,int>mapping;
vector <int> result;
for (int i=0;i<num.size();i++)
mapping[num[i]]=i;
for (int i=0;i<num.size();i++)
{
int gap=target-num[i];
if (mapping.find(gap)!=mapping.end())
{
result.push_back(i+1);
result.push_back(mapping[gap]+1);
break;
}
}
return result;
}
int main()
{
int a[4]={2,11,7,15};
vector<int> arr(a,a+4);
vector <int> index;
int target=9;
index=twoSum(arr,target);
cout<<"index1= "<<index[0]<<endl<<"index2="<<index[1]<<endl;
return 0;
}