精华内容
下载资源
问答
  • 为了实现一个动态数组类的封装,我们需要考虑几个问题:new/delete的使用、内存分配策略、类的四大函数(构造函数、拷贝构造函数、拷贝赋值运算符、析构函数)、运算符的重载。涉及到的知识点很多,对此本文只做简单...
  • C++中用new动态创建二维数组的格式一般是这样:TYPE (*p)[N] = new TYPE [][N]; 其中,TYPE是某种类型,N是二维数组的列数。采用这种格式,列数必须指出,而行数无需指定。在这里,p的类型是TYPE*[N],即是指向一个...
  • Java实现 蓝桥杯 算法训练 动态数组使用

    万次阅读 多人点赞 2019-06-11 20:37:23
    算法训练 动态数组使用 时间限制:1.0s 内存限制:512.0MB 提交此题 从键盘读入n个整数,使用动态数组存储所读入的整数,并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其...

    算法训练 动态数组使用
    时间限制:1.0s 内存限制:512.0MB
    提交此题
    从键盘读入n个整数,使用动态数组存储所读入的整数,并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其整数部分。
    样例输入:
    5
    3 4 0 0 2
    样例输出:
    9 1
    样例输入:
    7
    3 2 7 5 2 9 1
    样例输出:
    29 4

    import java.util.Scanner;
    
    
    public class 动态数组使用 {
    	public static void main(String[] args)  {
    		Scanner sc = new Scanner(System.in);
    		int n = sc.nextInt();
    		sc.nextLine();
    		int a[] = new int[n];
    		int sum = 0;
    		for (int i = 0; i < a.length; i++) {
    			a[i] = sc.nextInt();
    			sum += a[i];
    		}
    		int avg = sum/n;
    		System.out.println(sum+" "+avg);
    	}
    
    
    }
    
    
    展开全文
  • 主要介绍了go 动态数组 二维动态数组,本文通过实例代码给大家介绍的非常详细,对大家的学习或工作具有一定的参考借鉴价值,需要的朋友可以参考下
  • 主要介绍了C++中关于[]静态数组和new分配的动态数组的区别分析,很重要的概念,需要的朋友可以参考下
  • 主要介绍了Java封装数组之动态数组实现方法,结合实例形式详细分析了java动态数组的实现原理、操作步骤与相关注意事项,需要的朋友可以参考下
  • 主要介绍了Python如何实现动态数组,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
  • C# 数组_C#动态数组详解整理

    千次阅读 2021-01-30 14:55:03
    使用如下: int[] nums = new int[] {1,2,3 }; Array 中定义的常用属性 Length -- 数组个数 Rank---数组纬度 LongLength---多维度数组中,数据总个数。 Array 中定义的方法 实例方法:下标访问数组 ..

    一、C# 数组  Array

    简介

    namespace System
    
     public abstract class Array

    Array 类 (抽象类) 是C#中所有数组的基类,在System命名空间下。

    使用如下:

     int[] nums = new int[] {1,2,3 };

    Array 中定义的常用属性

    Length -- 数组个数

    Rank---数组纬度

    LongLength---多维度数组中,数据总个数。

     

    Array 中定义的方法

    实例方法:下标访问数组

                int[] nums = new int[] {1,2,3 };
                nums.SetValue(1,10);
                nums.GetValue(1);

    静态方法:

                //使用不多了,因为Linq的出现,使用更方便
                Array.Sort();
                Array.Reverse();
                Array.Copy();

     

    二、C# 动态数组  /  集合

    1. ArrayList 动态数组

    个数动态,类型动态,可以 跟JavaScript  的Array 对应。

    命名空间 : namespace System.Collections

    ArrayList 常用属性:

    Count ---数组个数

     

    ArrayList 常用方法:

    添加:Add(),Insert(),InsertRange()

    删除:Remove(),RemoveAt(),RemoveRange(), Clear()

    排序: Sort()   ,Reverse() 

    复制: Copy()

    案例:

                //动态数组
                ArrayList arrayList = new ArrayList();
                arrayList.Add(1);
                arrayList.Add("张三");

     

    2.字典数组 Dictionary<T,T>

     

    Dictionary 常用属性

    Count----数组个数

     

    Dictionary 常用方法

    添加: Add()

    移除: Remove() , Clear()

     

    案例:

                Dictionary<int, string> dic = new Dictionary<int, string>();
                dic.Add(1, "分类1");
                dic.Add(2, "分类2");

     

     

    3.List<T> 泛型集合 ,(主流,使用更灵活,尤其搭载Linq)

    List 常用属性

    Count---列表个数

     

    List 常用方法

    添加:Add(),AddRange()

    删除:Remove(),RemoveAt(),RemoveRange(), Clear()

    排序: Sort()   ,Reverse() 

    复制: Copy()

     

    跟数组转换:ToArray()

     

     

     

    更多:

    DotNet 开发项目类型整理_C#开发项目类型整理

     C#面向对象_C#面向对象开发开发整理

     C#面向对象_静态和实例,静态类和实例类,静态成员和实例成员

    展开全文
  • 主要介绍了Java动态数组添加数据的方法,结合实例形式详细分析了Java动态数组的创建、添加、查找、打印等相关操作技巧,需要的朋友可以参考下
  • C语言创建动态数组

    2012-07-23 10:11:35
    本文讲述了如何C语言也能创建动态数组的技巧,通过代码实例来演示分析,让你进一步了解数组的动态创建技巧与代码的艺术。
  • 请实现一个简单的动态数组,能够随时改变大小,不会溢出,也不会浪费内存空间。 下面的代码实现了简单的动态数组: #include #include int main() { //从控制台获取初始数组大小 int N; int *a; int i; ...
  • 主要介绍了C语言动态数组使用实现代码的相关资料,需要的朋友可以参考下
  • Delphi样例代码:演示动态数组、静态数组、TBytes 的区别,以及结合TMemoryStream的使用
  • C++动态数组模板实现

    2014-06-01 22:49:24
    课本内容简单实现,通过动态数组模板
  • Java自定义动态数组

    千次阅读 2019-02-15 00:38:33
    Java自定义动态数组 1、静态数组向动态数组转变 (1)静态数组,数组空间固定长度 这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足   (2)静态数组如何转变成动态数组 第一步:创建...

    Java自定义动态数组

    1、静态数组向动态数组转变

    (1)静态数组,数组空间固定长度

    这个数组空间总长为4,如果此时新插入一个数据就会报数组空间不足

     

    (2)静态数组如何转变成动态数组

    第一步:创建一个空间是data数组两倍的newData数组(扩容);

    第二步:把data数组中的元素全部赋值到newData数组;

     

    2、数组扩容程序

    // 数组扩容
    private void resize(int newCapacity){
       
    E[] newData = (E[]) new Object[newCapacity];
        for
    (int i = 0; i < size; i++) {
            newData[i] =
    data[i];
       
    }
       
    data = newData;
    }

    数组添加元素:数组空间不够就会扩容(原来空间2倍)

        // 数组指定位置添加元素
       
    public void add(int index, E e) {
    //        if (size == data.length)
    //            throw new IllegalArgumentException("Add failed.Array is full.");
           
    if (index < 0 || index > size)
               
    throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
            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++;
       
    }

    数组删除元素:数组空间空闲太大就会缩容(原来空间的1/2)

    // 从数组中删除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--;
        
    // loitering objects != memory leak 手动释放内存空间
       
    data[size] = null;
        if
    (size == data.length / 2) {
            resize(
    data.length / 2);
       
    }
       
    return ret;
    }

     

    3、数组整体代码

    public class Array<E> {
       
    // 定义数组变量,data.length表示数组容量capacity
       
    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 int getSize() {
           
    return size;
       
    }

       
    // 获取数组的容量
       
    public int getCapacity() {
           
    return data.length;
       
    }

       
    // 判断数组是否为空
       
    public boolean isEmpty() {
           
    return size == 0;
       
    }

    /*    // 在数组末尾添加元素
        public void addLast(E e) {
            if (size == data.length)
                throw new IllegalArgumentException("AddLast failed.Array is full.");
            data[size] = e;
            size++;
        }*/

        // 在数组末尾添加元素(复用add方法)
       
    public void addLast(E e) {
            add(
    size, e);
       
    }

       
    // 在数组头部添加元素(复用add方法)
       
    public void addFirst(E e) {
            add(
    0, e);
       
    }

       
    // 数组指定位置添加元素
       
    public void add(int index, E e) {
    //        if (size == data.length)
    //            throw new IllegalArgumentException("Add failed.Array is full.");
           
    if (index < 0 || index > size)
               
    throw new IllegalArgumentException("Add failed. Require index >= 0 and index <= size");
            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++;
       
    }

       
    // 获取index索引位置的元素
       
    public E get(int index) {
           
    if (index < 0) {
               
    throw new IllegalArgumentException("Get failed.Index is illegal.");
           
    }
           
    return data[index];
       
    }

       
    // 修改index索引位置的元素
       
    public void set(int index, E e) {
           
    if (index < 0 || index >= size) {
               
    throw new IllegalArgumentException("Set failed.Index is illegal.");
           
    }
           
    data[index] = e;
       
    }

       
    // 查找数组中是否存在元素e
       
    public boolean contains(E e) {
           
    for (int i = 0; i < size; i++) {
               
    if (data[i] == e) {
                   
    return true;
               
    }
            }
            
    return false;
       
    }

       
    // 查找数组中元素e所在的索引,如果不存在元素e,则返回-1
       
    public int find(E e) {
           
    for (int i = 0; i < size; i++) {
               
    if (data[i] == e) {
                   
    return i;
               
    }
            }
           
    return -1;
       
    }

       
    // 从数组中删除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--;
           
    // loitering objects != memory leak 手动释放内存空间
           
    data[size] = null;
            if
    (size == data.length / 2) {
                resize(
    data.length / 2);
           
    }
           
    return ret;
        
    }

       
    // 删除数组第一个元素,返回删除的元素
       
    public E removeFirst() {
           
    return remove(0);
       
    }

       
    // 删除数组最后一个元素
       
    public E removeLast() {
           
    return remove(size - 1);
       
    }

       
    // 删除数组中指定元素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;
       
    }

       
    // 重写父类toString()方法
       
    @Override
       
    public String toString() {
            StringBuilder sb =
    new StringBuilder();
           
    sb.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
           
    sb.append('[');
            for
    (int i = 0; i < size; i++) {
                sb.append(
    data[i]);
                if
    (i != size - 1) {
                    sb.append(
    ',');
               
    }
            }
            sb.append(
    ']');
            return
    sb.toString();
       
    }
    }

    4、数组测试代码

    public class ArrayTest {
       
    public static void main(String[] args) {
           
    // 测试toString()方法
           
    Array<Integer> arr = new Array(10);
            for
    (int i = 0; i < 10; i++) {
               
    // 测试addLast(int e)方法
                
    arr.addLast(i);
           
    }
            System.
    out.println("添加数组元素:");
           
    System.out.println(arr);

           
    // 测试add(int index, int e)方法
           
    arr.add(1, 200);
           
    System.out.println("在数组指定索引位置插入元素e:");
           
    System.out.println(arr);

           
    // 测试addFirst(int e)方法
           
    arr.addFirst(-10);
           
    System.out.println("在数组头部位置插入元素e:");
           
    System.out.println(arr);

        }
    }

    测试结果如下所示:初始化数组空间大小为10,第一次插入10个元素到数组之后,然后再添加一个元素,此时数组会扩容为原来空间的两倍。

    添加数组元素:

    Array: size = 10 , capacity = 10

    [0,1,2,3,4,5,6,7,8,9]

    在数组指定索引位置插入元素e:

    Array: size = 11 , capacity = 20

    [0,200,1,2,3,4,5,6,7,8,9]

    在数组头部位置插入元素e:

    Array: size = 12 , capacity = 20

    如果感兴趣的童鞋,可以观看我下一篇博客:简单复杂度分析

    展开全文
  • 主要介绍了Shell动态生成数组的多种方法,本文给出while循环法和for循环法,以及使用seq生成数组法,需要的朋友可以参考下
  • #通过python实现动态数组 """ 数组特点: 占用一段连续的内存空间,支持随机(索引)访问,且时间复杂度为O(1) 添加元素时间复杂度:O(n) 删除元素时间复杂度:O(n) """ class Arr: def __init__(self, capacity...
  • 动态数组使用

    2012-08-22 09:38:58
    动态数组基本使用,C#代码,一些最基本的使用,主要数组定义值得记忆。
  • Java动态数组

    千次阅读 多人点赞 2018-07-18 10:38:44
    1.Java动态数组的用法详解  Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。 ...

    1.Java动态数组的用法详解

         Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。

     语法:add()是添加一个新的元素,remove()删除一个元素,size()获得ArrayList的长度。ArrayList的下标是从0开始。

    import java.util.ArrayList;
     
    public class JavaArrayList {
    	public static void main(String[] args) {
    		// Java动态数组的初始化
    		ArrayList al = new ArrayList();
    		// 向Java动态数组中添加数据
    		al.add("a");
    		al.add("b");
    		al.add("c");
    		// 输出Java动态数组
    		for (int i = 0; i < al.size(); i++) {
    			String alEach = (String) al.get(i);
    			System.out.println(alEach);
    		}
    		// 删除数组中的某个元素,删除第二个元素
    		al.remove(1);
    		// 修改Java动态数组,把新的元素放到第二个位置
    		al.add(1, "2");
    		// //输出Java动态数组
    		for (int i = 0; i < al.size(); i++) {
    			String alEach = (String) al.get(i);
    			System.out.println(alEach);
    		}
    	}
    }
    

    2.动态数组实现(ArrayList原理)

    2.1 什么是数组

            同类数据元素的集合,在计算机中以连续的地址存储,编译时确定长度,无法改变。

    2.2 什么是动态数组

           数据结构中顺序表的物理实现,同类数据元素的集合,在计算机中以连续的地址存储,大小在创建时决定,但是可以改变。

    2.3 为什么使用动态数组

           支持随机访问,查询速度快。但是插入和删除都需要移动元素,比起链表开销较大。如:java集合类中的ArrayList Vector等

    2.4 动态数组实现代码(ArrayList原理)

    /**
     * 顺序表的实现
     * @author chengh
     * @param 
     */
    public class ArrayList<E> {
        private Object[] data = null; // data: 用来保存此线性表数据的数组
        private int capacity; // capacity: 线性表的容量
        private int current; // current: 当前数据的下标
        /**
         * 初始化为声明大小,则设置为10。
         */
        ArrayList() {
            this(10);
        }
        /**
         * 初始化线性表,声明保存数据的数组大小。
         * @param initialSize 顺序表的初始化大小
         */
        ArrayList(int initialSize) {
            if (initialSize >= 0) {
                this.capacity = initialSize;
                data = new Object[initialSize];
                current = 0;
            } else {
                throw new RuntimeException("初始化大小不能小于0:" + initialSize);
            }
        }
        /**
         * 在线性表的末尾添加元素,添加之前确认线性表是否已满
         * @param e 待加入的元素
         * @return
         */
        public boolean AddElement(E e) {
            ensureCapacity();
            data[current] = e;
            ++current;
            return true;
        }
        /**
         * 检查存储数据的数组容量,如果数组已经满,则扩充容量;否则不操作。
         */
        private void ensureCapacity() {
            int index;
            if (current == capacity) {
                capacity *= 2;
                Object[] newData = new Object[capacity];
                for(index = 0; index < current; ++index) {
                    newData[index] = data[index];
                }
                data = newData;
            }
        }
        /**
         * 返回下标为index的元素
         * @param index 欲取得元素的下标
         * @return
         */
        public E get(int index) {
            validateIndex(index);
            return (E) data[index];
        }
        /**
         * 
         * @param index 待插入的位置
         * @param e 待插入的元素
         * @return
         */
        public boolean set(int index, E e) {
            validateIndex(index);
            data[index] = e;
            return true;
        }
        /**
         * 验证下标值是否合法,非法时抛出异常
         * @param index 待验证的下标值
         */
        private void validateIndex(int index) {
            if (index < 0 || index > current) {
                throw new RuntimeException("无效的下标:" + index);
            }
        }
        /**
         * 返回当前顺序表的大小
         * @return
         */
        public int size() {
            return current;
        }
        /**
         * 在指定位置插入指定元素
         * @param index 待插入的位置
         * @param e 待插入的元素
         * @return
         */
        public boolean insert(int index, E e) {
            validateIndex(index);
            ensureCapacity();
            for (int temp = current; temp > index; --temp) {
                data[temp] = data[temp - 1];
            }
            data[index] = e;
            return true;
        }
        /**
         * 删除下标为index元素
         * @param index 待删除元素的下标
         * @return
         */
        public boolean delete(int index) {
            validateIndex(index);
            for ( ; index < current - 1; ++index) {
                data[index] = data[index + 1];
            }
            data[current - 1] = null;
            --current;
            return true;
        }
        @Override
        public String toString() {
            String str = "[ ";
            for (Object o : data) {
                if (o != null) {
                    str += o + " ";
                }
            }
            str += "]";
            return str;
        }
    } 

     

    展开全文
  • 直入主题,什么是动态数组?怎么?概念上的东西不多说了,看例子! 正文 // 什么是动态数组?什么时候?有什么看例子: // // 定义数组:Dim 数组名(下标),数组长度已被锁定! Dim GG(3) //定义一个数组GG,...
  • 从一个文件中读取数据,然后保存到一个动态的数组中,这个动态数组是动态申请的,而不是静态的数组。
  • VBS中的动态数组需要使用System.Collections.ArrayList,需要的朋友可以参考下
  • 动态数组:c++中数组有时候不用在编译时就知道长度,直到运行时才知道,这就是动态数组,也就是可以动态分配长度的数组。与静态数组变量区别是,动态分配的数组空间将一直存在,直到程序显式的释放它为止。定义一个...
  • 插入排序算法(动态数组实现) printf("--------插入排序算法的实现--------\n"); printf("输入数组的大小length:\n"); int length=0; scanf("%d",&length); /****动态分配内存初始化数组*********************...
  • C语言静态数组常常接触,因为静态数组简单好用,使用动态数组不如使用链表,动态数组处境尴尬。
  • 本文给大家分享java版和C语言版简单使用静态语言实现动态数组的方法,非常不错,具有参考借鉴价值,需要的朋友参考下吧
  • C语言的动态数组 VS C++的动态数组

    千次阅读 2018-08-26 19:37:09
    C语言中的动态数组 C语言中的动态数组就是动态内存分配的知识 首先,先看C语言的那些小秘密之动态数组https://blog.csdn.net/bigloomy/article/details/6615012,里面有关内存分配的内容,请看C语言的那些小秘密之...
  • vector是指能够存放任意类型的动态数组,而C语言中并没有面向对象的C++那样内置vector类,所以我们接下来就来看一下使用C语言实现vector动态数组的实例,需要的朋友可以参考下

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 813,441
精华内容 325,376
关键字:

动态数组怎么用