关于c++内存回收（delete）对程序整体运行时间影响的疑问

最新推荐文章于 2023-09-06 10:16:07 发布
最新推荐文章于 2023-09-06 10:16:07 发布
阅读量1k 收藏 2
点赞数 3
文章标签： 数据结构 算法 内存泄漏
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MorphLing_/article/details/109732363
版权

起因是这样的，最近算法课在上红黑树，写红黑树的时候肯定涉及一些内存管理的问题，主要是在插入结点的时候要用new分配一个新的结点，并在清空红黑树的时候把这些结点delete释放掉。

算法导论书上只提供了插入和删除操作的代码，但是因为要测试多组数据的运行时间，需要自己实现一个清空(destroy)操作。本着避免一切可能造成的内存泄漏的原则，一开始我写了完整的清空函数，也就是从根节点开始递归，回收每个结点的内存空间，其中我的结点和树定义如下。

enum RBTColor{RED, BLACK};

class RBTNode {
public:
    RBTColor color;
    int key;
    RBTNode *lson;
    RBTNode *rson;
    RBTNode *parent;
    RBTNode(RBTColor c, int k) {
        color = c;
        key = k;
        lson = rson = parent = NULL;
    }
};
class RBTree {
public:
    RBTree() {
        root = NULL;
    }
    void destroy() {
        destroy(root);
    }
private:
    void destroy(RBTNode *&root) {
        if (root == NULL) return ;
        if (root->lson) destroy(root->lson);
        if (root->rson) destroy(root->rson);
        delete root;
        root = NULL;
    }
}rb_tree;

然而运行时感觉运行时间很奇怪，于是修改测试数据，测了5组规模一样的数据，发现只有第一次的运行时间是正常的，后面四次的时间明显大很多。进一步记录了一下destroy函数所占用的时间，结果如下。

destroy time : 0 ms SIZE : 100000 RUNTIME : 71 ms
destroy time : 46 ms SIZE : 100000 RUNTIME : 3308 ms
destroy time : 38 ms SIZE : 100000 RUNTIME : 2442 ms
destroy time : 38 ms SIZE : 100000 RUNTIME : 3415 ms
destroy time : 39 ms SIZE : 100000 RUNTIME : 2267 ms
destroy time : 38 ms

意识到可能是destroy的过程中的某些操作产生了这样的结果，采取控制变量法，尝试去掉了内存回收的部分之后运行时间时间恢复正常。修改后的destroy和测试结果如下，但很明显，这样写又会有内存泄漏的问题，即没有在清空红黑树前回收每个结点的内存

void destroy() {
    // clock_t rec = clock();
    // destroy(root);
    // cout << "destroy time : " << clock() - rec << " ms ";
    root = NULL;
}

SIZE : 100000 RUNTIME : 61 ms
SIZE : 100000 RUNTIME : 64 ms
SIZE : 100000 RUNTIME : 71 ms
SIZE : 100000 RUNTIME : 67 ms
SIZE : 100000 RUNTIME : 65 ms

可以确定是清空操作(destroy)造成了这一现象。此时我陷入了疑惑：RUNTIME所记录的仅仅是执行红黑树“插入”操作所消耗的时间，并没有记录清空操作的时间，与清空操作唯一的联系是对于内存的操作。但清空操作完成后，此时红黑树的根结点指针指向空结点，整个程序的执行状态和程序刚开始时几乎完全相同，但实际运行时间却差了40-50倍。

一个猜想是清空时的delete操作影响到了程序所能够使用的内存空间，但delete是起到回收内存的作用的，理论上来说意味着可供使用的内存空间更大了，为什么会比不回收内存空间的写法耗时更久呢？这一猜想完全不能解释这种现象。

以上就是我目前遇到的最主要的问题，对此我还做了以下尝试：

  1. 修改测试数据规模大小，测试了10^6的情况，仍有这个问题

    destroy time : 0 ms SIZE : 1000000 RUNTIME : 669 ms
