算法：C语言实现一个动态数组

已于 2022-03-17 09:55:05 修改
阅读量3.7k 收藏 18
点赞数 7
分类专栏： 算法与数据结构 文章标签： 算法 c语言 数据结构
于 2020-12-10 18:09:33 首次发布
原文链接：https://github.com/acl-dev/demo
版权

实现

空间自增长

前提： 确保array已经初始化了

1、调用时机：

  • 当array要容纳的元素个数超过了数组的容量

2、需要什么条件：

  • array的首地址
  • array要存放的元素个数（原来的个数+期望的个数）

3、怎么做

(1)、判断array的容量是否超过了要存放的元素个数

  • 是：返回
  • 不是：到(3)

(2)、计算新要申请的容量（规定为16的倍数）

  • 初始化为要存放的元素个数
  • 要之变成16的倍数
  • 如果计算出的容量为0，直接返回

(3)、更新本次增长之后数组要达到的容量 = 原来的容量 + 本次要申请的容量

(4)、开始向内核申请空间，空间大小为array.capacity*sizeof(void *)。 因为item为二级指针，指向一个指向void连续的空间的指针

  • 如果原来array中没有存放元素，使用malloc申请
  • 如果原来array中存放了元素，使用realloc申请
    • 如果array之后的堆空间组以增长到需要的空间，申请这段空间，然后将原来的地址返回
    • 否则内核从内存空间中找一块足够大的空间，将原来的内容复制过去，然后将新内存首地址返回，最后释放老的空间

(5)、使用memset初始化刚刚申请的空间为NULL

// 功能： 令array的空间足以容纳min_capacity个元素
void private_array_grow(ACL_ARRAY *a, int min_capacity){
    int min_delta = 16;
    int delta;
    // 如果数组本身的容量就足够了，就直接返回
    if(a->capacity > min_capacity){
        return;
    }

    // 计算出需要新申请多少空间（强制为16的倍数）
    /*        0       0
     *        1-16    16
     *        17-32   32
     * */
    delta = min_capacity;
    delta += min_delta-1;
    delta /= min_delta;
    delta *= min_delta;
    if(delta < 0){
        return;
    }
    a->capacity += delta;
    if (a->items) {
        a->items = (void **) realloc(a->items, a->capacity * sizeof(void *));
    } else {
        a->items = (void **) malloc(a->capacity * sizeof(void *));
    }

    /*
     * 使用0初始化刚刚申请到的内存:
     * [从items起，后移动count个元素]作为起始位置，使用0初始化'没有存放元素[数组总容量-已经存放了元素的内存]'的内存
     * */
    memset(a->items + a->count, 0, (a->capacity - a->count) * sizeof(void *));
}

向动态数组尾部添加动态成员变量

前提： 确保array已经初始化了

1、功能：向动态数组尾部添加动态成员变量

2、参数：

  • array的首地址
  • 要存放的元素obj： 这个元素是一个指针，指向任意类型的空间

3、返回值：返回当前存放位置的索引

4、怎么做

(1)、 确认是不是有足够的空间来存放这个元素

  • 判断条件：如果数组当前索引count等于数组的容量，向内核申请新的空间，新空间大小是count + 1

(2)、放置元素

  • array[count++] = obj

(3)、返回当前存放元素的索引 count - 1

//  令array当前元素索引指向一个任意类型的指针
int private_array_push(ACL_ARRAY *a, void *obj)
{
    if (a->count >= a->capacity)
        private_array_grow(a, a->count + 16);
    a->items[a->count++] = obj;
    return(a->count - 1);
}

从动态数组弹出最后一个元素

前提： 确保array已经初始化了

1、功能：从动态数组弹出最后一个元素

ps：count为下一个元素要存放的索引，也是整个数组存放的元素个数

2、需要些什么

  • array元素的首地址
  • 需要返回最后存放的元素

3、返回值：

  • 返回弹出的元素

4、怎么做：
(1)、判断当前数组是否存放了元素， 判断条件：count == 0

  • 如果没有，返回NULL
  • 存放了，跳到（2）

(2)、找到要弹出的索引：count不仅是元素个数，还是元素下一个要存放的索引，所以想要找到上次的索引，直接减少1就好，count–不仅找到了上次存放位置的索引，也让元素个数减少了1

(3)、用一个临时值将这个索引指向的空间存储起来，以便最终返回

(4)、 令array[count] = NULL

