LeetCode-Binary Tree Level Order Traversal II-搞定指向指针的指针和malloc的用法

    对于这个题目，其实就是二叉树的按层遍历，然后将按层遍历的结果倒序存放而已，正好复习一下二叉树的按层遍历。

void BinTree_Level(ChainBinTree *bt,void (*oper)(ChainBinTree *p)){

	ChainBinTree *p;
	ChainBinTree *q[QUEUE_MAXSIZE];
	int head,tail=0;
	
	if(bt){
		tail=(tail+1)%QUEUE_MAXSIZE;
		q[tail]=bt;
	}
	while(head!=tail){
		head=(head+1)%QUEUE_MAXSIZE;
		p=q[head];
		oper(p);
		if(bt->left!=NULL){
			tail=(tail+1)%QUEUE_MAXSIZE;
			q[tail]=p->left;
		}
		
		if(bt->right!=NULL){
			tail=(tail+1)%QUEUE_MAXSIZE;
			q[tail]=p->right;
		}	
	} 
	return;
}

    参考二叉树的按层遍历，就能写出这道题的代码，思路如下

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Return an array of arrays of size *returnSize.
 * The sizes of the arrays are returned as *columnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
int GetdepthofTree(struct TreeNode* root){
    if (!root) return 0;
    int left = GetdepthofTree(root->left);
    int right = GetdepthofTree(root->right);
    if (left > right)
        return left+1;
    else
        return right+1;
}


int** levelOrderBottom(struct TreeNode* root, int** columnSizes, int* returnSize) {
    if (!root){
        return NULL;
    }
    //获取二叉树的深度，最大层数或者说
    int depth = *returnSize = GetdepthofTree(root);
    
    //ret是一个指向一个二维数组的指针，这一块地址是我们自己开辟的，需要malloc
    int** ret = (int**)malloc(depth*sizeof(int*));
    
    //columnSizes是一个指向指针的指针，这个地址已经指定了，就是说这个地址了存放的下一个地址已经确定了，但是下一个地址里存放的还是地址，这个地址任然不确定，那么就需要malloc了
    //*columnSizes是一个指向一个一维数组的指针，数组的大小也是depth
    
    *columnSizes = (int*)malloc(depth*sizeof(int));
    int front = 0, back = 0;
    struct TreeNode* queue[10000];
    queue[back++] = root;
    while (front < back){
        int start = front, end = back;
        (*columnSizes)[--depth] = end - start;
        front = end;
        //开始的时候我们只给了ret的地址，因为ret是一个二维数组的起始地址，但是这个二维数组里面的一维数组的地址并没有确定，就需要malloc来确定
        ret[depth] = (int*)malloc((end - start)*sizeof(int));
        for (int i=start; i<end; i++){
            ret[depth][i-start] = queue[i]->val;
            if (queue[i]->left) queue[back++] = queue[i]->left;
            if (queue[i]->right) queue[back++] = queue[i]->right;
        }
    }
    return ret;
}

    c语言什么时候需要动态分配内存

首先应该知道计算机系统中有四个内存区域：

    栈：主要存放一些我们定义的局部变量和形参

    堆：主要是动态分配的存储空间

    字符常量区：存放字符常量

    全局区：存放一些全局变量和静态变量。

    int *p;//我们声明了一个指针p，p里面存放要找的值的地址

    但是光这样的话是并没有什么用的，

    int a=5;

    p=&a;//这个时候才把地址放到了p这个指针中了。但是这不叫指针的动态分配内存，这叫指针变量的初始化。

    当我们用malloc函数为一指针变量分配了地址，在不需要再用的时候需要释放这一片内存，在上面我已经讲过动态分配的变量时储存在堆里面，但是这个堆的空间并不是无限大的，也许当我们编一个小的程序的时候可能我们并不能够发现什么，但是对于那些大的程序，如果我们没及时释放堆的空间的时候会放生内存泄露。所谓内存泄露是因为堆的空间被我们动态分配用完了，这样当我们再去使用动态分配堆的空间的时候就没有足够的空间让我们使用了，这样就需要占有原来的空间，也就是会把其他的空间来储存我们键入的值，这样会导致原来储存的数据被破坏掉，导致了内存的泄露了。