destroy time : 470 ms SIZE : 1000000 RUNTIME : 7070 ms
destroy time : 462 ms SIZE : 1000000 RUNTIME : 7294 ms
destroy time : 473 ms SIZE : 1000000 RUNTIME : 7754 ms
destroy time : 471 ms SIZE : 1000000 RUNTIME : 6117 ms
destroy time : 468 ms

  2. 把释放内存的部分写到了RBTNode的析构函数中，并修改对应的destroy：

    class RBTNode {
public:
    RBTColor color;
    int key;
    RBTNode *lson;
    RBTNode *rson;
    RBTNode *parent;
    RBTNode(RBTColor c, int k) {
        color = c;
        key = k;
        lson = rson = parent = NULL;
    }
    ~RBTNode() {
        if (lson) delete(lson); lson = NULL;
        if (rson) delete(rson); rson = NULL;
    }
};
void destroy() {
    clock_t rec = clock();
    delete(root);
    root = NULL;
    cout << "destroy time : " << clock() - rec << " ms ";
}

    从结果来说，和原来的没有任何区别

  3. 写了一个简化版的测试程序，通过最简单的数据结构（链表）进行测试，问题仍然存在，可见不是红黑树操作的问题

    #include <bits/stdc++.h>

using namespace std;

int cnt;

class Node {
public:
    Node(int x) {
        key = x;
        nxt = NULL;
    }
    int key;
    Node *nxt;
};

class chain {
public:
    chain() {
        head = NULL;
    }
    void destroy() {
        clock_t rec = clock();
        Node *now = head, *pre;
        while(now !=NULL && now->nxt != NULL) {
            pre = now;
            now = now->nxt;
            delete pre;
            pre = NULL;
            cnt++;
        }
        if (now) delete now;
        head = NULL;
        cout << "destroy time : " << clock() - rec << " ms" << endl;
    }
    void insert(int x) {
        Node *node = new Node(x);
        insert(head, node);
    }
    void print() {
        print(head);
        cout << endl;
    }
private:
    Node *head;
    void destroy(Node *&now) {
        if (!now) return;
        cnt++;
        destroy(now->nxt);
        delete now;
        now = NULL;
    }
    void insert(Node *&now, Node *&node) {
        if (now == NULL) {
            now = node;
            return;
        }
        insert(now->nxt, node);
    }
    void print(Node *now) {
        if (!now) return;
        cout << now->key << " ";
        print(now->nxt);
    }
}L;

int main() {
    clock_t rec;
    L.destroy();
    for (int j = 1; j <= 5; j++) {
        rec = clock();
        for (int i = 1; i <= 10000; i++) L.insert(i);
        cout << "time : " << clock() - rec << " ms " ;
        L.destroy();
    }
    return 0;
}

    运行结果如下：

    destroy time : 0 ms
time : 120 ms destroy time : 383 ms
time : 506 ms destroy time : 378 ms
time : 499 ms destroy time : 375 ms
time : 498 ms destroy time : 375 ms
time : 507 ms destroy time : 375 ms

    仍然是只有第一次运行时时间正常，后面几次时间都长很多。

    且去掉delete之后时间恢复正常。再次确定是delete造成的问题。

  4. 抄了一个网上的红黑树代码，加上delete之后自己跑了一下，还是有这个问题

  5. 建了两颗红黑树，先对第一棵树做一遍插入和清空操作，再对第二棵树做插入操作，发现第二个树的插入时间也变慢了（进一步确定了问题与内存管理的关系）

重新简述下问题：在清空数据结构时，如果用delete回收了内存，那么会对下一次使用同样数据结构的运行时间产生非常大的影响。但原因未知，希望能找到对于这一现象的解释。

加了delete之后变慢的时间：

SIZE :100 RUNTIME : 2 ms
SIZE :1000 RUNTIME : 2 ms
SIZE :10000 RUNTIME : 13 ms
SIZE :100000 RUNTIME : 1049 ms
SIZE :1000000 RUNTIME : 4881 ms

不加delete正常的运行时间：

SIZE :100 RUNTIME : 9 ms
SIZE :1000 RUNTIME : 2 ms
SIZE :10000 RUNTIME : 8 ms
SIZE :100000 RUNTIME : 126 ms
SIZE :1000000 RUNTIME : 1341 ms

（搞了好几天了没搞懂为什么，救救孩子

附红黑树代码（只有插入操作）

#include <iostream>
#include <ctime>
#include <string.h>
#include <algorithm>

using namespace std;

const int MAXN = 1e6 + 5;

int data[MAXN], height;

enum RBTColor{RED, BLACK};

class RBTNode {
public:
    RBTColor color;
    int key;
    RBTNode *lson;
    RBTNode *rson;
    RBTNode *parent;
    RBTNode(RBTColor c, int k) {
        color = c;
        key = k;
        lson = rson = parent = NULL;
    }
    ~RBTNode() {
        if (lson) delete(lson); lson = NULL;
        if (rson) delete(rson); rson = NULL;
    }
};