void * private_array_pop(ACL_ARRAY *a){
    void *ptr;

    if(a->count == 0){
        return (NULL);
    }

    a->count--;
    ptr = a->items[a->count];
    a->items[a->count] = NULL;
    return ptr;
}

返回array元素的个数

  1. 需要什么：
  • array的首地址

2、返回什么？

  • 元素个数

3、怎么做？

  • 如果array==NULL，返回-1
  • 否则，返回a.count
int private_array_size(const ACL_ARRAY *a)
{
	if(a == NULL)
		return(-1);
	return(a->count);
}

返回索引idx的值

前提： 确保array已经初始化了

1、功能： 如果我们想要取出索引idx处的元素怎么做？

2、需要什么？

  • array的首地址
  • 要寻值的索引

3、返回值：

  • 返回找到的值

4、怎么做：

(1)、确保索引有效： 如果索引无效返回NULL

  • idx必须大于-1 & index 小于count[下一个元素的索引]

(2)、从items中找到存储的值

void *private_array_index(const ACL_ARRAY *a, int idx)
{
    if(idx < 0 || idx > a->count - 1)
        return(NULL);

    return(a->items[idx]);
}

删除索引idx处的元素

1、需要什么？

  • array首地址
  • 待删除元素的索引
  • 是否需要释放索引指向的空间，如果需要，那么如何释放索引指向的那个元素

2、返回值

  • -1表示删除失败
  • 0表示删除成功

3、怎么做？

(1)、判断array是否初始化

  • 没有初始化，返回-1
  • 初始化了，跳到(2)
    (2)、判断索引是否越界
  • 越界，返回-1
  • 没有越界，跳到(3)

(3)、判断索引指向的空间是否需要释放

  • 如果需要，而且索引指向的空间不为NULL，那么释放，释放之后跳到(4)
  • 如果不需要，跳到(4)

(4)、元素个数减少1

(5)、判断释放元素之后，array是否还存在元素

  • 存放，将最末尾的那个元素移动到刚刚释放的空间的位置，然后跳到(6)
  • 不存放，跳到(6)

(6) 到了这一步，该干的事情已经干完了，返回0

int private_array_delete(ACL_ARRAY *a, int idx, void (*free_fn)(void*))
{
    if (a == NULL)
        return (-1);
    if (idx < 0 || idx >= a->count)
        return (-1);
    if (free_fn != NULL && a->items[idx] != NULL)
        free_fn(a->items[idx]);
    a->count--;
    if (a->count > 0)
        a->items[idx] = a->items[a->count];
    return (0);
}

删除array中的内存obj

1、参数：

  • array的首地址
  • 要删除的内存obj的地址

2、返回值：需要知道是否返回成功

  • -1表示不成功
  • 0表示成功

3、怎么做：
（1）如果数组没有初始化(array == NULL)或者obj==NULL，直接返回0，否则跳到（2）
（2）循环array，如果发现item与obj相等，调用private_array_delete，否则跳到（3）
（3） 直接返回-1

int private_array_delete_obj(ACL_ARRAY *a, void *obj, void (*free_fn)(void*))
{
    int   i;

    if (a == NULL || obj == NULL)
        return (-1);
    for (i = 0; i < a->count; i++) {
        if (a->items[i] == obj) {
            return (private_array_delete(a, i, free_fn));
        }
    }
    return (-1);
}

释放掉动态数组内的成员变量但并不释放动态数组对象

1、需要什么

  • array的首地址
  • 释放数组项的的函数指针free_fn

2、无需返回值

3、怎么做
(1) 如果array 为NULL，直接返回；否则跳到(2)
(2) 循环array，如果free_fn不为NULL & 数组项不为NULL，调用free_fn(数组项)，然后将a->items[idx] = NULL
(3) 最后令a.count = 0

void private_array_clean(ACL_ARRAY *a, void (*free_fn)(void *)){
    for(int i = 0; i < a->count; i++){
        if(free_fn != NULL && a->items[i] != NULL){
            free_fn(a->items);
        }
        a->items[idx] = NULL;	/* sanity set to be null */
    }
    a->count = 0;
}

释放整个数组

1、需要什么

  • array的首地址
  • 释放数组项的的函数指针free_fn

2、无需返回值

void private_array_destroy(ACL_ARRAY *a, void (*free_fn)(void *)){
    private_array_clean(a, free_fn);
    if(a->items){
        free(a->items);
    }
    free(a->items);
}

总结

1、private_array.h

#pragma once

#include "acl_iterator.h"

typedef struct ACL_ARRAY ACL_ARRAY;
struct ACL_ARRAY{
    int     capacity;
    int     count;
    void    **items;

