嵌入式小聪

树与二叉树——练习题

深度优先遍历（借用栈）

前序遍历（递归法，迭代法）

中序遍历（递归法，迭代法）

后序遍历（递归法，迭代法）

广度优先遍历（借用队列）

层次遍历（迭代法）

递归三步曲：

「确定递归函数的参数和返回值：」确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数，并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型

「确定终止条件：」写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出

「确定单层递归的逻辑：」确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程

1. ✌二叉树的前序遍历

代码实现：递归 + 迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

#define MAX_NODE 100

// 递归
void pre_order1(struct TreeNode* root, int* res, int* returnSize) {
    if (root == NULL) { // 终止条件
        return ;
    }
    res[(*returnSize)++] = root->val;
    pre_order1(root->left, res, returnSize);
    pre_order1(root->right, res, returnSize);
}

// 迭代（非递归） 深度优先搜索---借用栈
void pre_order2(struct TreeNode* root, int* res, int* returnSize) {
    if (root == NULL) {
        return ;
    }
    struct TreeNode* stack[MAX_NODE]; // 创建一个栈
    int top = -1; // 栈顶
    stack[++top] = root;
    while (top != -1) { // 栈不为空则执行while循环
        struct TreeNode* node = stack[top]; // 记录栈顶
        res[(*returnSize)++] = node->val;
        top--;
        if (node->right) { // 右子树先进栈
            stack[++top] = node->right;
        }
        if (node->left) {
            stack[++top] = node->left;
        }
    }
}

int* preorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * MAX_NODE);
    *returnSize = 0;
    pre_order1(root, res, returnSize);
    pre_order2(root, res, returnSize);
    return res;
}

2. ✌二叉树的中序遍历

代码实现：递归 + 迭代

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

#define MAX_NODE 100

// 递归
void mid_order1(struct TreeNode* root, int* res, int* returnSize) {
    if (root == NULL) { // 终止条件
        return ;
    }
    mid_order1(root->left, res, returnSize);
    res[(*returnSize)++] = root->val;
    mid_order1(root->right, res, returnSize);
}

// 迭代（非递归） 深度优先搜索---借用栈
void mid_order2(struct TreeNode* root, int* res, int* returnSize) {
    if (root == NULL) {
        return ;
    }
    struct TreeNode* stack[MAX_NODE]; // 创建一个栈
    int top = -1; // 栈顶
    struct TreeNode* p = root;
    struct TreeNode* q = NULL;
    while (p || top != -1) {
		if (p) {
			stack[++top] = p;
			p = p->left;
		} else {
			q = stack[top];
			res[(*returnSize)++] = q->val;
            top--;
			p = q->right;
		}
	}
}

int* inorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * MAX_NODE);
    *returnSize = 0;
    mid_order1(root, res, returnSize);
    mid_order2(root, res, returnSize);
    return res;
}

3. 二叉树的后序遍历

代码实现：递归 + 两种迭代方法

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */

#define MAX_NODE 100

// 递归
void post_order1(struct TreeNode* root, int* res, int* returnSize) {
    if (root == NULL) { // 终止条件
        return ;
    }
    post_order1(root->left, res, returnSize);
    post_order1(root->right, res, returnSize);
    res[(*returnSize)++] = root->val;
}

// 迭代（非递归） 深度优先搜索---借用栈
/*
第一种方法：
    先序遍历是 中左右 --->调整代码左右循序--->中右左--->反转result数组--->左右中
    后序遍历是 左右中
*/
void post_order2(struct TreeNode* root, int* res, int* returnSize) {
    if (root == NULL) {
        return ;
    }
    struct TreeNode* stack[MAX_NODE]; // 创建一个栈
    int top = -1; // 栈顶
    stack[++top] = root;
    while (top != -1) { // 栈不为空则执行while循环
        struct TreeNode* node = stack[top]; // 记录栈顶
        res[(*returnSize)++] = node->val;
        top--;
        if (node->right) { // 右子树先进栈
            stack[++top] = node->right;
        }
        if (node->left) {
            stack[++top] = node->left;
        }
    }
    // 反转res数组
    int i = 0, j = *returnSize - 1;
    while (i < j) {
        int temp = res[i];
        res[i] = res[j];
        res[j] = temp;
        i++;
        j--;
    }
}
/*
第二种方法：
    1、沿着根的左孩子，依次入栈，直到左孩子为空;
    2、读栈顶元素进行判定，若右孩子不空且未被访问，将右孩子执行第一步;
    3、栈顶元素出栈。
*/
struct TreeNode* stack[MAX_NODE]; // 定义一个栈
int top = -1; // 栈顶 
void post_order3(struct TreeNode* root, int* res, int* returnSize) {
    struct TreeNode *p = root, *r = NULL; // r标记最近访问过的结点
	while (p || top != -1) {
		if (p) {
			stack[++top] = p;
			p = p->left;
		} else {
			p = stack[top];
			// 获取栈顶元素赋值给p
			// ❤case one❤
			if (p->right && p->right != r) { // 若右孩子存在且未被访问
				p = p->right; // 就让右孩子
				stack[++top] = p; // 入栈
				p = p->left; // 让右孩子向左
				// 上面三句意思就是让右孩子的左孩子一直入栈，一直向左走
			} else {
			    // ❤case two❤
                res[(*returnSize)++] = stack[top--]->val; // 右孩子为空或未被访问过，就出栈
				r = p;  // r标记最近访问结点
				p = NULL;  // r置空
				// 置空原因：因为这个结点已经出栈了
			}
		}
	}
}

int* postorderTraversal(struct TreeNode* root, int* returnSize) {
    int* res = malloc(sizeof(int) * MAX_NODE);
    *returnSize = 0;
    post_order1(root, res, returnSize);
    post_order2(root, res, returnSize);
    post_order3(root, res, returnSize);
    return res;
}

4. 二叉树的层序遍历

代码实现：

