刷题中的小技巧（一）

Java如何判断int溢出

//因为double范围比int大很多，所以使用double来判断是否溢出很简单
public int reverse2(int x) {
	double ans=0;
	int flag=1;
	if(x<0){
	    flag=-1;
	}
	x=x*flag;
	while(x>0) {
	    ans = 10 * ans + x % 10;
	    x = x / 10;
	}
	if(ans>Integer.MAX_VALUE){//判断是否溢出
	    System.out.println(ans);
	    return 0;
	}
	else
	    return (int)(flag*ans);
}

---

Java中的map详解

HashMap：我们最常用的Map，它根据key的HashCode 值来存储数据,根据key可以直接获取它的Value，同时它具有很快的访问速度。HashMap最多只允许一条记录的key值为Null(多条会覆盖);允许多条记录的Value为 Null。非同步的。

TreeMap: 能够把它保存的记录根据key排序,默认是按升序排序，也可以指定排序的比较器，当用Iterator 遍历TreeMap时，得到的记录是排过序的。TreeMap不允许key的值为null。非同步的。

Hashtable: 与 HashMap类似,不同的是:key和value的值均不允许为null;它支持线程的同步，即任一时刻只有一个线程能写Hashtable,因此也导致了Hashtale在写入时会比较慢。

LinkedHashMap: 保存了记录的插入顺序，在用Iterator遍历LinkedHashMap时，先得到的记录肯定是先插入的.在遍历的时候会比HashMap慢。key和value均允许为空，非同步的。

---

java中如何不自己写排序方法完成排序

1. 如果要排序的东西是放在一个数组里面的

1.1 如果要排序的东西是基本数据类型，如int

int[] c=new int[]{4,5,1,2,3,6,9};
Arrays.sort(c);
Arrays.sort(c,1,4);

1.2 如果要排序的东西是java自己的类，如Integer

Integer[] b=new Integer[]{4,5,1,2,3,6,9};
Arrays.sort(b);
Arrays.sort(b,1,4,Collections.reverseOrder());
Arrays.sort(b, Comparator.reverseOrder());
for(int i=0;i<7;i++)
	System.out.print(b[i]);

1.3 如果要排序的东西是你自己实现的类，那就在类里面直接重写compareTo方法

import java.util.*;

public class Solution{
    static class time implements Comparable{
        private int a;
        private int b;

        public time(int a, int b){
            this.a=a;
            this.b=b;
        }

        public int geta(){
            return this.a;
        }

        public int getb(){
            return this.b;
        }

        @Override
        public int compareTo(Object o) {
            time o2=(time)o;
            return o2.getb()-this.getb();
        }
    }
    public time[] fun(time[] a){
        Arrays.sort(a);
        return a;
    }


    public static void main(String [] arg){
        Solution s=new Solution();
        time[] num=new time[]{new time(1,2),new time(2,4),new time(3,3),new time(1,5)};

        s.fun(num);

        for(int i=0;i<4;i++){
            System.out.print(num[i].geta());
            System.out.print(" ");
            System.out.println(num[i].getb());
        }



    }
}

2. 如果要排序的东西是放在一个List里面的

2.1 如果要排序的东西是java自己的类，如Integer，直接在传参的时候传入一个比较器；传入null的话默认升序排列

ArrayList<Integer> a=new ArrayList<>();
a.add(4);
a.add(5);
a.add(1);
a.sort(new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return o2-o1;
	}
});
//a.sort(null);

2.2 如果要排序的东西是你自己实现的类，那就在类里面直接重写compareTo方法

---

不同位数相加时的技巧

假设每次循环返回一个int，第一次返回1，第二次返回2，第三次返回3，最后算法的结果是123，如何计算？

这个 问题看似简单其实有一个问题，就是你并不知道循环的次数是多少，也就是说无法确定1乘以的究竟是10的几次方，下面介绍两种方法：

方法一：

用stack的思想，把每次循环的值都存在stack中，这样以先进后出的性质，最后只需要每次pop出一个值，先乘以1，再依次乘以10，100，1000即可算出123

方法二：

这个方法比较巧妙，就是令val=val*10+x;其中val初始化为0，x为每次循环的值。这样的话就不需要借助额外的存储空间了。

---

&的妙用

比如下面这段代码，最后的输出是ans，我需要ans随着递归的每一层的进行都改变它的值，而且改变其真正的值，这时候就要在方法实现的时候在ans前面加上&。但是k是一个临时变量，在计算每一条路径时都会有不同的值，我希望递归的每一层都会改变k的值，但是却不影响上一层的递归，即这层递归结束后k还是原来上一层递归的值，这时候再在方法实现的时候就不需要在k之前加&

int minDepth(TreeNode* root) {
        if (!root)
            return 0;
        int ans = INT_MAX;
        int k = 1;
        dfs(root,ans,k);
        return ans;
    }
    void dfs(TreeNode* root, int &ans, int k) {
        if (root->left == NULL && root->right == NULL) {
            ans = min(k,ans);
            return;
        }
        if (root->left || root->right)
            k++;
        if (root->left) 
            dfs(root->left, ans, k);    
        if (root->right) 
            dfs(root->right, ans, k);
    }

---

字符串倒序

#include<string>
int main()
{
    string str="cvicses";
    string s(str.rbegin(), str.rend());
    cout << s << endl;
    return 0;
}

---

关注我，了解更多刷题中的小技巧