leetcode经典面试题总结

1.给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
说明：你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
题解：
第一种方法（异或运算）

class Solution {
    public int singleNumber(int[] nums) {
        int result = 0;
        for (int i = 0; i < nums.length; i++) {
			result = result^nums[i];
		}
        return result;
    }
}

第二种方法（数组排序）

class Solution {
    public int singleNumber(int[] nums) {
        if(nums.length==1) return nums[0];
        Arrays.sort(nums);
        for(int i = 0;i<nums.length-1;i=i+2){
            if(nums[i] != nums[i+1]) return nums[i];
        }
        return nums[nums.length-1];
    }
}

2.给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
题解：
第一种方法

class Solution {
	public int majorityElement(int[] nums) {
		int count = 1;
		int maj = nums[0];
		for (int i = 1; i < nums.length; i++) {
			if (maj == nums[i])
				count++;
			else {
				count--;
				if (count == 0) {
					maj = nums[i + 1];
				}
			}
		}
		return maj;
	}
}

第二种方法

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

3.编写一个高效的算法来搜索 m x n 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：
每行的元素从左到右升序排列。
每列的元素从上到下升序排列。
题解：
第一种（从右上角开始）

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0) return false;
        int m = 0;
        int n = matrix[0].length - 1;
        while (m < matrix.length && n >= 0) {
            if (matrix[m][n] == target) {
                return true;
            } else if (matrix[m][n] > target) {
                n--;
            } else {
                m++;
            }
        }
        return false;
    }
}

第二种（从左下角开始）

class Solution {
    public boolean searchMatrix(int[][] matrix, int target) {
        if (matrix == null || matrix.length == 0) return false;
        int m = 0;
        int n = matrix.length - 1;
        while (m < matrix[0].length && n >= 0) {
            if (matrix[n][m] == target){
                return true;
            }else if(matrix[n][m] > target){
                n--;
            }else{
                m++;
            }
        }
        return false;
    }
}

4给定两个有序整数数组 nums1 和 nums2，将 nums2 合并到 nums1 中，使得 num1 成为一个有序数组。
说明:初始化 nums1 和 nums2 的元素数量分别为 m 和 n。
你可以假设 nums1 有足够的空间（空间大小大于或等于 m + n）来保存 nums2 中的元素。
题解：

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int p = m-- + n-- - 1;
        while (m >= 0 && n >= 0){
            nums1[p--] = nums1[m] > nums2[n] ? nums1[m--] : nums2[n--];
        }
        while (n >= 0){
            nums1[p--] = nums2[n--];
        }
        第二种方法
        // for(int i=m;i<m+n;i++){
        //     nums1[i]=nums2[i-m];
        // }
        // Arrays.sort(nums1);
    }
}

5.给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。

class Solution {
    private class LargerNumberComparator implements Comparator<String> {
        @Override
        public int compare(String a, String b) {
            String order1 = a + b;
            String order2 = b + a;
           return order2.compareTo(order1);
           //如果参数字符串等于此字符串，则返回值 0；
		   //如果此字符串小于字符串参数，则返回一个小于 0 的值；
		   //如果此字符串大于字符串参数，则返回一个大于 0 的值。
		   //order2.compareTo(order1)是因为：
		   //sort默认从小到大排序，所以这里应该是逆排序，从大到小排		    
        }
    }
    public String largestNumber(int[] nums) {
        // 把int数组转成字符串数组
        String[] asStrs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            asStrs[i] = String.valueOf(nums[i]);
        }
        // 根据自定义排序规则进行排序
        Arrays.sort(asStrs, new LargerNumberComparator());
        // 如果在排序完之后，最大的数是0，则整个最大数为0
        if (asStrs[0].equals("0")) {
            return "0";
        }
        // 将排序好的字符串数组转成字符串
        String largestNumberStr = new String();
        for (String numAsStr : asStrs) {
            largestNumberStr += numAsStr;
        }
        return largestNumberStr;
    }
}

6.求 1+2+…+n ，要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句（A?B:C）。

```bash
class Solution {
    public int sumNums(int n) {
        //第一种方法：等差数列求和公式
        //return (int)(Math.pow(n,2)+n) >> 1;
        //第二种方法：短路递归
        int sum = n;
        boolean flag = (n > 0) && (sum += sumNums(n-1)) > 0;
        return sum;
    }
}