226. 翻转二叉树
题解:
解法一:
- 通过遍历整个二叉树解题
- 对于当前节点,如果不为空,则交换它的两个子节点,否则直接返回当前节点
- 对两个子节点进行同样的操作
- 前序位置或者后序位置都可以进行节点交换的操作
后序位置
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {TreeNode}
*/
var invertTree = function(root) {
var traverse = function(root) {
if(!root) {
return;
}
console.log(root)
traverse(root.left);
traverse(root.right);
let t = root.left;
root.left = root.right;
root.right = t;
}
traverse(root);
return root
};
前序位置
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {TreeNode}
*/
var invertTree = function(root) {
if(!root) {
return root;
}
let t = root.left;
root.left = root.right;
root.right = t;
invertTree(root.left);
invertTree(root.right);
return root;
};
解法二:
通过递归函数定义
5. 递归函数就是反转一个二叉树,然后返回该二叉树的根节点
6. 那么对于当前节点的左子树就等于反转后的右子树
7. 当前节点的右子树就等于反转后的左子树
/**
* Definition for a binary tree node.
* function TreeNode(val, left, right) {
* this.val = (val===undefined ? 0 : val)
* this.left = (left===undefined ? null : left)
* this.right = (right===undefined ? null : right)
* }
*/
/**
* @param {TreeNode} root
* @return {TreeNode}
*/
var invertTree = function(root) {
if(!root) {
return root;
}
let left = invertTree(root.left);
let right = invertTree(root.right);
root.left = right;
root.right = left;
return root;
};
116. 填充每个节点的下一个右侧节点指针
题解:
- 除了要把相同父节点的左右子树连接, 还要把不同父节点的左右节点连接
- 所以要遍历二叉树的时候, 需要把左右节点都传入
- 先把当前左节点指向当前的右节点
- 然后将左节点的左右子树链接
- 把右节点左右子树链接
- 把左节点的右子树和右节点的左子树链接
- 返回root
/**
* // Definition for a Node.
* function Node(val, left, right, next) {
* this.val = val === undefined ? null : val;
* this.left = left === undefined ? null : left;
* this.right = right === undefined ? null : right;
* this.next = next === undefined ? null : next;
* };
*/
/**
* @param {Node} root
* @return {Node}
*/
var connect = function(root) {
let traverse = function(leftT, rightT) {
if(!leftT || !rightT) {
return;
}
leftT.next = rightT;
traverse(leftT.left, leftT.right);
traverse(rightT.left, rightT.right);
traverse(leftT.right, rightT.left);
}
if(!root) {
return null;
}
traverse(root.left, root.right);
return root;
};
插入排序
思路: 从第二个元素arr[i]开始,和之前的元素arr[j]进行比较,找到它第一个大于的元素,然后插入到该元素前面
#include <stdio.h>
int a[1010];
void Input(int n, int *a) {
for(int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
}
void Output(int n, int *a) {
for(int i = 0; i < n; ++i) {
if(i)
printf(" ");
printf("%d", a[i]);
}
puts("");
}
void InsertSort(int n, int *a) { // (1)
int i, j;
for(i = 1; i < n; ++i) {
int x = a[i]; // (2)
for(j = i-1; j >= 0; --j) { // (3)
if(x <= a[j]) { // (4)
a[j+1] = a[j]; // (5)
}else
break; // (6)
}
a[j+1] = x; // (7)
}
}
int main() {
int n;
while(scanf("%d", &n) != EOF) {
Input(n, a);
InsertSort(n, a);
Output(n, a);
}
return 0;
}
选择排序
从0 - n的位置,每次选择一个最小的元素填入
#include <stdio.h>
int a[1010];
void Input(int n, int *a) {
for(int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
}
}
void Output(int n, int *a) {
for(int i = 0; i < n; ++i) {
if(i)
printf(" ");
printf("%d", a[i]);
}
puts("");
}
void Swap(int *a, int *b) {
int tmp = *a;
*a = *b;
*b = tmp;
}
void SelectionSort(int n, int *a) { // (1)
int i, j;
for(i = 0; i < n - 1; ++i) { // (2)
int min = i; // (3)
for(j = i+1; j < n; ++j) { // (4)
if(a[j] < a[min]) {
min = j; // (5)
}
}
Swap(&a[i], &a[min]); // (6)
}
}
int main() {
int n;
while(scanf("%d", &n) != EOF) {
Input(n, a);
SelectionSort(n, a);
Output(n, a);
}
return 0;
}