/**
 * 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 *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
// returnColumnSizes：用于存储每个数组中元素个数
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }
    int** res = (int**)malloc(sizeof(int*) * 2000);
    *returnColumnSizes = (int*)malloc(sizeof(int) * 2000);
    struct TreeNode* queue[2001]; // 创建一个队列  注意：队头不放元素，长度须+1
    int head = 0; // 队头
    int tail = 0; // 队尾
    queue[++tail] = root; //head:不存放数据，tail:存放数据
    while (head < tail) {
        int colSize = 0, last = tail;
        res[*returnSize] = (int*)malloc(sizeof(int) * (last - head));
        while (head < last) {
            struct TreeNode* node = queue[++head];
            res[*returnSize][colSize++] = node->val;
            if (node->left != NULL) {
                queue[++tail] = node->left;
            }
            if (node->right != NULL) {
                queue[++tail] = node->right;
            }       
        }
        (*returnColumnSizes)[*returnSize] = colSize;
        (*returnSize)++;
    }
    return res;
}

5. 二叉树的层序遍历||

思路：相对于102.二叉树的层序遍历，就是最后把res数组反转一下就可以了

/**
 * 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 *returnColumnSizes array.
 * Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
 */
// returnColumnSizes：用于存储每个数组中元素个数
int** levelOrderBottom(struct TreeNode* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if (root == NULL) {
        return NULL;
    }
    int** res = (int**)malloc(sizeof(int*) * 2000);
    *returnColumnSizes = (int*)malloc(sizeof(int) * 2000);
    struct TreeNode* queue[2001]; // 创建一个队列 注意：队头不放元素，长度须+1
    int head = 0; // 队头
    int tail = 0; // 队尾
    queue[++tail] = root; //head:不存放数据，tail:存放数据
    while (head < tail) {
        int colSize = 0, last = tail;
        res[*returnSize] = (int*)malloc(sizeof(int) * (last - head));
        while (head < last) {
            struct TreeNode* node = queue[++head];
            res[*returnSize][colSize++] = node->val;
            if (node->left) {
                queue[++tail] = node->left;
            }
            if (node->right) {
                queue[++tail] = node->right;
            }       
        }
        (*returnColumnSizes)[*returnSize] = colSize;
        (*returnSize)++;
    }

    // 反转res数组
    int** ret = (int**)malloc(sizeof(int*) * (*returnSize));
    int nums[*returnSize];
    for (int i = 0; i < *returnSize; i++) {
        nums[i] = (*returnColumnSizes)[i];
    }
    for (int i = 0; i < *returnSize; i++) {
        (*returnColumnSizes)[i] = nums[*returnSize - i - 1];
    }

    for (int i = 0; i < *returnSize; i++) {
        ret[i] = (int*)malloc(sizeof(int) * nums[*returnSize - i - 1]);
        for (int j = 0; j < nums[*returnSize - i - 1]; j++) {
            ret[i][j] = res[*returnSize - i - 1][j];
        }
    }
    free(res);
    return ret;
}

6. 二叉树的右视图

思路：层序遍历的时候，判断是否遍历到单层的最后一个元素，如果是，就放进result数组中，随后返回result就可以了

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int* rightSideView(struct TreeNode* root, int* returnSize) {
    int* ret = malloc(sizeof(int) * 100);
    memset(ret, 0, sizeof(int) * 100);
    *returnSize = 0;
    if (root == NULL) {
        return ret;
    }
    struct TreeNode* queue[101]; // 创建一个队列
    int head = 0; // 对头
    int tail = 0; // 队尾
    queue[++tail] = root; //head:不存放数据，tail:存放数据
    while (head < tail) {
        int last = tail;
        while (head < last) {
            struct TreeNode* node = queue[++head];
            if (head == last) {
                ret[(*returnSize)++] = node->val;
            }
            if (node->left) {
                queue[++tail] = node->left;
            }
            if (node->right) {
                queue[++tail] = node->right;
            }
        }
    }
    return ret;
}

7. 二叉树的层平均值

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
double* averageOfLevels(struct TreeNode* root, int* returnSize) {
    double* ret = malloc(sizeof(double) * 10000);
    memset(ret, 0, sizeof(int) * 10000);
    *returnSize = 0;
    if (root == NULL) {
        return ret;
    }
    struct TreeNode* queue[10001]; // 创建一个队列
    int head = 0; // 对头
    int tail = 0; // 队尾
    queue[++tail] = root; //head:不存放数据，tail:存放数据
    while (head < tail) {
        int last = tail;
        double sum = 0;
        int size = tail - head; // 每层结点个数
        while (head < last) {
            struct TreeNode* node = queue[++head];
            sum += node->val;
            if (node->left) {
                queue[++tail] = node->left;
            }
            if (node->right) {
                queue[++tail] = node->right;
            }
        }
        ret[(*returnSize)++] = sum / size;
    }
    return ret;
}

8. N叉树的前序遍历

9. 在每个树行中找最大值 515

10. 填充每个节点的下一个右侧节点指针 116

11. 填充每个节点的下一个右侧节点指针|| 117

12. 翻转二叉树

思路：

在翻转时，需要从根节点往下先交换左右子树，然后再递归到左右子树进行相同的操作

（前序遍历 and 层序遍历）

在翻转时，需要从下往上先交换左右子树，然后再递归到父节点进行交换（后序遍历）
中序遍历不可以（原因：先翻转左子树，然后左右子树交换，这时候再翻转的右子树是之前的左子树）

层序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

// 交换左右子树
void swap(struct TreeNode* root) {
    struct TreeNode* l = root->left;
    struct TreeNode* r = root->right;
    root->left = r;
    root->right = l;
}

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL) {
        return root;
    }
    struct TreeNode* queue[101]; // 创建一个队列
    int head = 0; // 队头
    int tail = 0; // 队尾
    queue[++tail] = root; // head:不存放数据，tail:存放数据
    while (head < tail) {
        struct TreeNode* node = queue[++head];
        swap(node); // 翻转
        if (node->left) {
            queue[++tail] = node->left;
        }
        if (node->right) {
            queue[++tail] = node->right;
        }
    }
    return root;
}

前序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

// 交换左右子树
void swap(struct TreeNode* root) {
    struct TreeNode* l = root->left;
    struct TreeNode* r = root->right;
    root->left = r;
    root->right = l;
}

