C语言自动管理动态分配内存的一种方法

于 2024-10-09 08:46:33 发布
阅读量363 收藏 2
点赞数 17
分类专栏： 把C语言捡起来 文章标签： c语言 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwsong52/article/details/142773983
版权

C语言自动管理动态分配内存的一种方法

正常情况下用malloc分配内存，用free释放内存，用realloc重新分配，分配的内存必须要释放，我们的思路是自定义一个函数my_alloc，用户调用my_alloc函数分配的内存都自动记录在一个指针数组mempool中，这个数组在程序运行时首先初始化，每次调用my_alloc函数，都将分配的内存指针记录在mempool中，在程序运行结束前将mempool中记录的内存指针依次释放，最后将mempool释放，如此操作，用户只需调用my_alloc分配内存就可以了，不必顾及其他问题。

自定义静态变量和相关函数，测试一下分配1000次内存

  • #define PAGESIZE 128 定义宏PAGESIZE每次为mempool增加128个指针
  • static void **mempool = NULL; 无类型指针数组，保存分配的内存指针
  • static int pcount = 0; 记录分配内存的次数，每次加一
  • static int ps = 1; 记录mempool重新分配内存的次数
  • xmalloc函数，调用malloc分配内存，如出错则显示信息并返回NULL！！！
  • my_mempool_init函数，初始化mempool，为无类型指针数组分配128个指针！
  • my_alloc函数，分配内存，保存内存指针，记录次数，等于ps*PAGESIZE则ps增一，重新为mempool分配内存！！！
  • my_mempool_free函数，释放所有分配的内存
  • my_mempool_out_info函数，输出mempool相关的信息
  • my_strlen函数，自定义求字符串长度的函数
  • my_strdup函数，自定义字符串复制函数，返回复制的字符串的指针，这个指针是用myalloc在内存中分配的，只需要在程序运行结束前用my_mempool_free统一释放就可以了。

代码如下：

/* filename: mem.c */
#include <stdio.h>
#include <stdlib.h>

/**/
#define PAGESIZE 128

/**/
static void **mempool = NULL;
static int pcount = 0;
static int ps = 1;

/* */
static void *
xmalloc (size_t size)
{
  void *value = malloc (size);
  if (value == NULL)
    fprintf (stderr, "Alloc Memory error!\n");
  return value;
}

/**/
void
my_mempool_init (void)
{
  mempool = xmalloc (ps * PAGESIZE * sizeof(void*));
}

/**/
void*
my_alloc (int len)
{
  void *tmp = xmalloc (len);
  mempool[pcount] = tmp;
  pcount = pcount + 1;
  if (ps * PAGESIZE == pcount)
    {
      ps = ps + 1;
      mempool = realloc (mempool, ps * PAGESIZE * sizeof(void*));
    }
  return tmp;
}

/**/
void
my_mempool_free (void)
{
  for (int i = 0; i < pcount; i++)
    free (mempool[i]);
  free (mempool);
}

/**/
void
my_mempool_out_info (void)
{
  printf ("PAGESIZE : %d\n", PAGESIZE);
  printf ("Count : %d\n", pcount);
  printf ("Pages : %d\n", ps);
  printf ("Pointers : %d\n", ps * PAGESIZE);
}

/**/
int
my_strlen (char *str)
{
  int len = 0;
  while (*str != 0)
    {
      len = len + 1;
      str++;
    }
  return len;
}

/**/
char*
my_strdup (char *str)
{
  int len = my_strlen (str);
  char *tmp = (char*) my_alloc (len * sizeof(char));
  for (int i = 0; i < len; i++)
    tmp[i] = str[i];
  return tmp;
}

/**/
int
main (int argc, char *argv[])
{
  my_mempool_init ();
  for (int j = 0; j < 1000; j++)
    {
      char *tmp = my_strdup ("Not only a test here!");
    }
  my_mempool_out_info ();
  my_mempool_free ();
  return 0;
}
/* --(.v.)-- */

编译运行，通过，再用valgrind来检测一下，结果如下：

