c++浅拷贝与深拷贝(LeetCode669)

之前上C++/C#课上老师讲过这个问题，只不过当时主要是跟着老师的节奏与情形，从理论上基本了解了其原理。不过当自己写代码的时候，还是遇到了这个非常坑的问题。因此再来分析一下。

今天第一次做LeetCode，对这种指针的代码填空题个人感觉还是很有挑战性的。(作为一个数据结构课几乎很少用指针写代码、全是数组流的后遗症）

LeetCode题目传送门

题目的大意很简单，就是给定一个二叉排序树(BST, binary search tree)，再给定一个区间[l,r]，要我们把在其中区间里的树给抠出来返回。

由于BST是给定的，我们显然只要递归进行求解就好了。递归思路很清晰的话，代码很短，5行左右就搞定(见本文最后)。我的解法比较麻烦，而且对指针的不熟悉踩了不少坑。因此慢慢填。

先写几点非常基础的原则(写的时候怎么还是这么容易掉坑)

函数里定义的局部变量是放在栈上的，函数结束后会自动释放。而malloc的空间是放在堆上的，除非程序要手动释放不会消失。

---

c++的指针变量需要首先赋值，否则会变成野指针。类似这种应该都报错，因为
任何指针变量刚被创建时不会自动成为NULL指针，它的缺省值是随机的，它会乱指一气。所以，指针变量在创建的同时应当被初始化，要么将指针设置为NULL，要么让它指向合法的内存。

然后回到题目标题的最大的坑。

先po一些基础概念。

所谓浅拷贝，指的是在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数执行的也是浅拷贝。大多情况下“浅拷贝”已经能很好地工作了，但是一旦对象存在了动态成员，那么浅拷贝就会出问题了。

在“深拷贝”的情况下，对于对象中动态成员，就不能仅仅简单地赋值了，而应该重新动态分配空间.

有几个需要注意的点，一是对于指针变量的初始化。TreeNode *lll = (TreeNode *)(sizeof(TreeNode)); 这么写的原因是因为这样分配不会随着我们函数的结束这段空间被释放，因为我们结束后可能还会需要这段内存的值，第二：我一开始是这么写的 TreeNode tthh(0);
TreeNode* res = &tthh;

这么写是不可取的。直接将指针对象知道了一个新初始的TreeNode上，临时变量指的那个空间里的值，一出当前函数、这个值可能就从正确的变成了无穷，应该是c++某种释放机制。反正这样写在LeetCode上交的结果就是reference binding to misaligned address 0x7faf0d005d32 for type 'const int', which requires 4 byte alignment 的RunTime Error。

我们每次把lll或者rrr传到下一层递归的ans指针的目的是什么呢，是要其指向的值是正确的子树的结果。而如果此时我们只是做一句ans=lll; 它的意义是什么呢，这显然是一个浅拷贝，只把lll的值也就是指向的地址给了ans，至于里面的值呢，在当前的这一层中我们指向和lll相同的地方，无可厚非。不过一返回到上层就GG。举个例子，如下图：

比如在做到3节点的时候，我们分配给lll的地址为A，我们进入到左节点0的时候显然ans指向的地址也是A，我们在0的时候会得到ans=rrr;的一个新地址B，指向2->1这样的一棵子树。目前看没有问题域。但是！当从0这层返回到上层的时候，我们在3中的lll的地址还会变成我们想要的B吗？显然不会，因为我们知道，在C++中参数的传递方式是值传递，所以这个地址还会又变成A，然后此时我们就还是会指向了一片虚无的地方，然后就错了。因此避免的方法就是，我们在进行每次进行复制的时候进行一次深拷贝，因此就看到那三行的拷贝内容。也许，你又要问了，那为什么上面的ans->left = lll; 可以直接进行浅拷贝呢，那是因为我们是直接对ans的内容进行了改变，因此函数结束后其内容仍然改变了。当然进行深拷贝也行,只要记住不要往NULL里面写东西。即ans->left = (TreeNode*)(malloc(sizeof(TreeNode)));
ans->left->val = lll->val;
ans->left->left = lll->left;
ans->left->right = lll->right;

最终我AC的代码如下:

class Solution {
public:
    bool dfs(TreeNode* root, int L, int R, TreeNode * ans){//浅拷贝，指针引用！
        ans->left = ans->right = NULL;

        bool zy = false;
        bool h;
        if (root->val >= L && root->val <= R){
            ans->val = root->val;
            zy = true;
        }
        if (root->left != NULL){
            TreeNode* lll = (TreeNode*)(malloc(sizeof(TreeNode)));
            lll->left = lll->right = NULL;//指针初始化，拒绝野指针

            h = dfs(root->left, L, R, lll);
            if (h){//判断坐标子树上有没有东西，有东西的话就把
                if (root->val >= L && root->val <= R){
                    //ans->left = (TreeNode*)(malloc(sizeof(TreeNode)));
                    ans->left = lll;
                }
                else{
                //ans = lll;
                    ans->val = lll->val;
                    ans->left = lll->left;
                    ans->right = lll->right;
                }
            }
            zy |= h;
        }
        if (root->right){
            TreeNode* rrr = (TreeNode*)(malloc(sizeof(TreeNode)));
            rrr->left = rrr->right = NULL;
            h = dfs(root->right, L, R, rrr);
            if (h){
                if (root->val >= L && root->val <= R){
                    //ans->right = (TreeNode*)(malloc(sizeof(TreeNode)));
                    ans->right = rrr;
                }
                else{
                    ans->val = rrr->val;
                    ans->left = rrr->left;
                    ans->right = rrr->right;
                }
            }
            zy |= h;
        }
        return zy;
    }
    TreeNode* trimBST(TreeNode* root, int L, int R) {
        cout << sizeof(TreeNode) << endl;
        TreeNode* res = (TreeNode*)(malloc(sizeof(TreeNode)));
        res->left = res->right = NULL;//指针初始化，拒绝野指针
        dfs(root, L, R, res);
        return res;
    }
};

虽然过了，但我也进行了新的思考，能否就浅拷贝不复制其内容呢？显然也是可以的，只需要我们传递的是指针的引用就行了。改一下函数声明即可：

bool dfs(TreeNode* root, int L, int R, TreeNode *& ans)

到了这个程度，我想我对于这道题的理解也就告一段落。其实这道题比较好的思路没有这么绕，只需要我们直接在原来的这颗树上进行删减就好 。删减的原则如下：

• 当root的值位于L和R之间，则递归修剪其左右子树，返回root。
• 当root的值小于L，则其左子树的值都小于L，抛弃左子树，返回修剪过的右子树。
• 当root的值大于R，则其右子树的值都大于R，抛弃右子树，返回修剪过的左子树。

最终的代码也就非常简短与清晰了：

public TreeNode trimBST(TreeNode root, int L, int R) {
        if (root == null) return null;
        if (root.val < L){
            return trimBST(root.right, L, R);
        }
        else if (root.val > R){
            return trimBST(root.left, L, R);
        }
        else {
            TreeNode ans = new TreeNode(root.val);
            ans.left = trimBST(root.left, L, R);
            ans.right = trimBST(root.right, L, R);
            return ans;
        }
    }

最后总结一下，c++中函数参数进行传递的时候都是浅拷贝。如果是指针它的意思就是只复制它的内容给一个新的对象，这个函数结束后这个新对象就释放了。因此我们如果想要改变原来的这个参数的值就是通过引用的方式，（最后PS，引用的好的点在于用了同样的对象同样的空间，避免了复制，想想看如果是一个数组或者是vector并且这个函数多次调用的时候这个花销的时间得有多大，说多了都是泪。另一道题参数少写一个&，TLE大半天才发现对一个无需改变的vector自己拼命在调用、复制来复制去)