// 递归：先序遍历
void pre_order(struct TreeNode* root) {
    if (root == NULL) {
        return ;
    }
    swap(root); // 交换
    if (root->left) {
        pre_order(root->left);
    }
    if (root->right) {
        pre_order(root->right);
    }
}

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL) {
        return root;
    }
    pre_order(root);
    return root;
}

后序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

// 交换左右子树
void swap(struct TreeNode* root) {
    struct TreeNode* l = root->left;
    struct TreeNode* r = root->right;
    root->left = r;
    root->right = l;
}

// 递归：后序遍历
void pre_order(struct TreeNode* root) {
    if (root == NULL) {
        return ;
    }
    if (root->left) {
        pre_order(root->left);
    }
    if (root->right) {
        pre_order(root->right);
    }
    swap(root); // 交换
}

struct TreeNode* invertTree(struct TreeNode* root) {
    if (root == NULL) {
        return root;
    }
    pre_order(root);
    return root;
}

13. 对称二叉树

分析：比较的是两个子树的里侧和外侧的元素是否相等

本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool compare(struct TreeNode* l, struct TreeNode* r) {
    // 首先排除空节点的情况
    if (l == NULL && r != NULL) {
        return false;
    } else if (l != NULL && r == NULL) {
        return false;
    } else if (l == NULL && r == NULL) {
        return true;
    } else if (l->val != r->val) { // 排除了空节点，再排除数值不相同的情况
        return false;
    }

    // 此时就是：左右节点都不为空，且数值相同的情况
    // 此时才做递归，做下一层的判断
    return compare(l->left, r->right) && compare(l->right, r->left);
}
 
bool isSymmetric(struct TreeNode* root) {
    if (root == NULL) {
        return true;
    }
    return compare(root->left, root->right);
}

14. 二叉树的最大深度

后序遍历：通过递归函数的返回值做计算树的高度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define max(a, b) ((a) > (b) ? (a) : (b))

int getDepth(struct TreeNode* node) {
    if (node == NULL) {
        return 0;
    }
    int leftDepth = getDepth(node->left); // 左
    int rightDepth = getDepth(node->right); // 右
    int depth = 1 + max(leftDepth, rightDepth); // 中
    return depth;
}

int maxDepth(struct TreeNode* root) {
    return getDepth(root);
}

精简代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define max(a, b) ((a) > (b) ? (a) : (b))

int maxDepth(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    return 1 + max(maxDepth(root->left), maxDepth(root->right));
}

前序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int result;

void getDepth(struct TreeNode* node, int depth) {
    result = depth > result ? depth : result; // 中

    if (node->left == NULL && node->right == NULL) {
        return ;
    }

    // 左
    if (node->left) {
        depth++; // 深度+1
        getDepth(node->left, depth);
        depth--; // 回溯，深度-1
    }
    // 右
    if (node->right) {
        depth++; // 深度+1
        getDepth(node->right, depth);
        depth--; // 回溯，深度-1
    }
}

int maxDepth(struct TreeNode* root) {
    result = 0;
    if (root == NULL) {
        return result;
    }
    getDepth(root, 1);
    return result;
}

层序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int maxDepth(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int depth = 0;
    struct TreeNode* queue[10001];
    int head = 0;
    int tail = 0;
    queue[++tail] = root; //head:不存放数据，tail:存放数据
    while (head < tail) {
        int last = tail;
        depth++;
        while (head < last) {
            struct TreeNode* node = queue[++head];
            if (node->left) {
                queue[++tail] = node->left;
            }
            if (node->right) {
                queue[++tail] = node->right;
            } 
        }
    }
    return depth;
}

15. N叉树的最大深度

16. 二叉树的最小深度

注意：最小深度是从根节点到最近叶子节点的最短路径上的节点数量（左右孩子都为空的节点才是叶子节点！）

后序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define min(a, b) ((a) > (b) ? (b) : (a))

int getDepth(struct TreeNode* node) {
    if (node == NULL) {
        return 0;
    }
    int leftDepth = getDepth(node->left); // 左
    int rightDepth = getDepth(node->right); // 右

    // 当一个左子树为空，右不为空，这时并不是最低点
    if (node->left == NULL && node->right != NULL) { 
        return 1 + rightDepth;
    }
    // 当一个右子树为空，左不为空，这时并不是最低点
    if (node->left != NULL && node->right == NULL) { 
        return 1 + leftDepth;
    }
    int result = 1 + min(leftDepth, rightDepth); 
    return result;
}

int minDepth(struct TreeNode* root) {
    return getDepth(root);
}

精简代码：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define min(a, b) ((a) > (b) ? (b) : (a))

int minDepth(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    if (root->left == NULL && root->right != NULL) {
        return 1 + minDepth(root->right);
    }
    if (root->left != NULL && root->right == NULL) {
        return 1 + minDepth(root->left);
    }
    return 1 + min(minDepth(root->left), minDepth(root->right));
}

层序遍历：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define min(a, b) ((a) > (b) ? (b) : (a))

int minDepth(struct TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int depth = 0;
    struct TreeNode* queue[100001];
    int head = 0;
    int tail = 0;
    queue[++tail] = root; //head:不存放数据，tail:存放数据
    while (head < tail) {
        int last = tail;
        depth++;
        int flag = 0;
        while (head < last) {
            struct TreeNode* node = queue[++head];
            if (node->left) {
                queue[++tail] = node->left;
            }
            if (node->right) {
                queue[++tail] = node->right;
            } 
            if (!node->left && !node->right) { // 当左右孩子都为空的时候，说明是最低点的一层了，退出
                flag = 1;
                break;
            }
        }
        if (flag == 1) {
            break;
        }
    }
    return depth;
}

17. 完全二叉树的节点个数

后序遍历：

层序遍历：

18. 平衡二叉树

二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数

二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数

后序遍历：

层序遍历：

19. 二叉树的所有路径

前序遍历：让父节点指向孩子节点，找到对应的路径

20. 相同的树

21. 左叶子之和

后序遍历（左右中）：通过递归函数的返回值来累加求取左叶子数值之和

22. 找树左下角的值

层序遍历：

前序遍历：深度最大的叶子节点一定是最后一行，记录深度最大的叶子节点，此时就是树的最后一行最左边的值

23. 路径总和