songvm@ubuntu:~/works/xdn/moo$ gcc mem.c -o mem
songvm@ubuntu:~/works/xdn/moo$ ./mem
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
songvm@ubuntu:~/works/xdn/moo$ valgrind --leak-check=yes ./mem
==3835== Memcheck, a memory error detector
==3835== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3835== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==3835== Command: ./mem
==3835== 
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
==3835== 
==3835== HEAP SUMMARY:
==3835==     in use at exit: 0 bytes in 0 blocks
==3835==   total heap usage: 1,009 allocs, 1,009 frees, 58,888 bytes allocated
==3835== 
==3835== All heap blocks were freed -- no leaks are possible
==3835== 
==3835== For counts of detected and suppressed errors, rerun with: -v
==3835== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

将mempool封装到一个结构体中去

  • 以上代码用到三个静态变量mempool, pcount, ps，用struct _Mempool结构体封装起来更规范一些！！！
  • 再定义一个静态的结构体变量 static Mempool _mempool; 供程序调用。

修改代码如下：

/* filename: mema.c */
#include <stdio.h>
#include <stdlib.h>

/**/
#define PAGESIZE 128

/*
static void **mempool = NULL;
static int pcount = 0;
static int ps = 1;
*/

/**/
typedef struct _Mempool Mempool;
struct _Mempool {
  void **pool;
  int pcount, ps;
};

/**/
static Mempool _mempool;

/**/
static void *
xmalloc (size_t size)
{
  void *value = malloc (size);
  if (value == NULL)
    fprintf (stderr, "Alloc Memory error!\n");
  return value;
}

/**/
static Mempool *
get_mempool (void)
{
  return &_mempool;
}

/**/
void
my_mempool_init (Mempool *mem)
{
  mem->pcount = 0;
  mem->ps = 1;
  mem->pool = xmalloc (mem->ps * PAGESIZE * sizeof(void*));
}

/**/
void*
my_alloc (int len)
{
  Mempool *mem = get_mempool();
  void *tmp = xmalloc (len);
  mem->pool[mem->pcount] = tmp;
  mem->pcount = mem->pcount + 1;
  if (((mem->ps) * PAGESIZE) == (mem->pcount))
    {
      mem->ps = mem->ps + 1;
      mem->pool = realloc (mem->pool, ((mem->ps) * PAGESIZE) * sizeof(void*));
    }
  return tmp;
}

/**/
void
my_mempool_free (Mempool *mem)
{
  for (int i = 0; i < mem->pcount; i++)
    free (mem->pool[i]);
  free (mem->pool);
}

/**/
void
my_mempool_out_info (Mempool *mem)
{
  printf ("PAGESIZE : %d\n", PAGESIZE);
  printf ("Count : %d\n", mem->pcount);
  printf ("Pages : %d\n", mem->ps);
  printf ("Pointers : %d\n", (mem->ps) * PAGESIZE);
}

/**/
int
my_strlen (char *str)
{
  int len = 0;
  while (*str != 0)
    {
      len = len + 1;
      str++;
    }
  return len;
}

/**/
char*
my_strdup (char *str)
{
  int len = my_strlen (str);
  char *tmp = (char*) my_alloc (len * sizeof(char));
  for (int i = 0; i < len; i++)
    tmp[i] = str[i];
  return tmp;
}

/**/
int
main (int argc, char *argv[])
{
  Mempool *mem = get_mempool ();
  my_mempool_init (mem);
  for (int j = 0; j < 1000; j++)
    {
      char *tmp = my_strdup ("Not only a test here!");
    }
  my_mempool_out_info (mem);
  my_mempool_free (mem);
  return 0;
}
/* --(.v.)-- */

编译运行，用valgrind检查一下有无内存泄漏情况，结果如下：

songvm@ubuntu:~/works/xdn/moo$ gcc mema.c -o mema
songvm@ubuntu:~/works/xdn/moo$ ./mema
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
songvm@ubuntu:~/works/xdn/moo$ valgrind --leak-check=yes ./mema
==3913== Memcheck, a memory error detector
==3913== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3913== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==3913== Command: ./mema
==3913== 
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
==3913== 
==3913== HEAP SUMMARY:
==3913==     in use at exit: 0 bytes in 0 blocks
==3913==   total heap usage: 1,009 allocs, 1,009 frees, 58,888 bytes allocated
==3913== 
==3913== All heap blocks were freed -- no leaks are possible
==3913== 
==3913== For counts of detected and suppressed errors, rerun with: -v
==3913== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
songvm@ubuntu:~/works/xdn/moo$