*:first-child {
margin-top: 0 !important;
}

.markdown-body>*:last-child {
margin-bottom: 0 !important;
}

.markdown-body .anchor {
position: absolute;
top: 0;
bottom: 0;
left: 0;
display: block;
padding-right: 6px;
padding-left: 30px;
margin-left: -30px;
}

.markdown-body .anchor:focus {
outline: none;
}

.markdown-body h1,
.markdown-body h2,
.markdown-body h3,
.markdown-body h4,
.markdown-body h5,
.markdown-body h6 {
position: relative;
margin-top: 1em;
margin-bottom: 16px;
font-weight: bold;
line-height: 1.4;
}

.markdown-body h1 .octicon-link,
.markdown-body h2 .octicon-link,
.markdown-body h3 .octicon-link,
.markdown-body h4 .octicon-link,
.markdown-body h5 .octicon-link,
.markdown-body h6 .octicon-link {
display: none;
color: #000;
vertical-align: middle;
}

.markdown-body h1:hover .anchor,
.markdown-body h2:hover .anchor,
.markdown-body h3:hover .anchor,
.markdown-body h4:hover .anchor,
.markdown-body h5:hover .anchor,
.markdown-body h6:hover .anchor {
height: 1em;
padding-left: 8px;
margin-left: -30px;
line-height: 1;
text-decoration: none;
}

