191. 位1的个数

编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。

思路

这个题是简单的使用异或就行了
异或：相同为0，不同为1
与：只有同为1时，结果才为1

完整代码

public int hammingWeight(int n) {
        int cnt = 0;
        while(n != 0){
             n = n ^ (n & ((~n) + 1));
             cnt++;
        }
        return cnt;
    }

73. 矩阵置零

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。

思路

“在计算机科学中，一个原地算法（in-place algorithm）基本上不需要额外辅助的数据结构,然而,允许少量额外的辅助变量来转换数据的算法。当算法运行时，输入的数据通常会被要输出的部分覆盖掉。不是原地算法有时候称为非原地（not-in-place）或不得其所（out-of-place）。–摘自*。
在计算复杂性理论中，原地算法包含使用O(1)空间复杂度的所有算法，DSPACE(1)类型。”
看到这里我还是不明白，怎么定义额外数据结构，最后又看了看别的定义，就是直接在原来的数据结构上改，而不需要利用额外的数据结构来存储结果。也就是意味着可以使用额外的空间来辅助计算，但是返回结果还仍然是原数据结构
1.用额外的空间存储所有0出现的位置，因为不知道到底出现了几个0，所以额外空间是o(mn);
2.一次遍历，存储出现的0的行和列，因为只有m行和n列，所以额外空间是o(m + n);
3.对于常量空间o(1)的做法，就是如果该行/列有0，那么第0行或者第0列就一定有0.直接从第一行开始遍历，然后将遇到的0的行列保存到第0行和第0列中，最后遍历第0行和第0列，就能得到结果
这里用的是第二种方式做的.

完整代码

public void setZeroes(int[][] matrix) {
        int m = matrix.length;
        int n = matrix[0].length;
        if(m == 0 || n == 0){
            return;
        }
        boolean[] row = new boolean[m];
        boolean[] col = new boolean[n];
        for(int x = 0 ; x < m * n; x++){
            if(matrix[x / n][x % n] == 0){
                row[x / n] = true;
                col[x % n] = true;
            }
        }
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                if(row[i] == true || col[j] == true){
                    matrix[i][j] = 0;
                }
            }
        }
    }

150. 逆波兰表达式求值

根据 逆波兰表示法，求表达式的值。

有效的算符包括 +、-、*、/ 。每个运算对象可以是整数，也可以是另一个逆波兰表达式。

思路

弄清波兰式和逆波兰式。
波兰式就是前缀表达式
逆波兰式就是后缀表达式
一般我们接触到的比如：1 + 2 * 3 - 5这种是中缀表达式。其前缀表达式为+1-235，后缀表达式是1235-+；
在计算波兰式和逆波兰式的时候都要使用到栈。不过，波兰式是从右向左遍历，逆波兰式是从左向右遍历。

语法

在判断操作符的时候，发现使用if判断和switch条件语句的时候用的时间没有明显区别

完整代码

public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new ArrayDeque<>();
        int n = tokens.length;
        for(int i = 0; i < n; i++){
            if(tokens[i].equals("+") || tokens[i].equals("-") || tokens[i].equals("*") || tokens[i].equals("/")){
            	int b = stack.pollLast();
				int a = stack.pollLast();
				int str = 0;
                switch(tokens[i]){
                    case "+" : str = a + b; break;
                    case "-" : str = a - b; break;
                    case "*" : str = a * b; break;
                    case "/" : str = a / b; break;
                }
				stack.addLast(str);
            }else {
				stack.addLast(Integer.parseInt(tokens[i]));
			}
        }
        return stack.pollLast();
    }

31. 下一个排列

实现获取 下一个排列 的函数，算法需要将给定数字序列重新排列成字典序中下一个更大的排列。

如果不存在下一个更大的排列，则将数字重新排列成最小的排列（即升序排列）。

必须 原地 修改，只允许使用额外常数空间。

思路

一开始想者交换从后面找到打破降序的变化点，然后交换之后排列后面的数
但是这样并不能得到正确结果。应该是交换变化点左边的数和右边比该数大的那个数。

语法

Arrays.sort不能对基本类型进行逆序，逆序之前要将其变成引用类型

完整代码

public void nextPermutation(int[] nums) {
        if(nums.length == 1){
            return;
        }
        int n = nums.length;
        int index = 0;
        boolean flag = false;
        for(int i = n - 2; i >= 0; i--) {
        		if(nums[i] < nums[i + 1]) {
            		index = i;
            		flag = true;
            		break;
            	}
        }
        
        if(index == 0 && flag == false) {
        	Arrays.sort(nums, index, n);
        }else {
        	for(int i = n - 1; i >= index; i--) {
            	if(nums[i] > nums[index]) {
            		int temp = nums[i];
            		nums[i] = nums[index];
            		nums[index] = temp;
            		break;
            	}
            }
        	Arrays.sort(nums, index + 1, n);	
		}
    }