再分配1000个整数的数组指针并赋值测试，同时加上简单的注释

代码如下：

/* filename: memb.c */
#include <stdio.h>
#include <stdlib.h>

/* compile : gcc memb.c -o memb
       run : ./memb
   memcheck: valgrind --leak-check=yes ./memb  */

/**/
#define PAGESIZE 128

/* define Mempool datatype */
typedef struct _Mempool Mempool;
struct _Mempool {
  void **pool;
  int pcount, ps;
};

/* the mempool here! */
static Mempool _mempool;

/* call malloc function and out error info */
static void *
xmalloc (size_t size)
{
  void *value = malloc (size);
  if (value == NULL)
    fprintf (stderr, "Alloc Memory error!\n");
  return value;
}

/* got the mempool! */
static Mempool *
get_mempool (void)
{
  return &_mempool;
}

/* init the mempool */
void
my_mempool_init (Mempool *mem)
{
  mem->pcount = 0;
  mem->ps = 1;
  mem->pool = xmalloc (mem->ps * PAGESIZE * sizeof(void*));
}

/* define alloc function myself */
void*
my_alloc (int len)
{
  Mempool *mem = get_mempool();
  void *tmp = xmalloc (len);
  mem->pool[mem->pcount] = tmp;
  mem->pcount = mem->pcount + 1;
  if (((mem->ps) * PAGESIZE) == (mem->pcount))
    {
      mem->ps = mem->ps + 1;
      mem->pool = realloc (mem->pool, ((mem->ps) * PAGESIZE) * sizeof(void*));
    }
  return tmp;
}

/* define free function myself */
void
my_mempool_free (Mempool *mem)
{
  for (int i = 0; i < mem->pcount; i++)
    free (mem->pool[i]);
  free (mem->pool);
}

/* output mempool info */
void
my_mempool_out_info (Mempool *mem)
{
  printf ("PAGESIZE : %d\n", PAGESIZE);
  printf ("Count : %d\n", mem->pcount);
  printf ("Pages : %d\n", mem->ps);
  printf ("Pointers : %d\n", (mem->ps) * PAGESIZE);
}

/* define strlen funcfion myself */
int
my_strlen (char *str)
{
  int len = 0;
  while (*str != 0)
    {
      len = len + 1;
      str++;
    }
  return len;
}

/* define strdup function myself return the str pointer
   without free, my_mempool_free will free all */
char*
my_strdup (char *str)
{
  int len = my_strlen (str);
  char *tmp = (char*) my_alloc (len * sizeof(char));
  for (int i = 0; i < len; i++)
    tmp[i] = str[i];
  return tmp;
}

/* ------------------------- */

/**/
int
main (int argc, char *argv[])
{
  Mempool *mem = get_mempool ();

  my_mempool_init (mem);

  for (int j = 0; j < 1000; j++)
    {
      char *tmp = my_strdup ("Not only a test here!");
    }
  my_mempool_out_info (mem);
  printf ("--------------------\n");

  int *ip = (int*) my_alloc (1000 * sizeof(int));
  for (int k = 0; k < 1000; k++)
    ip[k] = k;
  my_mempool_out_info (mem);
  printf ("--------------------\n");

  my_mempool_free (mem);
  return 0;
}
/* --(.v.)-- */

编译运行，达到预期效果

songvm@ubuntu:~/works/xdn/moo$ gcc memb.c -o memb
songvm@ubuntu:~/works/xdn/moo$ ./memb
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
--------------------
PAGESIZE : 128
Count : 1001
Pages : 8
Pointers : 1024
--------------------
songvm@ubuntu:~/works/xdn/moo$ valgrind --leak-check=yes ./memb
==3944== Memcheck, a memory error detector
==3944== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3944== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==3944== Command: ./memb
==3944== 
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
--------------------
PAGESIZE : 128
Count : 1001
Pages : 8
Pointers : 1024
--------------------
==3944== 
==3944== HEAP SUMMARY:
==3944==     in use at exit: 0 bytes in 0 blocks
==3944==   total heap usage: 1,010 allocs, 1,010 frees, 62,888 bytes allocated
==3944== 
==3944== All heap blocks were freed -- no leaks are possible
==3944== 
==3944== For counts of detected and suppressed errors, rerun with: -v
==3944== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
songvm@ubuntu:~/works/xdn/moo$