前序遍历：

中序遍历：

后序遍历：

24. 路径总和||

前序遍历：

中序遍历：

后序遍历：

25. 从中序与后序遍历序列构造二叉树

第一步：如果数组大小为零的话，说明是空节点了。

第二步：如果不为空，那么取后序数组最后一个元素作为节点元素。

第三步：找到后序数组最后一个元素在中序数组的位置，作为切割点

第四步：切割中序数组，切成中序左数组和中序右数组（顺序别搞反了，一定是先切中序数组）

第五步：切割后序数组，切成后序左数组和后序右数组

第六步：递归处理左区间和右区间

代码实现：

26. 从前序与中序遍历序列构造二叉树

27. 最大二叉树

分析：构造树一般采用的是前序遍历，因为先构造中间节点，然后递归构造左子树和右子树

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode* construct(const int* nums, int l, int r) {
    if (l > r) {
        return NULL;
    }
    int best = l; // 最大值下标
    for (int i = l + 1; i <= r; i++) {
        if (nums[i] > nums[best]) {
            best = i;
        }
    }
    struct TreeNode* node = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    node->val = nums[best];
    node->left = construct(nums, l, best - 1);
    node->right = construct(nums, best + 1, r);
    return node;
}

struct TreeNode* constructMaximumBinaryTree(int* nums, int numsSize) {
    return construct(nums, 0, numsSize - 1);
}

28. 合并两个二叉树

前序遍历：

中序遍历：

后序遍历：

层序遍历：

29. 二叉搜索树中的搜索

29. 验证二叉搜索树

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

bool isValidBSTHelper(struct TreeNode* root, struct TreeNode* pre) {
    if (root == NULL) {
        return true;
    }
    // 检查左子树
    bool left = isValidBSTHelper(root->left, pre);
    // 检查当前节点
    if (pre != NULL && pre->val >= root->val) {
        return false;
    }
    // 记录前一个节点
    pre = root;
    // 检查右子树
    bool right = isValidBSTHelper(root->right, pre);
    return left && right;
}

bool isValidBST(struct TreeNode* root) {
    // 初始时前一个节点为空
    return isValidBSTHelper(root, NULL);
}

30. 二叉搜索树的最小绝对差

31. 二叉搜索树中的众数

32. 二叉树的最近公共祖先

代码实现：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    if (root == q || root == p || root == NULL) {
        return root;
    }
    struct TreeNode* l = lowestCommonAncestor(root->left, p, q);
    struct TreeNode* r = lowestCommonAncestor(root->right, p, q);
    if (l != NULL && r != NULL) {
        return root;
    }
    if (l == NULL && r != NULL) {
        return r;
    } else if (l != NULL && r == NULL) {
        return l;
    } else {
        return NULL;
    }
}

精简代码：

33. 搜索树的公共祖先问题

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

struct TreeNode* dfs(struct TreeNode* cur, struct TreeNode* p, struct TreeNode* q) {
    if (cur == NULL) {
        return NULL;
    }
    if (cur->val > p->val && cur->val > q->val) { // 左
        struct TreeNode* l = dfs(cur->left, p, q);
        if (l != NULL) {
            return l;
        }
    }

    if (cur->val < p->val && cur->val < q->val) {   // 右
        struct TreeNode* r = dfs(cur->right, p, q);
        if (r != NULL) {
            return r;
        }
    }
    return cur;
}

struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) {
    return dfs(root, p, q);
}

34. 二叉搜索树中的插入操作

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* insertIntoBST(struct TreeNode* root, int val) {
    if (root == NULL) {
        struct TreeNode* node = malloc(sizeof(*node));
        node->left = node->right = NULL;
        node->val = val;
        return node;
    }
    if (root->val > val) {
        root->left = insertIntoBST(root->left, val);
    }
    if (root->val < val) {
        root->right = insertIntoBST(root->right, val);
    }
    return root;
}

35. 删除二叉搜索树中的节点

分析：

有以下五种情况：

第一种情况：没找到删除的节点，遍历到空节点直接返回了
找到删除的节点
- 第二种情况：左右孩子都为空（叶子节点），直接删除节点，返回NULL为根节点
- 第三种情况：删除节点的左孩子为空，右孩子不为空，删除节点，右孩子补位，返回右孩子为根节点
- 第四种情况：删除节点的右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
- 第五种情况：左右孩子节点都不为空，则将删除节点的左子树头结点（左孩子）放到删除节点的右子树的最左边节点的左孩子上，返回删除节点右孩子为新的根节点

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


struct TreeNode* deleteNode(struct TreeNode* root, int key){
    // 第一种情况：没找到删除的节点，遍历到空节点直接返回了
    if (root == NULL) {
        return root;
    }
    if (root->val == key) {
        // 第二种情况：左右孩子都为空（叶子节点），直接删除节点， 返回NULL为根节点
        // 第三种情况：其左孩子为空，右孩子不为空，删除节点，右孩子补位 ，返回右孩子为根节点
        if (root->left == NULL) {
            return root->right;
        // 第四种情况：其右孩子为空，左孩子不为空，删除节点，左孩子补位，返回左孩子为根节点
        } else if (root->right == NULL) {
            return root->left;
        // 第五种情况：左右孩子节点都不为空，则将删除节点的左子树放到删除节点的右子树的最左边节点的左孩子的位置
        // 并返回删除节点右孩子为新的根节点
        } else {
            struct TreeNode* node = root->right; // 找右子树最左边的节点
            while (node->left != NULL) {
                node = node->left;
            }
            node->left = root->left; // 把要删除的节点（root）左子树放在cur的左孩子的位置
            struct TreeNode* tmp = root; // 把root节点保存一下，下面来删除
            root = root->right; // 返回旧root的右孩子作为新root
            free(tmp); // 释放节点内存
            return root;
        }
    }
    if (root->val > key) {
        root->left = deleteNode(root->left, key);
    }
    if (root->val < key) {
        root->right = deleteNode(root->right, key);
    }
    return root;
}

迭代：