class RBTree {
public:
    RBTree() {
        root = NULL;
    }
    ~RBTree() {
        destroy();
    }
    void insert(int key) {
        RBTNode *node = new RBTNode(RED, key);
        insert(root, node);
        //cout << "finish" << endl;
    }
    void inOrder() {
        cout << "root : " << root->key << endl;
        inOrder(root);
    }
    void check() {
        check(root, 1);
    }
    void destroy() {
        clock_t rec = clock();
        delete(root);
        root = NULL;
        cout << "destroy time : " << clock() - rec << " ms ";
        // root = NULL;
    }
private:
    RBTNode *root;
    void check(RBTNode *&x, int h) {
        h += x->color;
        if (x->lson) check(x->lson, h);
        if (x->rson) check(x->rson, h);
        if (x->color == 0) {
            if (x->lson && x->lson->color == 0 || x->rson && x->rson->color == 0)
                cout << "COLOR ERROR!" << endl;
        }
        if (!x->lson && !x->rson) {
            if (height == 0) height = h;
            else {
                if (height != h)
                    cout << "HEIGHT ERROR!" << endl;
            }
        }
    }
    void inOrder(RBTNode *&x) {
        if (x->lson) inOrder(x->lson);
        cout << "color : " << (x->color ? "BLACK" : "RED  ");
        cout << " key : " << x->key << endl;
        if (x->rson) inOrder(x->rson);
    }
    void insert(RBTNode *&root, RBTNode *&node) {
        if (root == NULL) {
            root = node; 
            insertFixup(root, root);
            return;
        }
        RBTNode *x = root, *y;
        while(x != NULL) {
            y = x;
            if (node->key < x->key) x = x->lson;
            else x = x->rson;
        }
        x = node;
        x->parent = y;
        if (node->key < y->key) y->lson = node;
        else y->rson = node;
        insertFixup(root, node);
    }
    void leftRotate(RBTNode *&root, RBTNode *&x) {
        RBTNode *y = x->rson, *z = x->parent;
        if (z == NULL) root = y;
        else 
            if (z->lson == x) z->lson = y;
            else z->rson = y;
        y->parent = x->parent;
        x->parent = y;
        x->rson = y->lson;
        if (x->rson) {
            x->rson->parent = x;
        }
        y->lson = x;
    }
    void rightRotate(RBTNode *&root, RBTNode *&x) {
        RBTNode *y = x->lson, *z = x->parent;
        if (z == NULL) root = y;
        else
            if (z->lson == x) z->lson = y;
            else z->rson = y;
        y->parent = x->parent;
        x->parent = y;
        x->lson = y->rson;
        if (x->lson) {
            x->lson->parent = x;
        }
        y->rson = x;
    }
    void insertFixup(RBTNode *&root, RBTNode *&x) {
        if (root == x) {
            x->color = BLACK;
            return;
        }
        RBTNode *y = x->parent;
        if (y->color == RED) {
            RBTNode *gparent = y->parent;
            if (gparent->lson == y) {
                RBTNode *uncle = gparent->rson;
                if (uncle && uncle->color == RED) {
                    uncle->color = y->color = BLACK;
                    gparent->color = RED;
                    insertFixup(root, gparent);    
                } else {
                    if (y->rson == x) {
                        leftRotate(root, y);
                        swap(x, y);
                    }
                    gparent->color = RED;
                    y->color = BLACK;
                    rightRotate(root, gparent);
                }
            } else {
                RBTNode *uncle = gparent->lson;
                if (uncle && uncle->color == RED) {
                    uncle->color = y->color = BLACK;
                    gparent->color = RED;
                    insertFixup(root, gparent);
                } else {
                    if (y->lson == x) {
                        rightRotate(root, y);
                        swap(x, y);
                    }
                    gparent->color = RED;
                    y->color = BLACK;
                    leftRotate(root, gparent);
                }
            }
        }    
    }
    void destroy(RBTNode *&root) {
        if (root == NULL) return ;
        if (root->lson) destroy(root->lson);
        if (root->rson) destroy(root->rson);
        delete root;
        root = NULL;
    }
}rb_tree;