分成多个文件编译，为开发大一点的应用做准备

头文件mem.h代码如下：

/* filename: mem.h */
#ifndef MEM_HEADER
#define MEM_HEADER

/**/
#define PAGESIZE 128

/* define Mempool datatype */
typedef struct _Mempool Mempool;
struct _Mempool {
  void **pool;
  int pcount, ps;
};

Mempool * get_mempool (void);
void my_mempool_init (Mempool *mem);
void * my_alloc (int len);
void my_mempool_free (Mempool *mem);
void my_mempool_out_info (Mempool *mem);

int my_strlen (char *str);
char * my_strdup (char *str);

#endif/*MEM_HEADER*/

*相关功能实现mem.c代码如下：

/* filename: mem.c */
#include <stdio.h>
#include <stdlib.h>
#include "mem.h"

/* the mempool here! */
static Mempool _mempool;

/* call malloc function and out error info */
static void *
xmalloc (size_t size)
{
  void *value = malloc (size);
  if (value == NULL)
    fprintf (stderr, "Alloc Memory error!\n");
  return value;
}

/* got the mempool! */
Mempool *
get_mempool (void)
{
  return &_mempool;
}

/* init the mempool */
void
my_mempool_init (Mempool *mem)
{
  mem->pcount = 0;
  mem->ps = 1;
  mem->pool = xmalloc (mem->ps * PAGESIZE * sizeof(void*));
}

/* define alloc function myself */
void*
my_alloc (int len)
{
  Mempool *mem = get_mempool();
  void *tmp = xmalloc (len);
  mem->pool[mem->pcount] = tmp;
  mem->pcount = mem->pcount + 1;
  if (((mem->ps) * PAGESIZE) == (mem->pcount))
    {
      mem->ps = mem->ps + 1;
      mem->pool = realloc (mem->pool, ((mem->ps) * PAGESIZE) * sizeof(void*));
    }
  return tmp;
}

/* define free function myself */
void
my_mempool_free (Mempool *mem)
{
  for (int i = 0; i < mem->pcount; i++)
    free (mem->pool[i]);
  free (mem->pool);
}

/* output mempool info */
void
my_mempool_out_info (Mempool *mem)
{
  printf ("PAGESIZE : %d\n", PAGESIZE);
  printf ("Count : %d\n", mem->pcount);
  printf ("Pages : %d\n", mem->ps);
  printf ("Pointers : %d\n", (mem->ps) * PAGESIZE);
}

/* define strlen funcfion myself */
int
my_strlen (char *str)
{
  int len = 0;
  while (*str != 0)
    {
      len = len + 1;
      str++;
    }
  return len;
}

/* define strdup function myself return the str pointer
   without free, my_mempool_free will free all */
char*
my_strdup (char *str)
{
  int len = my_strlen (str);
  char *tmp = (char*) my_alloc (len * sizeof(char));
  for (int i = 0; i < len; i++)
    tmp[i] = str[i];
  return tmp;
}
/* ----- mem.c ----- */
  • 测试功能文件tmem.c代码如下：
/* filename: tmem.c */
#include <stdio.h>
#include <stdlib.h>
#include "mem.h"

/* compile : gcc mem.c tmem.c -o tmem
       run : ./tmem
   memcheck: vargrind --leak-check=yes ./tmem  */

/**/
int
main (int argc, char *argv[])
{
  Mempool *mem = get_mempool ();

  my_mempool_init (mem);

  for (int j = 0; j < 1000; j++)
    {
      char *tmp = my_strdup ("Not only a test here!");
    }
  my_mempool_out_info (mem);
  printf ("--------------------\n");

  int *ip = (int*) my_alloc (1000 * sizeof(int));
  for (int k = 0; k < 1000; k++)
    ip[k] = k;
  my_mempool_out_info (mem);
  printf ("--------------------\n");

  my_mempool_free (mem);
  return 0;
}
/* --(.v.)-- */

