码迷,mamicode.com
首页 > 编程语言 > 详细

数据结构与算法之数组

时间:2020-07-17 11:38:06      阅读:65      评论:0      收藏:0      [点我收藏+]

标签:添加元素   vat   内存地址   指针   描述   public   序列   操作   不可   

数组

  • 实现一个支持动态扩容的数组
  • 实现一个大小固定的有序数组,支持动态增删改操作
  • 实现两个有序数组合并为一个有序数组

总结:数组扩容优先考虑使用Array的静态方法Resize,其次考虑把一个扩容的、临时的数组赋值给原数组。

 

什么是数据结构?

  • 数据结构是计算机存储、组织数据的方式;
    技术图片
  • 在实际应用中,根据使用场景来选择最合适的数据结构;

线性表

线性表是具有 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;
}

数据结构与算法之数组

标签:添加元素   vat   内存地址   指针   描述   public   序列   操作   不可   

原文地址:https://www.cnblogs.com/hrnn/p/13322992.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!