36. 修剪二叉搜索树

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
struct TreeNode* trimBST(struct TreeNode* root, int low, int high) {
    if (root == NULL) {
        return NULL;
    }
    if (root->val < low) {
        // 寻找符合区间[low, high]的节点
        return trimBST(root->right, low, high);
    }
    if (root->val > high) {
        // 寻找符合区间[low, high]的节点
        return trimBST(root->left, low, high);
    }
    root->left = trimBST(root->left, low, high); // root->left接入符合条件的左孩子
    root->right = trimBST(root->right, low, high); // root->right接入符合条件的右孩子
    return root;
}

37. 将有序数组转换为二叉搜索树

分析：分割数组中间位置的节点

递归：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

// 左闭右闭
struct TreeNode* pre_order(int* nums, int l, int r) {
    if (l > r) {
        return NULL;
    }
    int mid = (r + l) / 2;
    struct TreeNode* root = malloc(sizeof(*root));
    root->left = root->right = NULL;
    root->val = nums[mid];
    root->left = pre_order(nums, l, mid - 1);
    root->right = pre_order(nums, mid + 1, r);
    return root;
}

struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
    return pre_order(nums, 0, numsSize - 1);
}

38. ✌把二叉搜索树转换为累加树

反中序遍历（递归）：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

int pre; // 记录前一个结点的数值

// 反中序遍历（右左中） 递归
void mid_order(struct TreeNode* root) {
    if (root == NULL) {
        return ;
    }
    mid_order(root->right);
    root->val += pre;
    pre = root->val;
    mid_order(root->left);
}

struct TreeNode* convertBST(struct TreeNode* root) {
    pre = 0;
    mid_order(root);
    return root;
}

反中序遍历（迭代）：

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

#define MAX_NODE 10000

int pre; // 记录前一个结点的数值

// 反中序遍历（右左中） 迭代
void mid_order(struct TreeNode* root) {
    if (root == NULL) {
        return ;
    }
    struct TreeNode* stack[MAX_NODE]; // 创建一个栈
    int top = -1; // 栈顶
    struct TreeNode* p = root;
    struct TreeNode* q = NULL;
    while (p || top != -1) {
		if (p) {
			stack[++top] = p;
			p = p->right; // 右
		} else {
			q = stack[top];
			q->val += pre;
            pre = q->val;
            top--;
			p = q->left; // 左
		}
	}
}

struct TreeNode* convertBST(struct TreeNode* root) {
    pre = 0;
    mid_order(root);
    return root;
}

你可能感兴趣的:(数据结构与算法,数据结构)