编译运行，结果如预期：

gwsong@ubuntu:~/works/zoo/moo$ gcc mem.c tmem.c -o tmem
gwsong@ubuntu:~/works/zoo/moo$ ls
memb  memb.c  mem.c  mem.c~  mem.h  mem.h~  tmem  tmem.c  tmem.c~
gwsong@ubuntu:~/works/zoo/moo$ ./tmem
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
--------------------
PAGESIZE : 128
Count : 1001
Pages : 8
Pointers : 1024
--------------------
gwsong@ubuntu:~/works/zoo/moo$ valgrind --leak-check=yes ./tmem
==3639== Memcheck, a memory error detector
==3639== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3639== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==3639== Command: ./tmem
==3639== 
PAGESIZE : 128
Count : 1000
Pages : 8
Pointers : 1024
--------------------
PAGESIZE : 128
Count : 1001
Pages : 8
Pointers : 1024
--------------------
==3639== 
==3639== HEAP SUMMARY:
==3639==     in use at exit: 0 bytes in 0 blocks
==3639==   total heap usage: 1,010 allocs, 1,010 frees, 62,888 bytes allocated
==3639== 
==3639== All heap blocks were freed -- no leaks are possible
==3639== 
==3639== For counts of detected and suppressed errors, rerun with: -v
==3639== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
gwsong@ubuntu:~/works/zoo/moo$

下一步研究一下数据结构！！！