.markdown-body h1:hover .anchor .octicon-link,
.markdown-body h2:hover .anchor .octicon-link,
.markdown-body h3:hover .anchor .octicon-link,
.markdown-body h4:hover .anchor .octicon-link,
.markdown-body h5:hover .anchor .octicon-link,
.markdown-body h6:hover .anchor .octicon-link {
display: inline-block;
}

.markdown-body h1 {
padding-bottom: 0.3em;
font-size: 2.25em;
line-height: 1.2;
border-bottom: 1px solid #eee;
}

.markdown-body h2 {
padding-bottom: 0.3em;
font-size: 1.75em;
line-height: 1.225;
border-bottom: 1px solid #eee;
}

.markdown-body h3 {
font-size: 1.5em;
line-height: 1.43;
}

.markdown-body h4 {
font-size: 1.25em;
}

.markdown-body h5 {
font-size: 1em;
}

.markdown-body h6 {
font-size: 1em;
color: #777;
}

.markdown-body p,
.markdown-body blockquote,
.markdown-body ul,
.markdown-body ol,
.markdown-body dl,
.markdown-body table,
.markdown-body pre {
margin-top: 0;
margin-bottom: 16px;
}

.markdown-body hr {
height: 4px;
padding: 0;
margin: 16px 0;
background-color: #e7e7e7;
border: 0 none;
}

.markdown-body ul,
.markdown-body ol {
padding-left: 2em;
}

.markdown-body ul ul,
.markdown-body ul ol,
.markdown-body ol ol,
.markdown-body ol ul {
margin-top: 0;
margin-bottom: 0;
}

.markdown-body li>p {
margin-top: 16px;
}

.markdown-body dl {
padding: 0;
}

.markdown-body dl dt {
padding: 0;
margin-top: 16px;
font-size: 1em;
font-style: italic;
font-weight: bold;
}

.markdown-body dl dd {
padding: 0 16px;
margin-bottom: 16px;
}

.markdown-body blockquote {
padding: 0 15px;
color: #777;
border-left: 4px solid #ddd;
}

.markdown-body blockquote>:first-child {
margin-top: 0;
}

.markdown-body blockquote>:last-child {
margin-bottom: 0;
}

.markdown-body table {
display: block;
width: 100%;
overflow: auto;
word-break: normal;
word-break: keep-all;
}

.markdown-body table th {
font-weight: bold;
}

.markdown-body table th,
.markdown-body table td {
padding: 6px 13px;
border: 1px solid #ddd;
}

.markdown-body table tr {
background-color: #fff;
border-top: 1px solid #ccc;
}