Java高频面试之集合-02 牛马baby java 面试开发语言
hello啊，各位观众姥爷们！！！本baby今天来报道了！哈哈哈哈哈嗝面试官：说说队列queueJava队列（Queue）详解队列（Queue）是Java集合框架中一种先进先出（FIFO）的线性数据结构，广泛应用于生产者-消费者模型、任务调度、线程池等场景。Java提供了丰富的队列实现，涵盖线程安全、阻塞、优先级等特性。一、队列的核心接口与操作Java队列的顶层接口是java.util.Queue
ArrayList 和 LinkedList区别重生之我在成电转码 java 多线程系统
一、底层实现特性ArrayListLinkedList数据结构动态数组（Object[]数组）双向链表（每个节点有前驱和后继）内存布局连续内存，空间利用率高非连续内存，空间占用大元素访问方式下标随机访问（基于索引）只能顺序遍历，找元素慢⏱二、时间复杂度对比（核心！）操作ArrayListLinkedList随机访问O(1)O(n)头部插入O(n)（全体后移）O(1)中间插入O(n)O(n)尾部插入
Java架构师成长之路 hweiyu00 分享 spring 微服务 spring cloud java
概述本教程主要从6个方面，全面讲解Java技术栈的知识。1.性能调优深入理解MySQL底层原理、索引逻辑，数据结构与算法。使用Explain进行优化分析MVCC原理剖析日志机制解析2.框架源码掌握Spring底层原理带你手写一个Spring解析IOC、AOP源码、以及事务原理3.并发编程剖析Java底层锁机制CAS、JUC工具使用、AQS源码分析以及并发的集合类的讲解4.分布式开发剖析分布式中使用
Golang算法（二）数据结构小烧卖算法 GO语言
数据结构栈队列双向链表二叉搜索树红黑树栈typeStackstruct{head*Node}typeNodestruct{datainterface{}next*Node}funcNewStack()*Stack{s:=&Stack{head:&Node{data:nil,next:&Node{},},}returns}func(s*Stack)Push(datainterface{}){n:=&
数据结构之顺序表和栈 Dust-Chasing 数据结构算法 c语言
一、顺序表1.1顺序表的概念及结构顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，一般情况下采用数组存储。在数组上完成数据的增删查改。1.2静态顺序表静态顺序表，即使用定长的数组来存储元素，用下面一张图就可以清楚看懂1.3动态顺序表动态顺序表：使用动态开辟的数组存储。与静态顺序表不同，动态顺序表使用的数组大小可以动态变化，从而实现更灵活的储存数据。二、动态顺序表的实现静态顺序表只适
数据结构之链表（单链表） Dust-Chasing 数据结构链表 c语言
目录一、链表的概念二、链表的分类三、单链表的实现1.创建新的节点2.打印链表3.链表的头插和尾插尾插：要注意第一次插入时链表为空的情况。头插：4.单链表的头删和尾删尾删：注意链表中只有一个元素的情况。且要保存尾节点的前一个节点。头删：5.单链表的查找一、链表的概念链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表实际上就像一列火车一样，每一个
186.HarmonyOS NEXT系列教程之列表切换案例数据管理详解 harmonyos-next
温馨提示：本篇博客的详细代码已发布到git:https://gitcode.com/nutpi/HarmonyosNext可以下载运行哦！HarmonyOSNEXT系列教程之列表切换案例数据管理详解效果演示1.数据模型设计1.1ListInfo类@ObservedexportclassListInfo{//列表项数据结构icon:ResourceStr='';//图标资源name:Resource
在SPSS中进行单因素方差分析（One-Way ANOVA）是一种常见的统计分析方法，用于比较三个或更多独立组之间的均值差异。 zhangfeng1133 均值算法算法
在SPSS中进行单因素方差分析（One-WayANOVA）是一种常见的统计分析方法，用于比较三个或更多独立组之间的均值差异。以下是进行单因素方差分析的详细步骤：---###1.**数据准备**-**因变量**：需要分析的连续变量（如成绩、收入等）。-**自变量**：分类变量（如组别、性别等），通常是一个名义变量。数据结构示例：|组别（自变量）|成绩（因变量）||----------------|-
如何进行PHP性能优化？破碎的天堂鸟 PHP学习 php 性能优化开发语言
PHP性能优化是一个复杂且多方面的过程，涉及从代码层面到服务器配置的多个方面。以下是一些关键的优化技巧和最佳实践：选择合适的数据结构（如数组、对象等）可以显著提高程序的运行效率。缓存是提升PHP性能的有效手段之一。可以通过页面缓存、数据缓存、内存缓存等方式来减少重复计算。例如，使用APC、Memcached或Redis进行内存缓存，或者利用文件系统进行数据缓存。使用索引、优化SQL查询语句以及使用
卷积神经网络 - 理解卷积核的尺寸 k×k×Cin 谦亨有终 AI学习笔记 cnn 人工智能神经网络深度学习机器学习
卷积神经网络中，每个卷积核的尺寸为k×k×Cin，这一设计的核心原因在于多通道输入的数据结构和跨通道特征整合的需求。以下是详细解释：1.输入数据的结构输入形状：假设输入数据为三维张量，形状为H×W×Cin，其中：H：高度（Height）W：宽度（Width）Cin：通道数（Channelsin）多通道的物理意义：对于RGB图像，Cin=3（红、绿、蓝三通道）。对于中间层的特征图，Cin可能为64、
使用 NetworkX 进行图论分析与可视化 aiweker 跟我学python 图论 python
使用NetworkX进行图论分析与可视化NetworkX是一个用于创建、操作和研究复杂网络的Python库。它提供了丰富的图论算法和数据结构，适用于各种网络分析任务。本文将分点介绍NetworkX的主要功能，并通过代码示例进行详细说明。1.安装NetworkX在开始使用NetworkX之前，首先需要安装它。可以通过pip进行安装：pipinstallnetworkx2.创建图NetworkX支持多
C语言_数据结构总结8：链式队列 *.✧屠苏隐遥(ﾉ◕ヮ◕)ﾉ*.✧ C语言—数据结构数据结构 c语言开发语言 visualstudio visual studio 链表
纯C语言实现，不涉及C++链队列队列的链式表示称为链队列，它实际上是一个同时具有队头指针和队尾指针的单链表，头指针指向对头结点，尾指针指向队尾结点。头结点是链式队列中的特殊结点，通常不存储实际的队列元素数据，其主要作用是方便对队列的操作，例如在进行入队、出队操作时，可以统一操作逻辑，无需特殊处理队列为空的情况。它作为队列的头部标识，其next指针指向队列中的第一个真正存储数据的结点。尾结点（注意区
C语言_数据结构总结10：二叉树的递归/非递归遍历 *.✧屠苏隐遥(ﾉ◕ヮ◕)ﾉ*.✧ C语言—数据结构数据结构算法链表 visualstudio visual studio c语言 b树
纯C语言实现，不涉及C++遍历是二叉树各种操作的基础，例如对于一棵给定二叉树求结点的双亲/求结点的孩子/求二叉树的高度/求叶结点个数/判断两棵二叉树是否相等……所有这些操作都是在二叉树遍历的过程中进行的。因此必须掌握二叉树的各种遍历过程，并能灵活用以解决各种问题。常见的遍历次序有：先序，中序，后序->其中“序”是指根结点何时被访问。先序：根结点->左子树->右子树中序:左子树->根结点->右子树后
访问者模式【行为模式C++】 GoWjw 设计模式访问者模式
1.概述访问者模式是一种行为设计模式，它能将算法与其所作用的对象隔离开来。访问者模式主要解决的是数据与算法的耦合问题，尤其是在数据结构比较稳定，而算法多变的情况下。为了不污染数据本身，访问者会将多种算法独立归档，并在访问数据时根据数据类型自动切换到对应的算法，实现数据的自动响应机制，并确保算法的自由扩展。访问者模式在实际开发中使用的非常少，因为它比较难以实现并且应用该模式肯能会导致代码的可读性变差
【重温设计模式】访问者模式及其Java示例万猫学社重温设计模式及其Java实现设计模式访问者模式 java
访问者模式的基本概念访问者模式，一种行为型设计模式，其基本定义是：允许一个或者多个操作应用到一组对象上，解耦操作和对象的具体类，使得操作的添加可以独立于对象的类结构变化。在面向对象编程中，访问者模式的重要性不言而喻。它将数据操作和数据结构分离，使得在不改变数据结构的前提下，可以添加新的操作，从而增强了系统的灵活性和可扩展性。在访问者模式中，数据结构是稳定的，而操作是易变的。这就像一座博物馆，展品（
访问者模式烟沙九洲设计模式访问者模式 java
访问者（Visitor）模式属于行为型模式的一种。访问者模式主要用于分离算法和对象结构，从而在不修改原有对象的情况下扩展新的操作。它适用于数据结构相对稳定，而操作（行为）容易变化的场景。访问者模式允许在不修改现有类的情况下，为类层次结构中的对象定义新的操作。访问者模式通过将操作封装到一个独立的类（即访问者）中，使得对象结构与操作解耦。访问者模式使用了一种名为双分派（在运行时根据两个对象的类型动态选
ngx_http_conf_port_t 若云止水 http 网络协议网络
定义在src\http\ngx_http_core_module.htypedefstruct{ngx_int_tfamily;in_port_tport;ngx_array_taddrs;/*arrayofngx_http_conf_addr_t*/}ngx_http_conf_port_t;该结构体用于在Nginx配置阶段存储监听端口的配置信息，是listen指令解析后的核心数据结构。它将同一
AtCoder备赛冲刺必刷题（C++） | 洛谷 AT_abc396_a Triple Four 热爱编程的通信人 c++算法开发语言
本文分享的必刷题目是从蓝桥云课、洛谷、AcWing等知名刷题平台精心挑选而来，并结合各平台提供的算法标签和难度等级进行了系统分类。题目涵盖了从基础到进阶的多种算法和数据结构，旨在为不同阶段的编程学习者提供一条清晰、平稳的学习提升路径。欢迎大家订阅我的专栏：算法题解：C++与Python实现！附上汇总贴：算法竞赛备考冲刺必刷题（C++）|汇总【题目来源】洛谷：AT_abc396_a[ABC396A]
算法及数据结构系列 - 滑动窗口诺亚凹凸曼算法及数据结构算法数据结构 java
系列文章目录算法及数据结构系列-二分查找算法及数据结构系列-BFS算法算法及数据结构系列-动态规划算法及数据结构系列-双指针算法及数据结构系列-回溯算法算法及数据结构系列-树文章目录滑动窗口框架思路经典题型76.最小覆盖子串567.字符串的排列438.找到字符串中所有字母异位词3.无重复字符的最长子串滑动窗口框架思路/*滑动窗口算法框架*/voidslidingWindow(strings,str
数据结构二叉树进阶 z一一m 数据结构数据结构算法
1.根据二叉树创建字符串1.题目2.分析原理要把二叉树元素按照前序顺序取出来，并且以字符串的形式返回，还要添加括号对于左子树和右子树，那么第一步就是向定义一个string类型来接收取出的元素，需要用到to_string函数把整型变成string类型，第二步就是递归来深度遍历了，但是需要判断一下，题目有些情况是省略了括号，有些没有省去，题目例子可以知道左为空右不为空就不能省略括号，左不为空右为空就可
C/C++数据类型--整型类型蓝心湄 C/C++数据类型 c语言
概念数据类型表示的是数据的身份决定它可以进行什么操作、占用多少空间与数据结构的区别数据类型更倾向于表示数据的身份数据结构表示的是怎么操作数据（是在类型的基础上进行对数据的操作的）C语言允许使用的类型类型的分类算术类型：基本类型和枚举类型纯量类型：算术类型和指针类型组合类型：数组类型和结构体类型整型数据基本整型（int）长度为2字节或4字节短整型（shortint）长度为2字节长整型（longint
7种数据结构就很对数据结构 windows
7种数据结构顺序表sqlite.hseqlite.c单链表linklist.clinklist.h双链表doulinklist.cdoulinklist.h链式栈linkstack.clinkstack.h队列SeqQueue.cSeqQueue.h树tree.c哈希表hash.c顺序表sqlite.h#ifndef__SEQLIST_H__#define__SEQLIST_H__typedefs
python爬虫Redis数据库 Æther_9 Python爬虫零基础入门数据库 python 爬虫
Redis数据库Redis简介Redis是完全开源免费的，遵守BSD协议，是一个高性能的key-value数据库。Redis与其他key-value缓存产品有以下三个特点：Redis支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。Redis不仅仅支持简单的key-value类型的数据，同时还提供list，set，zset，hash等数据结构的存储。redis：半持
C语言动态顺序表的实现しかし118114 数据结构数据库 c语言经验分享数据结构链表
目录（一）静态顺序表（二）动态顺序表顺序表是数据结构的入门，本篇文章将详细介绍动态顺序表的增删改补。我们先了解一下静态顺序表。（一）静态顺序表静态顺序表是顺序表的一种，由于静态顺序表的大小固定，很容易溢出或浪费空间，所以我们一般不用静态顺序表。所有顺序表的实现都是基于数组实现的，其实顺序表是顺序表的pro版，可以装更多的数据。#defineTypedataint//这里定义的顺序表是int类型的/
什么是C++对象之间的view proxies 东北豆子哥 C++c++
在C++中，viewproxies是一种轻量级的对象，用于提供对另一个对象的间接访问或视图，而不直接拥有或管理该对象的数据。它们通常用于简化对复杂数据结构的访问，或在不需要复制数据的情况下提供特定的视图。1.ViewProxies的核心概念轻量级：Viewproxies通常不拥有数据，而是引用或包装另一个对象的数据。间接访问：通过viewproxies，可以以特定的方式访问或操作底层数据，而不需要
《Hello 算法》火了！！！一本写给算法初学者的入门算法书籍遇码分享算法 hello hello算法算法书籍
曾经也放出豪言壮语，决心要刷遍力扣上的所有算法题目。然而现实就很快啪啪的打脸。不知道多少人和我有过一样的经历。在读到《Hello算法》的序中，作者靳宇栋给了我们一个“台阶”。随后就表达了针对我们的现状，他特地写了《Hello算法》这本书，代表广大算法初学者表示感激涕零。《Hello算法》为什么适合入门动画图解、一键运行的数据结构与算法教程全书采用动画图解，内容清晰易懂、学习曲线平滑，引导初学者探索
java队列实现限流_如何使用队列实现微服务限流算法？纽太普 java队列实现限流
队列在平时开发中可能是出现频率最高的数据结构之一了，但是大部分情况下，我们都是用别人已经实现好的，比如kafka，比如redis里的list，以至于让人怀疑为什么还要去学习队列呢？希望今天的内容可以给你一些启发。什么是队列为了整个文章的完整性，我们还是来介绍一下什么是队列。我们举个生活中常见的案例，假设你在周杰伦的奶茶店买奶茶，由于人很多，为了保持公平和秩序，你被要求排队，最先来的人排到最前面，这
麒麟服务器操作系统Redis部署手册太极淘麒麟操作系统管理工具服务器 redis 运维
软件简介Redis****介绍REmoteDIctionaryServer(Redis)是一个由SalvatoreSanfilippo写的key-value存储系统，是跨平台的非关系型数据库。Redis是一个开源的使用ANSIC语言编写、遵守BSD协议、支持网络、可基于内存、分布式、可选持久性的键值对(Key-Value)存储数据库，并提供多种语言的API。Redis通常被称为数据结构服务器，因为
零基础上手Python数据分析 (7)：Python 面向对象编程初步 kakaZhui python 数据分析 excel
写在前面回顾一下，我们已经学习了Python的基本语法、数据类型、常用数据结构和文件操作、异常处理等。到目前为止，我们主要采用的是面向过程(ProceduralProgramming)的编程方式，即按照步骤一步一步地编写代码，解决问题。这种方式对于简单的任务已经足够，但当程序变得越来越复杂，代码量越来越大时，面向过程编程可能会显得力不从心，代码难以组织、复用和维护。代码复杂性带来的挑战：面向过程v
JavaScript数组-遍历数组咖啡の猫 javascript 开发语言
在JavaScript开发过程中，数组是一种非常常见且强大的数据结构，用于存储一系列有序的数据项。遍历数组是处理这些数据项的基础操作之一，无论是为了显示、转换还是过滤数据。本文将详细介绍几种常见的遍历数组的方法及其应用场景，帮助你选择最适合当前任务的方式。一、为什么需要遍历数组？遍历数组意味着逐一访问数组中的每个元素，以便执行特定的操作，如打印输出、修改值或基于条件筛选数据。不同的场景可能需要不同
PHP，安卓，UI，java，linux视频教程合集 cocos2d-x小菜 java UI linux PHP android
╔-----------------------------------╗┆
zookeeper admin 笔记 braveCS zookeeper
Required Software 1) JDK>=1.6 2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘数据和日志目录 1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
Spring配置多个连接池 easterfly spring
项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ Spring中有关于dataSource的配置： <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" &nb
Mysql 171815164 mysql
例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI TH GRANT OPTION; 如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
CommonDAO（公共/基础DAO） g21121 DAO
好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
直言有讳永夜-极光感悟随笔
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 精华: “直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
安装CentOS 7 和Win 7后，Win7 引导丢失随便小屋 centos
一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。一、首先具有root 的权限。即进入Terminal后输入命令su，然后输入密码即可二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 v
Oracle备份与恢复案例 aijuans oracle
Oracle备份与恢复案例一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
JavaEE开源快速开发平台G4Studio v5.0发布無為子
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。访问G4Studio网站 http://www.g4it.org 2013-04-06 发布G4Studio_V5.0版本功能新增 (1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
Oracle显示根据高考分数模拟录取百合不是茶 PL/SQL编程 oracle例子模拟高考录取学习交流
题目要求: 1,创建student表和result表 2,pl/sql对学生的成绩数据进行处理 3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 1,创建student表,和result表学生信息表; create table student( student_id number primary key,--学生id
优秀的领导与差劲的领导 bijian1013 领导管理团队
责任优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。努力工作优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
js函数在浏览器下的兼容 Bill_chen jquery 浏览器 IE DWR ext
做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： IE6：node.nextSibling,对于FF是不能识别的； FF：node.nextElementSibling,对于IE是不能识别的；兼容解决方式：var Div = node.nextSibl
【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC) bit1129 垃圾回收
吞吐量与用户线程暂停时间衡量垃圾回收算法优劣的指标有两个：吞吐量越高，则算法越好暂停时间越短，则算法越好首先说明吞吐量和暂停时间的含义。垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
J2EE监听器和过滤器基础白糖_ J2EE
Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 ServletContex监听器 ServletContex又叫application
博弈AngularJS讲义(16) - 提供者 boyitech js AngularJS api Angular Provider
Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 bylijinnan java
public class CommonSubSequence { /** * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。 * 写一个版本算法复杂度O(N^2)和一个O(N) 。 * * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。 * O(
sqlserver 2000 无法验证产品密钥 Chen.H sql windows SQL Server Microsoft
在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。这样做, 收到以下错误信息CD KEY的 SQ
[新概念武器]气象战争 comsci
气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 原因如下: 地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
oracle 中 rollup、cube、grouping 使用详解 daizj oracle grouping rollup cube
oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示转自namesliu -- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景 --- ROLLUP ，为了理解分组的成员数量，我增加了分组的计数 COUNT(SAL)
技术资料汇总分享 Dead_knight 技术资料汇总分享
本人汇总的技术资料，分享出来，希望对大家有用。 http://pan.baidu.com/s/1jGr56uE 资料主要包含： Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) Ser
初一下学期难记忆单词背诵第一课 dcj3sjt126com english word
could 能够 minute 分钟 Tuesday 星期二 February 二月 eighteenth 第十八 listen 听 careful 小心的，仔细的 short 短的 heavy 重的 empty 空的 certainly 当然 carry 携带；搬运 tape 磁带 basket 蓝子 bottle 瓶 juice 汁，果汁 head 头；头部
截取视图的图片, 然后分享出去 dcj3sjt126com OS Objective-C
OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. I implemented a category method on UIView to get the vi
MySql重置密码 fanxiaolong MySql重置密码
方法一: 在my.ini的[mysqld]字段加入： skip-grant-tables 重启mysql服务，这时的mysql不需要密码即可登录数据库然后进入mysql mysql>use mysql; mysql>更新 user set password=password('新密码') WHERE User='root'; mysq
Ehcache（03）——Ehcache中储存缓存的方式 234390216 ehcache MemoryStore DiskStore 存储驱除策略
Ehcache中储存缓存的方式目录 1 堆内存（MemoryStore） 1.1 指定可用内存 1.2 驱除策略 1.3 元素过期 2 &nbs
spring mvc中的@propertysource jackyrong spring mvc
在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： @PropertySource 在spring 3.1中开始引入比如有配置文件 config.properties mongodb.url=1.2.3.4 mongodb.db=hello 则代码中 @PropertySource(&
重学单例模式 lanqiu17 单例 Singleton 模式
最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式静态内部类方式: package test.pattern.singleton.statics; publ
.NET开源核心运行时，且行且珍惜 netcome java .net 开源
背景 2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
使用oscahe缓存技术减少与数据库的频繁交互 Everyday都不同 Web 高并发 oscahe缓存
此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
Spring+Mybatis 手动控制事务 toknowme mybatis
@Override public boolean testDelete(String jobCode) throws Exception { boolean flag = false; &nbs
菜鸟级的android程序员面试时候需要掌握的知识点 xp9802 android
熟悉Android开发架构和API调用掌握APP适应不同型号手机屏幕开发技巧熟悉Android下的数据存储熟练Android Debug Bridge Tool 熟练Eclipse/ADT及相关工具熟悉Android框架原理及Activity生命周期熟练进行Android UI布局熟练使用SQLite数据库；熟悉Android下网络通信机制，S