    void  (*push_back)(struct ACL_ARRAY*, void*);
    void  (*push_front)(struct ACL_ARRAY*, void*);
    void *(*pop_back)(struct ACL_ARRAY*);
    void *(*pop_front)(struct ACL_ARRAY*);

    void *(*iter_head)(ACL_ITER*, struct ACL_ARRAY*);
    void *(*iter_next)(ACL_ITER*, struct ACL_ARRAY*);
    void *(*iter_tail)(ACL_ITER*, struct ACL_ARRAY*);
    void *(*iter_prev)(ACL_ITER*, struct ACL_ARRAY*);
};

/**
 * 创建一个动态数组
 * @param init_size {int} 动态数组的初始大小
 * @return {ACL_ARRAY*} 动态数组指针
 */
ACL_ARRAY *private_array_create(int init_size);

/**
 * 释放掉动态数组内的成员变量，但并不释放动态数组对象
 * @param a {ACL_ARRAY*} 动态数组指针
 * @param free_fn {void (*)(void*)} 用于释放动态数组内成员变量的释放函数指针
 */
void private_array_clean(ACL_ARRAY *a, void (*free_fn)(void *));

/**
 * 释放掉动态数组内的成员变量，并释放动态数组对象
 * @param a {ACL_ARRAY*} 动态数组指针
 * @param free_fn {void (*)(void*)} 用于释放动态数组内成员变量的释放函数指针
 */
void private_array_destroy(ACL_ARRAY *a, void (*free_fn)(void *));

/**
 * 向动态数组尾部添加动态成员变量
 * @param a {ACL_ARRAY*} 动态数组指针
 * @param obj {void*} 动态成员变量
 * @return {int} 0: 成功；-1: 失败
 */
int private_array_push(ACL_ARRAY *a, void *obj);

/**
 * 从动态数组中弹出最尾一个对象
 * @param a {ACL_ARRAY*} 动态数组指针
 * @return {void*}, NULL 表示数组为空
 */
void* private_array_pop(ACL_ARRAY *a);

/**
 * 从动态数组中的指定位置删除某个对象，删除后数组内元素的先后顺序有可能发生了改变,
 * 因为删除后会自动将数组中最后的元素移至该位置处
 * @param a {ACL_ARRAY*} 动态数组指针
 * @param position {int} 某个位置，不得越界
 * @param free_fn {void (*)(void*)} 用于释放动态数组内成员变量的释放函数指针，如果该
 *  指针为空，则不释放，否则用此函数进行释放动态对象
 * @return {int} 0: 成功；-1: 失败
 */
int private_array_delete(ACL_ARRAY *a, int idx, void (*free_fn)(void*));

int private_array_delete_obj(ACL_ARRAY *a, void *obj, void (*free_fn)(void*));

/**
 * 从动态数组中的某个下标位置取出动态对象
 * @param a {ACL_ARRAY*} 动态数组指针
 * @param idx {int} 下标位置，不能越界，否则返回-1
 * @return {void*} != NULL: 成功；== NULL: 不存在或失败
 */
void *private_array_index(const ACL_ARRAY *a, int idx);

/**
 * 获得当前动态数组中动态对象的个数
 * @param a {ACL_ARRAY*} 动态数组指针
 * @return {int} 动态数组中动态对象的个数
 */
int private_array_size(const ACL_ARRAY *a);

void private_array_grow(ACL_ARRAY *a, int min_capacity);

#define	PRIVATE_ARRAY_PUSH(a, ptr) do  \
{  \
	if ((a)->count >= (a)->capacity)  \
		private_array_grow((a), (a)->count + 16);  \
	(a)->items[(a)->count++] = (ptr);  \
} while (0)

#define	PRIVATE_ARRAY_POP(a, ptr) do  \
{  \
	if ((a)->count > 0) {  \
		(a)->count--;  \
		(ptr) = (a)->items[(a)->count];  \
		(a)->items[(a)->count] = NULL;  \
	} else {  \
		(ptr) = NULL;  \
	}  \
} while (0)

2、acl_iterator.h

#pragma once
typedef struct ACL_ITER ACL_ITER;
struct ACL_ITER {
    void *ptr;		/**< 迭代器指针, 与容器相关 */
    void *data;		/**< 用户数据指针 */
    int   i;		/**< 当前迭代器在容器中的位置索引 */
    int   size;		/**< 当前容器中元素总个数 */
};