麻瓜老宋
关注
专栏目录
c语言链表动态分配内存,链表的C语言实现(含动态内存分配)
weixin_31089065的博客
05-21 3276
转自：http://blog.csdn.net/21aspnet/article/details/146968链表的C语言实现(含动态内存分配)上 链表的C语言实现之动态内存分配一、为什么用动态内存分配但我们未学习链表的时候，如果要存储数量比较多的同类型或同结构的数据的时候，总是使用一个数组。比如说我们要存储一个班级学生的某科分数，总是定义一个float型(存在0.5分)数组：float scor...
C语言 - 动态内存分配
good good study, day day up!
01-26 3855
malloc calloc relloc free 动态申请内存
【c语言】—动态内存分配 超详细版本
m0_74044018的博客
03-05 4850
讲解C语言中的动态内存分配，主讲malloc、calloc和realloc
【C语言】动态内存的分配
C、Java知识分享
01-29 1万+
动态内存的分配就那么回事儿！
C语言 ：学习动态内存分配
cainiaochufa2021的博客
02-27 1687
文章目录C语言动态分配为什么存在内存分配?动态内存函数的介绍`malloc``free``free`函数的**作用原理**是：使用后将指针赋为`NULL``calloc`运用一次`calloc`函数`realloc`当第一个参数为空指针时:当第一个参数不为空指针的时候:常见的动态内存分配错误对空指针的解引用操作对动态开辟空间的越界访问对非动态内存使用free释放对同一块动态内存进行多次释放忘记释放动态空间柔性数组柔性数组的特点一个如何开辟包含柔性数组成员的结构柔性数组的优势 C语言动态分配 为什么存在内存分
【C语言】内存的动态分配与释放
C/C++领域,数据结构,linux,MySQl学习者
10-29 1054
C语言中内存的动态分配相关知识,内容包括:什么是内存的动态分配?内存动态分配函数,动态内存释放函数以及6个常见的动态内存错误案例解析.
C语言中的动态内存分配
m0_62797154的博客
02-13 5842
大家好，今天简单讲一讲C语言中的动态内存分配。 截至目前，我们所使用的变量似乎都是在栈区（如局部变量、函数形参）和静态区（如全局变量、static修饰的变量），但是我们很早就知道除了栈区、静态区，在内存中还有‘堆’这样的一个区域。其实，这块内存就是用来动态内存分配的。 其实想一下就知道光靠栈区和静态区在处理问题时是很不灵活的（因为其开辟的空间是固定的），比如在声明数组时必须指定数组的大小（当然在C99中存在变长数组），但有时候我们也不能明确的指出要用多少空间，我们希望这块空间可大可小，既不过大，造成空间
【C语言进阶篇】动态内存分配和数组的动态内存分配
热门推荐
Ye_Ming_OUC的博客
04-23 2万+
本文主要介绍了C语言中常用的内存函数和数组的动态内存分配，并稍微提了一嘴柔性数组。动态内存分配是C语言中十分重要的一环，其中对二维数组的动态内存分配是个难点，需要多思考。
C语言之动态内存分配总结
Poem_coder的博客
01-23 2770
目录 一、为什么存在动态内存分配 二、动态内存函数的介绍 1.malloc和free 2.calloc 3.realloc 三、常见的动态内存错误 1.对NULL指针进行解引用操作 2.对动态开辟空间的越界访问 3.对非动态开辟内存使用free释放 4.使用free释放一块动态开辟内存的一部分 5.对同一块动态内存多次释放 6.动态内存开辟忘记释放（内存泄漏） 四、一些经典题 五、C/C++程序的内存开辟 六、柔性数组 一、为什么存在动态内存分配 以前的空间开辟如：int.
C语言动态内存分配函数
ZHA_123的博客
10-06 1835
通讯录大小是100，即最多只能存100个联系人的信息，那如果我们在使用时，需要存200人甚至更多人呢？ 那这个程序就不能满足我们的需求了。 而需要解决这个问题，我们就得学会使用C语言动态内存分配函数，对通讯录的大小进行动态分配。本篇博客会对动态内存分配函数进行讲解，一起来看看吧
深入解析C语言中的内存分配相关问题
09-03
当分配内存时，malloc会找到一个足够大的内存块并分割它，将一部分返回给用户，另一部分保留作为未来分配。释放内存时，free函数会将这块内存加入空闲链表。如果堆中内存碎片过多，malloc可能会尝试进行内存整理，将...
c语言动态内存分配知识点及实例
08-24
C语言中的动态内存分配是程序运行时根据需要动态地申请和释放内存的一种机制。它允许程序员在不知道数据规模的情况下分配内存，从而提高了程序的灵活性。本文将深入探讨动态内存分配的关键知识点并提供实例。 1. **...
c语言链表动态分配内存,梓益C语言学习笔记之链表＆动态内存＆文件
weixin_36423062的博客
05-21 980
梓益C语言学习笔记之链表＆动态内存＆文件一、定义：链表是一种物理存储上非连续，通过指针链接次序，实现的一种线性存储结构。二、特点：链表由一系列节点(链表中每一个元素称为节点)组成，节点在运行时动态生成(malloc)，每个节点包括两个部分：存储数据元素的数据域存储下一个节点地址的指针域如：typedef struct student｛int num；char name[20]；struct stu...
类C语言补充
2301_80702982的博客
10-01 523
/存放顺序表当中的数据元素的数组int length;//元素的个数}SqList;ElemType 根据后面 data 数据类型改成 int，float 等等，或者用 typedef char ElemType;数组静态分配int length;}SqList;存储空间已经确定，数组里面存放数组的首元素data[0]的基地址。数组动态分配int length;}SqList;存储空间没有确定，需要用SqList L;
C/C++中程序内存区域划分
吴先生的博客
10-08 205
C/C++程序内存分配的⼏个区域
【C++算法】9.双指针_四数之和
hlyd520的博客
10-04 543
后面的步骤类似，就不多赘述了。解法一：排序+暴力枚举+利用。双指针遇到合适的数继续往后走。解法二：排序+双指针。不满足循环条件，跳出。
Java 插入排序
最新发布
在那一刻，我们或许会发现自己站在了时间的另一岸，以更加成熟和宽广的胸怀，去拥抱那份隔代相传的深情。
10-08 129
插入排序（Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
代码随想录算法训练营Day28 | 39. 组合总和、40.组合总和Ⅱ、131.分割回文串
jiabao0520的博客
10-08 838
训练营第28天：39. 组合总和、40.组合总和Ⅱ、131.分割回文串
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 734
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值