.markdown-body table tr:nth-child(2n) {
background-color: #f8f8f8;
}

.markdown-body img {
max-width: 100%;
-moz-box-sizing: border-box;
box-sizing: border-box;
}

.markdown-body code {
padding: 0;
padding-top: 0.2em;
padding-bottom: 0.2em;
margin: 0;
font-size: 85%;
background-color: rgba(0,0,0,0.04);
border-radius: 3px;
}

.markdown-body code:before,
.markdown-body code:after {
letter-spacing: -0.2em;
content: "\00a0";
}

.markdown-body pre>code {
padding: 0;
margin: 0;
font-size: 100%;
word-break: normal;
white-space: pre;
background: transparent;
border: 0;
}

.markdown-body .highlight {
margin-bottom: 16px;
}

.markdown-body .highlight pre,
.markdown-body pre {
padding: 16px;
overflow: auto;
font-size: 85%;
line-height: 1.45;
background-color: #f7f7f7;
border-radius: 3px;
}

.markdown-body .highlight pre {
margin-bottom: 0;
word-break: normal;
}

.markdown-body pre {
word-wrap: normal;
}

.markdown-body pre code {
display: inline;
max-width: initial;
padding: 0;
margin: 0;
overflow: initial;
line-height: inherit;
word-wrap: normal;
background-color: transparent;
border: 0;
}

.markdown-body pre code:before,
.markdown-body pre code:after {
content: normal;
}

.markdown-body .highlight {
background: #fff;
}

.markdown-body .highlight .mf,
.markdown-body .highlight .mh,
.markdown-body .highlight .mi,
.markdown-body .highlight .mo,
.markdown-body .highlight .il,
.markdown-body .highlight .m {
color: #945277;
}

.markdown-body .highlight .s,
.markdown-body .highlight .sb,
.markdown-body .highlight .sc,
.markdown-body .highlight .sd,
.markdown-body .highlight .s2,
.markdown-body .highlight .se,
.markdown-body .highlight .sh,
.markdown-body .highlight .si,
.markdown-body .highlight .sx,
.markdown-body .highlight .s1 {
color: #df5000;
}

.markdown-body .highlight .kc,
.markdown-body .highlight .kd,
.markdown-body .highlight .kn,
.markdown-body .highlight .kp,
.markdown-body .highlight .kr,
.markdown-body .highlight .kt,
.markdown-body .highlight .k,
.markdown-body .highlight .o {
font-weight: bold;
}

.markdown-body .highlight .kt {
color: #458;
}

.markdown-body .highlight .c,
.markdown-body .highlight .cm,
.markdown-body .highlight .c1 {
color: #998;
font-style: italic;
}

.markdown-body .highlight .cp,
.markdown-body .highlight .cs {
color: #999;
font-weight: bold;
}

.markdown-body .highlight .cs {
font-style: italic;
}

.markdown-body .highlight .n {
color: #333;
}

.markdown-body .highlight .na,
.markdown-body .highlight .nv,
.markdown-body .highlight .vc,
.markdown-body .highlight .vg,
.markdown-body .highlight .vi {
color: #008080;
}

.markdown-body .highlight .nb {
color: #0086B3;
}

.markdown-body .highlight .nc {
color: #458;
font-weight: bold;
}

.markdown-body .highlight .no {
color: #094e99;
}

.markdown-body .highlight .ni {
color: #800080;
}

.markdown-body .highlight .ne {
color: #990000;
font-weight: bold;
}

.markdown-body .highlight .nf {
color: #945277;
font-weight: bold;
}

.markdown-body .highlight .nn {
color: #555;
}

.markdown-body .highlight .nt {
color: #000080;
}

.markdown-body .highlight .err {
color: #a61717;
background-color: #e3d2d2;
}

.markdown-body .highlight .gd {
color: #000;
background-color: #fdd;
}

.markdown-body .highlight .gd .x {
color: #000;
background-color: #faa;
}