class randInt {
public:
    randInt(int n, int s, int t):_n(n), _s(s), _t(t) {
        _r = _t - _s + 1;
        get = 0;
        exi = new bool[_r];
        number = new int[n];
        memset(exi, 0, sizeof(bool) * _r);
        memset(number, 0, sizeof(int) * _n);
    }
    ~randInt() {
        delete[] exi;
        delete[] number;
    }
    void generate_no_duplicate() {
        for (int i = 0; i < _n; i++) {
            int res = rand() * rand() % _r + _s;
            while(exi[res - _s]) res = rand() * rand() % _r + _s;
            exi[res - _s] = 1;
            number[i] = res;
        }
    }
    int getNum() {
        return number[get++];
    }
private:
    int _n, _s, _t, _r, get;
    bool *exi;
    int *number;
};

void calc_time(int SIZE, int s, int t) {
    rb_tree.destroy();
    clock_t rec = clock();
    for (int i = 0; i < SIZE; i++) {
        rb_tree.insert(data[i]);
    }
    cout << "SIZE : " << SIZE << " RUNTIME : " << clock() - rec << " ms" << endl;
}

int main() {
    srand(time(NULL));
    int n, s, t; 
    for (int i = 0; i < MAXN; i++) data[i] = i;
    random_shuffle(data, data + MAXN);
    for (int i = 1; i <= 5; i++) {
        calc_time(1000000, s, t);
    }
    return 0;
}
MorphLing_
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
C/C++程序内存的各种变量存储区域和各个区域详解
02-24
C语言在内存中一共分为如下几个区域，分别是：1.内存栈区：存放局部变量名；2.内存堆区：存放new或者malloc出来的对象；3.常数区：存放局部变量或者全局变量的值；4.静态区：用于存放全局变量或者静态变量；5.代码区：二进制代码。知道如上一些内存分配机制，有助于我们理解指针的概念。C/C++不提供垃圾回收机制，因此需要对堆中的数据进行及时销毁，防止内存泄漏，使用free和delete销毁new和malloc申请的堆内存，而栈内存是动态释放。全局变量、静态局部变量保存在全局数据区，初始化的和未初始化的分别保存在一起；普通局部变量保存在堆栈中；全局变量和局部变量在内存里的区别？一个由c/C++
解决Delete数据删除慢的问题
a345203172的专栏
07-14 1854
数据库delete慢的问题解决经验和思路，希望对你有帮助
C++程序执行A.exe计算A.exe的运行时间和内存
09-25
如何写一个C++程序，执行A.exe，计算A.exe的运行时间和内存。
C++程序检测内存泄漏的方法分享
12-31
一、前言 在Linux平台上有valgrind可以非常方便的帮助我们定位内存泄漏，因为Linux在开发领域的使用场景大多是跑服务器，再加上它的开源属性，相对而言，处理问题容易形成“统一”的标准。而在Windows平台，服务器和客户端开发人员惯用的调试方法有很大不同。下面结合我的实际经验，整理下常见定位内存泄漏的方法。 注意：我们的分析前提是Release版本，因为在Debug环境下，通过VLD这个库或者CRT库本身的内存泄漏检测函数能够分析出内存泄漏，相对而言比较简单。而服务器有很多问题需要在线上并发压力情况下才出现，因此讨论Debug版调试方法意义不大。 二、对象计数 方法：在对象构造时计数
详谈C++的内存泄漏问题
12-26
1）有多少new就有多少delete。而且配对的new与delete要尽量在一个函数中。如果子函数中需要返回的数据是通过new来创建的，我的处理方式一般是在需要调用这个函数的位置将对应的数据规模创建好，并且通过指针或是引用传递到子函数中。 2）本人比较粗心大意，又一次在编码的过程中 竟然将delete语句放在了return语句的后面，导致程序运行的过程中会因内存不足二崩溃。检查了不下20遍才检查出来，真是哭的心情都有了。希望大家以我为戒，一定把return语句放在函数的最后面，估计也就我一个人犯这种无聊的错误。 以上这篇详谈C++的内存泄漏问题就是小编分享给大家的全部内容了，希望能给大家一个参
C++学习笔记(四)--new与delete
最新发布
qq_45795134的博客
09-06 103
提示：以下是本篇文章正文内容，下面案例可供参考通常情况下我们只会使用new和delete的基本用法，但是了解他们的实现过程，并且知道定制new和delete之后，我们就会耳目一新，发现一片新的天地。
c++ 内存管理 —— delete释放内存的时效性
qq_41105501的博客
10-08 1483
c++ 内存管理 —— delete释放内存的时效性 delete释放之后，内容是立即回收的吗？ #include <iostream> using namespace std; int main() { int *map; int i=10; while(i--) { map=new int[20]; map[i]=i; cout << map[i]<<endl;//1 delete [] map; co
累计的力量，delete全表扫描导致程序运行时间过长。
cotchte0421的博客
07-01 195
昨天晚上熬夜加班到3点多，主要时间耗在一个做账业务上，这个业务是三个月前开始的，前几次做都还是比较快的不到一个小时，可是昨天晚上竟然花费了4个多小时。我手头工作太多，当时没顾得上找原因。今天早上分析了一下那个时段的AWR，原来祸...
一次delete速度异常慢的处理过程
weixin_34341117的博客
10-15 4695
  InnoDB delete from xxx速度暴慢原因 博客分类：   database MySQLPythonMobile多线程SQL  step1,一个简单的联系人表  Java代码   CREATE TABLE `contact784` (       `cid` bigint AUTO_INCREMENT NOT NULL,       `uid` bigint NO...
C++性能优化备忘
温故而知新
11-19 883
==影响性能的常见因素==* 访问/读写慢速的磁盘,网络设备或外部设备* 频繁的new/delete对象，尤其是复杂的大对象* 频繁的函数调用也会带来性能上的开销* 频繁的创建进程/线程,以及数据库/网络连接* 不合适的数据结构和低效的算法==针对这些因素的相应解决方法==* 使用内部缓存以减少读取外设的次数,将读写外设的操作放到单独的线程中* 使用内存池或其他内存
关于C++中delete释放内存时效性问题
itas109的专栏
04-01 9708
  如需转载请标明出处：http://blog.csdn.net/itas109  QQ技术交流群：129518033   测试示例：     #include &lt;iostream&gt; using namespace std; int main() { int *map; int i=10; while(i--) { map=new int...
浅谈new/delete
刘猿猿
11-17 252
在C语言的学习中，我们知道动态内存开辟是使用malloc函数来进行开辟一段连续的空间，释放则是用free来进行释放，而学习了C我们知道，在C中开辟内存是使用new，释放则也与之对应的delete，下面我们就来说说malloc/free与new/delete之间的区别以及底层实现原理 回顾 在C语言库中函数原型如下 #include &lt;stdlib.h&gt; void *malloc...
C++中使用delete 需要注意的两个问题
每天进步一点点就好
09-15 6148
1.  每次调用delete后一定要将对应的指针设置为NULL，要养成这样一个好习惯。为了保证每次delete后就执行赋值为NULL的习惯，可以定义单独的函数来做。下面是转载的一种方案：（http://blog.chinaunix.net/u/8681/showart_1946916.html） 偶然在Bjarne Stroustrup的主页上看到他对这个问题的解释: 之所以C++不在delete操作符中自动这么做是因为这个操作符为了灵活并不要求一个 lvalue. 但是他也说C++标准本身并不限制一
new和delete深度使用研习
西门吹雪
05-17 220
众所周知 c使用mollac和calloc函数在运行时动态分配内存，并使用free()释放动态分配的内存。c++支持这些函数，并且还有两个运算符new和delete，他们以更好、更简单的方式执行分配和释放内存。 对于int a、char str[10]等普通变量， 内存会自动分配和释放。 对于像int *p = new int[10]这样的动态分配内存，程序员有责任在不再需要时释放内存。 如果程序员不释放内存，则会导致 内存泄漏 （直到程序终止时才会释放内存）。 new 运算符请求堆中的内存分配。 如果有
C++测试程序记录程序运行时间
08-06
根据引用和引用中的代码，这段程序使用了不同的方法来记录程序的运行时间。在引用中，使用了clock()函数来计算程序运行的时间。而在引用中，使用了GetTickCount()函数来计算时间。这两种方法都可以得到程序的运行时间，只是单位不同，引用中的时间单位是秒，引用中的时间单位是毫秒。 如果你想将这两段代码合并在一起来记录程序的运行时间，可以参考引用中的代码。在这段代码中，使用了clock()函数和GetTickCount()函数来分别计算程序的开始时间和结束时间，并通过相减得到运行时间。这样就可以同时得到以秒为单位和毫秒为单位的运行时间。 需要注意的是，这些时间的精度可能会受到系统和计算机的影响，所以在不同的环境下得到的时间可能会有所不同。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值