/**
 * 正向遍历容器中元素
 * @param iter {ACL_ITER}
 * @param container {void*} 容器地址
 * @examples: samples/iterator/
 */
#define	ACL_FOREACH(iter, container)  \
        for ((container)->iter_head(&(iter), (container));  \
             (iter).ptr;  \
             (container)->iter_next(&(iter), (container)))

/**
 * 反向遍历容器中元素
 * @param iter {ACL_ITER}
 * @param container {void*} 容器地址
 * @examples: samples/iterator/
 */
#define	ACL_FOREACH_REVERSE(iter, container)  \
        for ((container)->iter_tail(&(iter), (container));  \
             (iter).ptr;  \
             (container)->iter_prev(&(iter), (container)))

/**
 * 获得当前迭代指针与某容器关联的成员结构类型对象
 * @param iter {ACL_ITER}
 * @param container {void*} 容器地址
 */
#define	ACL_ITER_INFO(iter, container)  \
	(container)->iter_info(&(iter), (container))

#define	acl_foreach_reverse	ACL_FOREACH_REVERSE
#define	acl_foreach		ACL_FOREACH
#define	acl_iter_info		ACL_ITER_INFO

3、private_array.c

#include "private_array.h"
#include "private_array.h"
#include <stdlib.h>
#include <memory.h>
#include <assert.h>


//指向数组的首元素
static void *array_iter_head(ACL_ITER *iter, struct ACL_ARRAY *a){
    assert(a != NULL);
    iter->size = a->count;  // 当前容器中元素总个数
    iter->i = 0;   // 当前迭代器在容器中的位置索引
    if(a->items == NULL){
        iter->ptr = iter->data = NULL;
    }else{
        iter->ptr = iter->data = a->items[iter->i];  // 指向当前位置
    }
    return (iter->ptr);
}

// 指向迭代器指针的下一个元素
static void *array_iter_next(ACL_ITER *iter, struct ACL_ARRAY *a){
    assert(a != NULL);
    iter->i++;   // 索引(移动指标)自增1
    if (iter->i >= a->count)
        iter->ptr = iter->data = NULL;
    else
        iter->ptr = iter->data = a->items[iter->i];  
    return (iter->ptr);
}
static void *array_iter_tail(ACL_ITER *iter, struct ACL_ARRAY *a){
    iter->i = a->count - 1;
    iter->size = a->count;
    if (a->items == NULL || iter->i < 0)
        iter->ptr = iter->data = 0;
    else
        iter->ptr = iter->data = a->items[iter->i];
    return (iter->ptr);
}
static void *array_iter_prev(ACL_ITER *iter, struct ACL_ARRAY *a){
    iter->i--;
    if (iter->i < 0)
        iter->ptr = iter->data = NULL;
    else
        iter->ptr = iter->data = a->items[iter->i];
    return (iter->ptr);
}



// min_capacity    至少需要容纳min_capacity个元素
void private_array_grow(ACL_ARRAY *a, int min_capacity){
    int min_delta = 16;
    int delta;
    // 如果数组本身的容量就足够了，就直接返回
    if(a->capacity > min_capacity){
        return;
    }

    // 计算出需要新申请多少空间（强制为16的倍数）
    /*        0       0
     *        1-16    16
     *        17-32   32
     * */
    delta = min_capacity;
    delta += min_delta-1;
    delta /= min_delta;
    delta *= min_delta;
    if(delta < 0){
        return;
    }
    a->capacity += delta;
    if (a->items) {
        a->items = (void **) realloc(a->items, a->capacity * sizeof(void *));
    } else {
        a->items = (void **) malloc(a->capacity * sizeof(void *));
    }

    /*
     * 使用0初始化刚刚申请到的内存:
     * [从items起，后移动count个元素]作为起始位置，使用0初始化'没有存放元素[数组总容量-已经存放了元素的内存]'的内存
     * */
    memset(a->items + a->count, 0, (a->capacity - a->count) * sizeof(void *));
}

int private_array_push(ACL_ARRAY *a, void *obj)
{
    if (a->count >= a->capacity)
        private_array_grow(a, a->count + 16);
    a->items[a->count++] = obj;
    return(a->count - 1);
}


static void array_prepare_append(ACL_ARRAY *a, int app_count){
    assert(app_count > 0);

    //（ 数组元素个数 + 待存储的元素个数 ）  > 数组容量
    if (a->count + app_count > a->capacity){
        private_array_grow(a, a->count + app_count);
    }
}