.markdown-body .highlight .ge {
font-style: italic;
}

.markdown-body .highlight .gr {
color: #aa0000;
}

.markdown-body .highlight .gh {
color: #999;
}

.markdown-body .highlight .gi {
color: #000;
background-color: #dfd;
}

.markdown-body .highlight .gi .x {
color: #000;
background-color: #afa;
}

.markdown-body .highlight .go {
color: #888;
}

.markdown-body .highlight .gp {
color: #555;
}

.markdown-body .highlight .gs {
font-weight: bold;
}

.markdown-body .highlight .gu {
color: #800080;
font-weight: bold;
}

.markdown-body .highlight .gt {
color: #aa0000;
}

.markdown-body .highlight .ow {
font-weight: bold;
}

.markdown-body .highlight .w {
color: #bbb;
}

.markdown-body .highlight .sr {
color: #017936;
}

.markdown-body .highlight .ss {
color: #8b467f;
}

.markdown-body .highlight .bp {
color: #999;
}

.markdown-body .highlight .gc {
color: #999;
background-color: #EAF2F5;
}

.markdown-body .octicon {
font: normal normal 16px octicons-anchor;
line-height: 1;
display: inline-block;
text-decoration: none;
-webkit-font-smoothing: antialiased;
-moz-osx-font-smoothing: grayscale;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
user-select: none;
}

.markdown-body .octicon-link:before {
content: '\f05c';
}

.markdown-body .task-list-item {
list-style-type: none;
}

.markdown-body .task-list-item+.task-list-item {
margin-top: 3px;
}

.markdown-body .task-list-item input {
float: left;
margin: 0.3em 0 0.25em -1.6em;
vertical-align: middle;
}

/*

github.com style (c) Vasily Polovnyov

*/

.hljs {
display: block;
overflow-x: auto;
padding: 0.5em;
color: #333;
background: #f8f8f8;
-webkit-text-size-adjust: none;
}

.hljs-comment,
.diff .hljs-header {
color: #998;
font-style: italic;
}

.hljs-keyword,
.css .rule .hljs-keyword,
.hljs-winutils,
.nginx .hljs-title,
.hljs-subst,
.hljs-request,
.hljs-status {
color: #333;
font-weight: bold;
}

.hljs-number,
.hljs-hexcolor,
.ruby .hljs-constant {
color: #008080;
}

.hljs-string,
.hljs-tag .hljs-value,
.hljs-doctag,
.tex .hljs-formula {
color: #d14;
}

.hljs-title,
.hljs-id,
.scss .hljs-preprocessor {
color: #900;
font-weight: bold;
}

.hljs-list .hljs-keyword,
.hljs-subst {
font-weight: normal;
}

.hljs-class .hljs-title,
.hljs-type,
.vhdl .hljs-literal,
.tex .hljs-command {
color: #458;
font-weight: bold;
}

.hljs-tag,
.hljs-tag .hljs-title,
.hljs-rule .hljs-property,
.django .hljs-tag .hljs-keyword {
color: #000080;
font-weight: normal;
}

.hljs-attribute,
.hljs-variable,
.lisp .hljs-body,
.hljs-name {
color: #008080;
}

.hljs-regexp {
color: #009926;
}

.hljs-symbol,
.ruby .hljs-symbol .hljs-string,
.lisp .hljs-keyword,
.clojure .hljs-keyword,
.scheme .hljs-keyword,
.tex .hljs-special,
.hljs-prompt {
color: #990073;
}

.hljs-built_in {
color: #0086b3;
}

.hljs-preprocessor,
.hljs-pragma,
.hljs-pi,
.hljs-doctype,
.hljs-shebang,
.hljs-cdata {
color: #999;
font-weight: bold;
}

.hljs-deletion {
background: #fdd;
}

.hljs-addition {
background: #dfd;
}

.diff .hljs-change {
background: #0086b3;
}

.hljs-chunk {
color: #aaa;
}
-->