题目：
题解：
前序遍历
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
preorder(root, result);
return result;
}
public void preorder(TreeNode root, List<Integer> result) {
if (root == null) {
return;
}
result.add(root.val);
preorder(root.left, result);
preorder(root.right, result);
}
}
中序遍历
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
inorder(root, res);
return res;
}
void inorder(TreeNode root, List<Integer> list) {
if (root == null) {
return;
}
inorder(root.left, list);
list.add(root.val); // 注意这一句
inorder(root.right, list);
}
}
后续遍历
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList<>();
postorder(root, res);
return res;
}
void postorder(TreeNode root, List<Integer> list) {
if (root == null) {
return;
}
postorder(root.left, list);
postorder(root.right, list);
list.add(root.val); // 注意这一句
}
}
解析：递归遍历，前序遍历：根左右遍历。中序遍历：左根右。后续遍历：左右根。
题目：
题解：
前序遍历
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result= new ArrayList<>();
if(root==null){
return result;
}
Stack<TreeNode> stack =new Stack();
stack.push(root);
while(!stack.isEmpty()){
TreeNode node= stack.pop();
result.add(node.val);
if(node.right!=null){
stack.push(node.right);
}
if(node.left!=null){
stack.push(node.left);
}
}
return result;
}
}
中序遍历
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
if (root == null){
return result;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while (cur != null || !stack.isEmpty()){
if (cur != null){
stack.push(cur);
cur = cur.left;
}else{
cur = stack.pop();
result.add(cur.val);
cur = cur.right;
}
}
return result;
}
}
后序遍历：
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<>();
if (root == null){
return result;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while (!stack.isEmpty()){
TreeNode node = stack.pop();
result.add(node.val);
if (node.left != null){
stack.push(node.left);
}
if (node.right != null){
stack.push(node.right);
}
}
Collections.reverse(result);
return result;
}
}
解析：
前序遍历：
前序遍历如图所示：
中序遍历如图所示：
后续遍历类似。
题目：力扣题目链接
给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
示例 1：
输入：root = [3,9,20,null,null,15,7]
输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1]
输出：[[1]]
示例 3：
输入：root = []
输出：[]
题解：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<List<Integer>> resList= new ArrayList<List<Integer>>();
public List<List<Integer>> levelOrder(TreeNode root) {
check(root);
return resList;
}
public void check(TreeNode node){
if(node ==null){
return;
}
Queue<TreeNode> que= new LinkedList<TreeNode>();
que.offer(node);
while(!que.isEmpty()){
List<Integer> itemList= new ArrayList<Integer>();
int len=que.size();
while(len>0){
TreeNode tmpNode = que.poll();
itemList.add(tmpNode.val);
if(tmpNode.left!=null){
que.offer(tmpNode.left);
}
if(tmpNode.right!=null){
que.offer(tmpNode.right);
}
len--;
}
resList.add(itemList);
}
}
}
解析：
借助队列：
用一个list集合嵌套一个list集合里面包含每一层的数值，借助队列，把根元素加到队列里面，统计队列里面元素个数，弹出一个元素，加到tmplist集合里面，再把弹出元素的左右节点（如果有）加入队列，len--，直到把原始队列里面元素全部弹完，len=0.然后把这一层的元素加到resList队列里面，不断遍历循环，直到队列为空结束，最后返回reslist，实现二叉树的层序遍历。
题目：
翻转一棵二叉树。
题解：
迭代法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null){
return null;
}
ArrayDeque<TreeNode> deque= new ArrayDeque<>();
deque.offer(root);
while(!deque.isEmpty()){
int size=deque.size();
while(size-->0){
TreeNode node= deque.poll();
swap(node);
if(node.left!=null){
deque.offer(node.left);
}
if(node.right!=null){
deque.offer(node.right);
}
}
}
return root;
}
public void swap(TreeNode root){
TreeNode t=root.left;
root.left=root.right;
root.right=t;
}
}
解析：
ArrayDeque的介绍：
ArrayDeque是 Deque接口的一个实现，使用了可变数组，所以没有容量上的限制。同时， ArrayDeque是线程不安全的，在没有外部同步的情况下，不能再多线程环境下使用。
ArrayDeque是 Deque的实现类，可以作为栈来使用，效率高于 Stack；也可以作为队列来使用，效率高于 LinkedList。
ArrayDeque 是 Java 集合中双端队列的数组实现，双端队列的链表实现（LinkedList）
需要注意的是， ArrayDeque不支持 null值。
用ArrayDeque当作一个队列，先把根节点放入队列中，当队列不为空，且队列中元素大于0时，先弹出一个元素，把这个元素的左右子树进行交换，当存在左子树或右子树的情况，则依次加入队列中
递归法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public TreeNode invertTree(TreeNode root) {
if(root==null){
return null;
}
invertTree(root.left);
invertTree(root.right);
swapChildren(root);
return root;
}
private void swapChildren(TreeNode root) {
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
}
}
解析：当根节点不存在时返回null，存在则把根的左子树放入递归操作，然后在把右子树放入递归操作，接着执行交换的方法。递归完成后，也完成了反转的逻辑。
题目：力扣题目链接
给定一个二叉树，检查它是否是镜像对称的。
题解：
递归法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
return compare(root.left,root.right);
}
private boolean compare(TreeNode left,TreeNode right){
if(left==null&&right!=null){
return false;
}
if(left!=null&&right==null){
return false;
}
if(left==null&&right==null){
return true;
}
if(left.val!=right.val){
return false;
}
//比较外侧
boolean compareOutside= compare(left.left,right.right);
//比较内测
boolean compareInside= compare(left.right,right.left);
return compareOutside&&compareInside;
}
}
解析：把不对称或对称的情况进行判断返回，分别递归比较外侧和内测，最后返回内外侧即可。
迭代法：使用双端队列，相当于两个栈
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isSymmetric(TreeNode root) {
Deque<TreeNode> deque = new LinkedList<>();
deque.offerFirst(root.left);
deque.addLast(root.right);
while(!deque.isEmpty()){
TreeNode leftNode= deque.pollFirst();
TreeNode rightNode=deque.pollLast();
if(leftNode==null&&rightNode==null){
continue;
}
if(leftNode==null||rightNode==null||leftNode.val!=rightNode.val){
return false;
}
deque.offerFirst(leftNode.left);
deque.offerFirst(leftNode.right);
deque.offerLast(rightNode.right);
deque.offerLast(rightNode.left);
}
return true;
}
}
解析：双端队列往头插入根节点的左节点，往尾插入根节点的右节点，在栈不为空的情况下，分别从两端弹出，然后判断对称条件进行返回，最后往栈里头部插入左节点的左节点，再往头部插入左节点的右节点，继续往尾部插入右节点的右节点，最后往尾部插入右节点的左节点，使弹出的两个元素全为外侧或全为内侧进行检查是否为轴对称。，当栈为空时，表示二叉树中所有元素进行了轴对称检查。
迭代法：使用普通队列：
public boolean isSymmetric3(TreeNode root) {
Queue<TreeNode> deque = new LinkedList<>();
deque.offer(root.left);
deque.offer(root.right);
while (!deque.isEmpty()) {
TreeNode leftNode = deque.poll();
TreeNode rightNode = deque.poll();
if (leftNode == null && rightNode == null) {
continue;
}
// if (leftNode == null && rightNode != null) {
// return false;
// }
// if (leftNode != null && rightNode == null) {
// return false;
// }
// if (leftNode.val != rightNode.val) {
// return false;
// }
// 以上三个判断条件合并
if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
return false;
}
// 这里顺序与使用Deque不同
deque.offer(leftNode.left);
deque.offer(rightNode.right);
deque.offer(leftNode.right);
deque.offer(rightNode.left);
}
return true;
}
解析：同上面
题目：力扣题目链接
给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3
/
9 20
/
15 7
返回它的最大深度 3 。
题解：递归法：
class Solution {
public int maxDepth(TreeNode root) {
if(root==null){
return 0;
}
int leftDepth= maxDepth(root.left);
int rightDepth = maxDepth(root.right);
return Math.max(leftDepth,rightDepth)+1;
}
}
解析：如果根节点为空最大深度为0，根节点不为空时，分别递归左子树和右子树，最后选择深度较大者加上根节点则为二叉树的最大深度。
题解：迭代法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int maxDepth(TreeNode root) {
if(root==null){
return 0;
}
Deque<TreeNode> deque= new LinkedList();
deque.offer(root);
int depth=0;
while(!deque.isEmpty()){
int size=deque.size();
depth++;
for(int i=0;i<size;i++){
TreeNode node=deque.poll();
if(node.left!=null){
deque.offer(node.left);
}
if(node.right!=null){
deque.offer(node.right);
}
}
}
return depth;
}
}
解析：无根节点时，深度为0。有根节点，用双端队列解决此题，先把根节点放入队列中，当队列不为空时，深度加一
遍历出队列的大小，遍历size次，当左节点不为空时，队列中加入左节点，右节点不为空时，队列加入右节点。不断循环遍历直到队列为空，返回深度。
给定一个 n 叉树，找到其最大深度。
最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
例如，给定一个 3叉树 :
我们应返回其最大深度，3
题解：递归法：
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> children;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, List<Node> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public int maxDepth(Node root) {
if(root==null){
return 0;
}
int depth=0;
if(root.children != null){
for(Node child:root.children){
depth=Math.max(depth,maxDepth(child));
}
}
return depth+1;
}
}
解析：根节点为空返回0，不为空，当根的子节点不为空时，遍历出每个节点，把这个节点进行递归，比较出最大深度。
迭代法：
/*
// Definition for a Node.
class Node {
public int val;
public List<Node> children;
public Node() {}
public Node(int _val) {
val = _val;
}
public Node(int _val, List<Node> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public int maxDepth(Node root) {
if(root==null){
return 0;
}
int depth=0;
Queue<Node> que= new LinkedList<>();
que.add(root);
while(!que.isEmpty()){
depth++;
int len=que.size();
while(len>0){
Node node= que.poll();
for (int i = 0; i < node.children.size(); i++)
if (node.children.get(i) != null)
que.offer(node.children.get(i));
len--;
}
}
return depth;
}
}
给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明: 叶子节点是指没有子节点的节点。
示例:
给定二叉树 [3,9,20,null,null,15,7],
返回它的最小深度 2
题解：递归法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int minDepth(TreeNode root) {
if(root==null){
return 0;
}
int leftDepth= minDepth(root.left);
int rightDepth=minDepth(root.right);
if(root.left==null){
return rightDepth+1;
}
if(root.right==null){
return leftDepth+1;
}
return Math.min(leftDepth, rightDepth) + 1;
}
}
解析：递归遍历根节点的左节点和右节点，如果根的左节点为空，则深度为右节点的深度加1，如果根的右节点为空，则深度为左节点深度加1
题解：迭代法：
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int minDepth(TreeNode root) {
if(root==null){
return 0;
}
Deque<TreeNode> deque= new LinkedList<>();
deque.offer(root);
int depth=0;
while(!deque.isEmpty()){
int size= deque.size();
depth++;
for(int i=0;i<size;i++){
TreeNode poll=deque.poll();
if(poll.left==null&&poll.right==null){
return depth ;
}
if(poll.left!=null){
deque.offer(poll.left);
}
if(poll.right!=null){
deque.offer(poll.right);
}
}
}
return depth;
}
}
题解：使用队列解题，先把根节点放入队列中，声明出深度，当队列不为空时，深度加1，遍历放入队列中的元素，弹出一个元素，如果发现是叶子节点，则返回该深度，如果发现弹出节点poll的左节点不为空，则加入队列里面，右节点不为空则加到队列里面，直到遍历完成，返回对应的最小深度。
给出一个完全二叉树，求出该树的节点个数。
示例 1：
示例 2：
示例 3：
提示：
树中节点的数目范围是[0, 5 * 10^4]
0 <= Node.val <= 5 * 10^4
题目数据保证输入的树是 完全二叉树
题解：递归法
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int countNodes(TreeNode root) {
if(root==null){
return 0;
}
return countNodes(root.left)+countNodes(root.right)+1;
}
}
解析：递归根的左节点和根的右节点得出最后的节点个数再加1即可
题解：迭代法
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int countNodes(TreeNode root) {
if(root==null){
return 0;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
int result=0;
while(!queue.isEmpty()){
int size = queue.size();
while(size-->0){
TreeNode node= queue.poll();
result++;
if(node.left!=null){
queue.offer(node.left);
}
if(node.right!=null){
queue.offer(node.right);
}
}
}
return result;
}
}
解析：利用迭代法，使用一个队列，队列中先加入根节点，定义总数变量，当队列不为空时，，先拿到队列的个数，当队列个数大于1时，先让size-1，弹出一个元素，节点个数加1，当弹出的节点的左节点不为空时，则加入队列中，当弹出节点右节点不为空时，则加入到队列中，不断的去迭代，最后统计出最后的个数。
给定一个二叉树，判断它是否是高度平衡的二叉树。
本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
示例 1:
给定二叉树 [3,9,20,null,null,15,7]
返回 true 。
示例 2:
给定二叉树 [1,2,2,3,3,null,null,4,4]
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public boolean isBalanced(TreeNode root) {
return getHeight(root)!=-1;
}
private int getHeight(TreeNode root){
if(root==null){
return 0;
}
int LeftHeight=getHeight(root.left);
if(LeftHeight==-1){
return -1;
}
int RightHeight = getHeight(root.right);
if(RightHeight==-1){
return -1;
}
if(Math.abs(LeftHeight-RightHeight)>1){
return -1;
}
return Math.max(LeftHeight,RightHeight) + 1;
}
}
解析：首先设计当获取二叉树的高度不是-1时，则返回正确，否则不满足要求。编写函数，首先如果根节点也没有，直接返回0，且满足要求。然后再把根的递归查左节点的高度，如果高度为-1，则不满足平衡二叉树，直接返回-1，根的右节点也是这样。接着如果左节点的高度和右节点的高度相差超过了1，则不是高度平衡的二叉树返回-1。否则是一个高度平衡二叉树，返回对应的高度。
题目：
给定一个二叉树，返回所有从根节点到叶子节点的路径。
说明: 叶子节点是指没有子节点的节点。
示例:
题解：递归法
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public List<String> binaryTreePaths(TreeNode root) {
List<String> res= new ArrayList<>();//最终要存的
if(root==null){
return res;
}
List<Integer> paths= new ArrayList<>();//结果路径
traversal(root,res,paths);
return res;
}
public void traversal(TreeNode root,List<String> res,List<Integer> paths){
paths.add(root.val);
if(root.left==null&&root.right==null){
StringBuilder sb= new StringBuilder();
for(int i=0;i<paths.size()-1;i++){
sb.append(paths.get(i)).append("->");
}
sb.append(paths.get(paths.size()-1));
res.add(sb.toString());
return;
}
if (root.left != null) {
traversal(root.left, res,paths);
paths.remove(paths.size() - 1);// 回溯
}
if (root.right != null) {
traversal(root.right, res,paths);
paths.remove(paths.size() - 1);// 回溯
}
}
}
解析：定义一个最终存的list和结果路径的list，先把根的值放入结果路径的list，当根的左节点和右节点都为空时，定义一个StringBuilder开始追加内容，把一个路径上的前size-1个节点放入paths里面并且每个节点加上->，最后额外加上最后一个节点，把这一整个路径放入最终集合res里面，返回即可，如果root的左节点或者右节点不为空时，则开始递归，并且回溯，递归一个回溯一个。最终完成了返回从根节点到叶子节点的路径。
如何在buildr项目中使用Ruby？我在很多不同的项目中使用过Ruby、JRuby、Java和Clojure。我目前正在使用我的标准Ruby开发一个模拟应用程序，我想尝试使用Clojure后端(我确实喜欢功能代码)以及JRubygui和测试套件。我还可以看到在未来的不同项目中使用Scala作为后端。我想我要为我的项目尝试一下buildr(http://buildr.apache.org/)，但我注意到buildr似乎没有设置为在项目中使用JRuby代码本身!这看起来有点傻，因为该工具旨在统一通用的JVM语言并且是在ruby中构建的。除了将输出的jar包含在一个独特的、仅限ruby
在rails源中:https://github.com/rails/rails/blob/master/activesupport/lib/active_support/lazy_load_hooks.rb可以看到以下内容@load_hooks=Hash.new{|h,k|h[k]=[]}在IRB中，它只是初始化一个空哈希。和做有什么区别@load_hooks=Hash.new 最佳答案 查看rubydocumentationforHashnew→new_hashclicktotogglesourcenew(obj)→new_has
我的主要目标是能够完全理解我正在使用的库/gem。我尝试在Github上从头到尾阅读源代码，但这真的很难。我认为更有趣、更温和的踏脚石就是在使用时阅读每个库/gem方法的源代码。例如，我想知道RubyonRails中的redirect_to方法是如何工作的:如何查找redirect_to方法的源代码？我知道在pry中我可以执行类似show-methodmethod的操作，但我如何才能对Rails框架中的方法执行此操作？您对我如何更好地理解Gem及其API有什么建议吗？仅仅阅读源代码似乎真的很难，尤其是对于框架。谢谢! 最佳答案 Ru
我的假设是moduleAmoduleBendend和moduleA::Bend是一样的。我能够从thisblog找到解决方案,thisSOthread和andthisSOthread.为什么以及什么时候应该更喜欢紧凑语法A::B而不是另一个，因为它显然有一个缺点？我有一种直觉，它可能与性能有关，因为在更多命名空间中查找常量需要更多计算。但是我无法通过对普通类进行基准测试来验证这一点。 最佳答案 这两种写作方法经常被混淆。首先要说的是，据我所知，没有可衡量的性能差异。(在下面的书面示例中不断查找)最明显的区别，可能也是最著名的，是你的
几个月前，我读了一篇关于rubygem的博客文章，它可以通过阅读代码本身来确定编程语言。对于我的生活，我不记得博客或gem的名称。谷歌搜索“ruby编程语言猜测”及其变体也无济于事。有人碰巧知道相关gem的名称吗？ 最佳答案 是这个吗:http://github.com/chrislo/sourceclassifier/tree/master 关于ruby-寻找通过阅读代码确定编程语言的rubygem？，我们在StackOverflow上找到一个类似的问题：
我目前正在使用以下方法获取页面的源代码:Net::HTTP.get(URI.parse(page.url))我还想获取HTTP状态，而无需发出第二个请求。有没有办法用另一种方法做到这一点？我一直在查看文档，但似乎找不到我要找的东西。 最佳答案 在我看来，除非您需要一些真正的低级访问或控制，否则最好使用Ruby的内置Open::URI模块:require'open-uri'io=open('http://www.example.org/')#=>#body=io.read[0,50]#=>"["200","OK"]io.base_ur
前言作为一名程序员，自己的本质工作就是做程序开发，那么程序开发的时候最直接的体现就是代码，检验一个程序员技术水平的一个核心环节就是开发时候的代码能力。众所周知，程序开发的水平提升是一个循序渐进的过程，每一位程序员都是从“菜鸟”变成“大神”的，所以程序员在程序开发过程中的代码能力也是根据平时开发中的业务实践来积累和提升的。提高代码能力核心要素程序员要想提高自身代码能力，尤其是新晋程序员的代码能力有很大的提升空间的时候，需要针对性的去提高自己的代码能力。提高代码能力其实有几个比较关键的点，只要把握住这些方面，就能很好的、快速的提高自己的一部分代码能力。1、多去阅读开源项目，如有机会可以亲自参与开源
嗨~大家好，这里是可莉！今天给大家带来的是7个C语言的经典基础代码~那一起往下看下去把【程序一】打印100到200之间的素数#includeintmain(){ inti; for(i=100;i 【程序二】输出乘法口诀表#includeintmain(){inti;for(i=1;i 【程序三】判断1000年---2000年之间的闰年#includeintmain(){intyear;for(year=1000;year 【程序四】给定两个整形变量的值，将两个值的内容进行交换。这里提供两种方法来进行交换，第一种为创建临时变量来进行交换，第二种是不创建临时变量而直接进行交换。1.创建临时变量来
文章目录git常用命令（简介，详细参数往下看）Git提交代码步骤gitpullgitstatusgitaddgitcommitgitpushgit代码冲突合并问题方法一：放弃本地代码方法二：合并代码常用命令以及详细参数gitadd将文件添加到仓库：gitdiff比较文件异同gitlog查看历史记录gitreset代码回滚版本库相关操作远程仓库相关操作分支相关操作创建分支查看分支：gitbranch合并分支：gitmerge删除分支：gitbranch-ddev查看分支合并图：gitlog–graph–pretty=oneline–abbrev-commit撤消某次提交git用户名密码相关配置g
打印1:defsum(i)i=i+[2]end$x=[1]sum($x)print$x打印12:defsum(i)i.push(2)end$x=[1]sum($x)print$x后者是修改全局变量$x。为什么它在第二个例子中被修改而不是在第一个例子中？类Array的任何方法(不仅是push)都会发生这种情况吗？ 最佳答案 变量范围在这里无关紧要。在第一段代码中，您仅使用赋值运算符=为变量i赋值，而在第二段代码中，您正在修改$x(也称为i)使用破坏性方法push。赋值从不修改任何对象。它只是提供一个名称来引用一个对象。方法要么是破坏性