ACL_ARRAY *private_array_create(int init_size){
    ACL_ARRAY  *a;

    a = (ACL_ARRAY *) calloc(1, sizeof(ACL_ARRAY));
    assert(a);

    a->iter_head = array_iter_head;
    a->iter_next = array_iter_next;
    a->iter_tail = array_iter_tail;
    a->iter_prev = array_iter_prev;

    if(init_size > 0)
        array_prepare_append(a, init_size);

    return (a);
}

void * private_array_pop(ACL_ARRAY *a){
    void *ptr;

    if(a->count == 0){
        return (NULL);
    }

    ptr = a->items[--a->count];
    a->items[a->count] = NULL;
    return ptr;
}

void *private_array_index(const ACL_ARRAY *a, int idx)
{
    if(idx < 0 || idx > a->count - 1)
        return(NULL);

    return(a->items[idx]);
}

int private_array_size(const ACL_ARRAY *a)
{
    if(a == NULL)
        return(-1);
    return(a->count);
}

int private_array_delete(ACL_ARRAY *a, int idx, void (*free_fn)(void*))
{
    if (a == NULL)
        return (-1);
    if (idx < 0 || idx >= a->count)
        return (-1);
    if (free_fn != NULL && a->items[idx] != NULL)
        free_fn(a->items[idx]);
    a->count--;
    if (a->count > 0)
        a->items[idx] = a->items[a->count];
    return (0);
}


int private_array_delete_obj(ACL_ARRAY *a, void *obj, void (*free_fn)(void*))
{
    int   i;

    if (a == NULL || obj == NULL)
        return (-1);
    for (i = 0; i < a->count; i++) {
        if (a->items[i] == obj) {
            return (private_array_delete(a, i, free_fn));
        }
    }
    return (-1);
}

void private_array_clean(ACL_ARRAY *a, void (*free_fn)(void *)){
    for(int i = 0; i < a->count; i++){
        if(free_fn != NULL && a->items[i] != NULL){
            free_fn(a->items[i]);
        }
    }
    a->count = 0;
}

void private_array_destroy(ACL_ARRAY *a, void (*free_fn)(void *)){
    private_array_clean(a, free_fn);
    if(a->items){
        free(a->items);
    }
    free(a);
}

4、main

#include <stdio.h>
#include "private_array.h"
#include <stdlib.h>

int main(void)
{
    ACL_ARRAY *a = private_array_create(10);
    ACL_ITER iter;
    int   i;
    char *ptr;

    for (i = 0; i < 20; i++) {
        ptr = (char*) malloc(32);
        snprintf(ptr, 32, "data: %d", i);
        (void) private_array_push(a, ptr);
    }

    printf("\nacl_foreach for acl_array:\n");
    acl_foreach(iter, a) {
        printf(">> i: %d, value: %s\n", iter.i, (char*) iter.data);
    }

    printf("\nacl_foreach_reverse for acl_array:\n");
    acl_foreach_reverse(iter, a) {
        printf(">> i: %d, value: %s\n", iter.i, (char*) iter.data);
    }

    private_array_destroy(a, free);

    return 0;
}
OceanStar的学习笔记
关注
专栏目录
c语言实现动态数组
qq_43536068的博客
03-31 2472
前言 最近研究二级指针,发现了二级指针配合realloc函数其实可以用来实现动态数组 这篇博文我只实现动态数组的push_back操作,就是在数组的末端增加一个元素 修正一个思想 c语言的函数参数,是不能在函数内部被修改的!!!因为传进来的参数,是拷贝构造 我们平时说"传指针就可以在函数内修改参数",实际上是误导学生的说法, 因为这个时候,函数的参数是指针,而这时候你会发现,你函数返回以后,这个指...
C语言如何实现动态数组？
04-29 4311
提出问题请问在c语言里如何实现动态大小的数组啊，比如说int a[N];，这里N的值可以在程序中定，或者有什么方法可以实现类似的功能？总之只要在编译时不用制定数组大小就行。分析问题嵌入式系...
「数组」实现动态数组的功能 / 实现标准库（C++）
最新发布
dakingffo的博客
07-24 1658
动态数组，顾名思议即可变长度的数组。本文实现了这种数据结构。
C语言实现动态数组
qq_34181098的博客
02-07 8192
指针与动态数组笔记 看公开课的学习笔记，C学习者交流群号 433368826 （我只是群员） 何为数组？ 在C语言中，定义一个数组，则是在计算机的内存中占据了一块固定的区域用于存储数据。 定义数组： int array[10] = { 0 }; 我们定义一个一般的一维数组往往有几个参数，以上述例子为例： 数组存储数据的类型 上为 int 整形，也就是数组中单位大小 数组的变量名 上为...
c语言动态数组的实现
qq_45973003的博客
02-05 1899
使用realloc函数调整动态数组的大小使用free函数释放动态数组占用的内存free(arr);需要注意的是，动态数组在使用完毕后应该及时释放内存，避免内存泄漏。另外，使用动态数组时需要注意数组下标的范围，避免访问越界导致程序崩溃。
算法：C语言实现（第1~4部分）答案
01-27
在本资源中，我们主要关注的是使用C语言实现算法的解答，这涵盖了算法的第1到第4个部分。C语言是一种广泛用于系统编程、应用编程、嵌入式系统以及编写算法实现的强大编程语言。其简洁性和高效性使得它成为学习和理解...
算法：C语言实现第1-4部分基础知识、数据结构、排序及搜索
01-22
例如，指针是C语言的一个重要特性，它允许我们直接操作内存地址，这在处理数据结构和算法时特别有用。 数据结构部分则深入到如何在内存中组织和管理数据。常见的数据结构包括数组、链表、栈、队列、树和图。数组是...
算法：C语言实现（第1~4部分）源代码
01-28
这个压缩包“算法：C语言实现（第1~4部分）源代码”显然包含了使用C语言编写的算法实现，可能是针对数据结构（Data Structures）的基础知识，以及一些基础到进阶的算法。 首先，我们可以从"DS_C"这个压缩包子文件的...
算法：C语言实现 第二卷(第5部分) 图算法
03-22
图算法是数据结构和算法课程中的难点，对于C语言的学习者来说，通过图算法的实现能够进一步加深对指针、动态内存分配和高级数据结构的理解，同时培养分析和解决复杂问题的能力。掌握图算法对于成为一名高级的软件...
C语言数组-C语言实现使用动态数组来构建循环链表.zip
03-02
在“C语言数组_C语言实现使用动态数组来构建循环链表”这个主题中，我们将探讨如何使用动态数组来实现循环链表的主要步骤： 1. **定义节点结构体**：首先，我们需要定义一个结构体来表示链表节点，通常包括数据域和...
用C语言创建动态数组
07-23
本文讲述了如何用C语言也能创建动态数组的技巧，通过代码实例来演示分析，让你进一步了解数组的动态创建技巧与代码的艺术。
[UE4]C 语言动态数组
weixin_30337157的博客
03-23 121
在实际的编程中，往往会发生这种情况，即所需的内存空间取决于实际输入的数据，而无法预先确定。对于这种问题，用静态数组的办法很难解决。为了解决上述问题，C语言提供了一些内存管理函数，这些内存管理函数结合指针可以按需要动态地分配内存空间，来构建动态数组，也可把不再使用的空间回收待用，为有效地利用内存资源提供了手段。 动态数组，是相对于静态数组而言。静态数组的长度是预先定义好的，在整个程序中，一旦给定大...
C语言动态数组的完整实现
ecorefeng的专栏
08-13 5538
    数组的有点在于随机存取，然而其不足也是明显的，就是一旦建立其大小就不能改变。若用数组存储数据，则必须创建一个可能存放的最大空间的数组，这无疑浪费了空间。动态数组解决了这个问题。动态数组的思路是：先建立一定大小的数组，向这个数组中存放数据，如果数组已满，则重新申请一个更大的空间来存放。每次重新申请时可以指定增量的大小(一般为原来数据的1.5倍)，也可以固定大小。这样做的好处是空间浪费不多，其不足是重新申请空间浪费时间，每次重新申请空间时须将原来的数据拷贝到新申请的空间，当数组很大时，这种浪费还是相当可
Python数据分析
qq_45070929的博客
09-28 162
1.改变数组的维度 我们用ravel、flatten、reshape和resize函数对NumPy数组的维度进行了修改。 2.数组的组合 NumPy数组有水平组合、垂直组合和深度组合等多种组合方式，我们将使用vstack、dstack、hstack、column_stack、row_stack以及concatenate函数来完成数组的组合。 ...
折半法排序详解：C语言实现与一维数组应用
- 起始数组：9、6、15、4、2 - 第1次划分：9、6、2、4、15 - 第2次划分：4、6、2、9、15 - 第3次划分：4、2、6、9、15 - 第4次划分：2、4、6、9、15 排序结束后，得到的结果是2、4、6、9、15。 此外，章节还可能...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值