力扣网：905、169、118、766、498

905.奇偶排序

给定一个非负整数数组 A，返回一个数组，在该数组中， A 的所有偶数元素之后跟着所有奇数元素。
你可以返回满足此条件的任何数组作为答案。

示例：

输入：[3,1,2,4]
输出：[2,4,3,1]
输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。

由题知：
左边放偶数，右边放奇数。

思路1：
可以新建一个等同数组，如果是奇数将元素放最后，如果是偶数放第一个位置，这样就可以排完。
但是：创建了额外的数组。

思路2：
在原数组上进行排，定义头和尾指针，如果左边是偶数，右边是奇数，头指针后移，尾指针前移。如果是左边右边都是奇数，则尾指针前移。然后继续判断。如果是左边右边都是偶数，则头指针后移，然后继续判断。当成为左奇右偶则交换换，然后继续判断，知道头尾相遇结束。

然后我们开始编写：

class Solution {
    public static int[] sortArrayByParity(int[] A) {
		/*
		 * 解：头L尾R交换
		 * 左偶右奇 L++ R--
		 * 左偶右偶 L++
		 * 左奇右奇 R--
		 * 左奇右偶 交换
		 */
		if(A==null||A.length==1||A.length==0)	//特殊情况
			return A;
		
		int L = 0;	//左指针
		int R = A.length-1;	//右指针
		
		while(L<R) {	//R始终要在L右边，当他俩相遇则说明遍历完了
			//左奇数右偶数 换位
			if(A[L]%2!=0&&A[R]%2==0) {
				int temp = A[R];
				A[R]=A[L];
				A[L]=temp;
			}
			//左偶数右奇数 不变L++ R--
			else if(A[L]%2==0&&A[R]%2==1){
				L++;
				R--;
			}
			//俩边都是奇数 R--
			else if(A[L]%2==1&&A[R]%2==1){
				R--;
			}
			//俩边都是偶数 L++
			else {
				L++;
			}
		}
		return A;
	}
}

169. 求众数

给定一个大小为 n 的数组，找到其中的众数。众数是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在众数。

示例 1:

输入: [3,2,3]
输出: 3
示例 2:

输入: [2,2,1,1,1,2,2]
输出: 2

思路1：
先排序，然后根据滑窗思想，然后找出连续最多的数，这个数就是众数。

class Solution {
    public int majorityElement(int[] nums) {
        /*
		 * 解：先排序然后然后根据滑窗思想，
		 * 然后找出连续最多的数，
		 * 这个数就是众数
		 */
		Arrays.sort(nums);	//先排序
		int count=0;	//定义出现最大次数
		int aim=0;	//定义众数
		int curCount=0;	//定义临时出现次数
		int curAim=0;	//定义临时众数
		int j=0;
		for(int i=0;i<nums.length;){
			if(i>(nums.length-1)/2){	//当i遍历到超过长度一半结束循环
				break;
			}
			curAim=nums[i];	//让当前的数为临时众数
			curCount=1;	//初始化临时次数
			for(j=i+1;j<nums.length;j++){	//让j从当前下标后一个继续开始循环
				if(nums[i]==nums[j]){	//如果j下标的数和临时的众数相同
					curCount++; //临时出现次数+1
				}else{	//j下标的数和i下标的数不同则跳出
					break;
				}
			}
			if(curCount>count){	//当临时次数大于最大次数
				count=curCount;	//将临时次数改为最大
				aim=curAim;	//让当前临时众数为为众数
			}
			i=j;	//让i变为j然后从j后继续循环
		}
		return aim;	//找完以后返回众数
    }
}

思路2：
不排序，遍历所有元素，假设俩个位置，进来一个元素占一个位置，如果后进来的元素和之前的不相等，则替换，如果相等则占另一个位置。直到遍历完，最后的数就是众数。

class Solution {
    public int majorityElement(int[] nums) {
        /*
		 * 解：遍历所有元素，假设俩个位置，进来一个元素占一个位置，
		 * 如果后进来的元素和之前的不相等，则替换，如果相等则占另一个位置。
		 * 直到遍历完，最后的数就是众数
		 */
		int num = nums[0];	//第一个数开始
		int count = 1;	//占了第一个位置，最多2位置
		for(int i = 1;i<nums.length;i++){	//遍历所有元素
			if(nums[i]==num){	//如果下一个元素等于当前元素
				count++;	//占另一个位置
			}
			else{	//如果下一个元素不等于当前元素
				count--;	//空开一个位置
				if(count==0){	//当位置都空开
					num = nums[i];	//当前元素占一个位置
					count=1;	//此时又占了1个位置
				}
			}
		}
        return num;	//留下最后的就是众数
    }
}

118. 杨辉三角

给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。

在杨辉三角中，每个数是它左上方和右上方的数的和。

示例:

输入: 5
输出:
[
[1],
[1,1],
[1,2,1],
[1,3,3,1],
[1,4,6,4,1]
]

思路：
很明显我们需要用到长度不一样的二维数组进行存。这样右上角部分就不会被浪费，同理根据题意我们需要用二位线性表进行存储。第一个和最后一个都是1，中间的数是由上一行同位置和前一个位置的值的和。

class Solution {
    public List<List<Integer>> generate(int numRows) {
        //定义二维线性表
    	List<List<Integer>> lists = new ArrayList<List<Integer>>();
    	for (int i = 1; i <= numRows; i++) {	//共循环行数次
			ArrayList<Integer> list = new ArrayList<>();	//内层线性表
			for (int j = 0; j < i; j++) {	//第一行一个第二行俩个第三行俩个
				if(j==0||j==i-1) {	//每一行的第一个和最后一个都是1
					list.add(1);
				}
				else {
					//除了第一个和最后一个数是1其他位置是由上一行的同下标的数+其前一个数的和
					//记为num
					int num = lists.get(i-2).get(j)+lists.get(i-2).get(j-1);
					list.add(num);
				}
			}
			lists.add(list);
			
		}
    	return lists;
    }
}

766. 托普利茨矩阵

如果一个矩阵的每一方向由左上到右下的对角线上具有相同元素，那么这个矩阵是托普利茨矩阵。

给定一个 M x N 的矩阵，当且仅当它是托普利茨矩阵时返回 True。

示例 1:

输入:
matrix = [
[1,2,3,4],
[5,1,2,3],
[9,5,1,2]
]
输出: True

解释:
在上述矩阵中, 其对角线为:
“[9]”, “[5, 5]”, “[1, 1, 1]”, “[2, 2, 2]”, “[3, 3]”, “[4]”。
各条对角线上的所有元素均相同, 因此答案是True。

示例 2:

输入:
matrix = [
[1,2],
[2,2]
]
输出: False

解释:
对角线"[1, 2]"上的元素不同。

说明:

matrix 是一个包含整数的二维数组。
matrix 的行数和列数均在 [1, 20]范围内。
matrix[i][j] 包含的整数在 [0, 99]范围内。

思路：

很明显左下角和右上角俩元素不需要判断，只需要将红色对角线遍历完就好了，分别从00的左边和下边开然后进行对角线遍历灰色为边界。

class Solution {
    public boolean isToeplitzMatrix(int[][] matrix) {
    	int r=matrix.length;	//定义行
		int c=matrix[0].length;	//定义列
		
		//先往下开始沿对角线遍历
		for(int i=0;i<c-1;i++){	//到灰色就停止
			int x=1;	//初始化纵坐标
			int y=i+1;	//定义横坐标
			while(x>=0&&x<r&&y>=0&&y<c){
				//第一次判断11和00处是否相等，第二次判断22类推
				if(matrix[x][y]!=matrix[0][i]){
					return false;
				}
				x++;
				y++;
			}
		}
		//在往右开始沿对角线编写
		for(int i=1;i<r-1;i++){	//到灰色就停止
			int x=i+1;
			int y=1;
			while(x>=0&&x<r&&y>=0&&y<c){
				if(matrix[x][y]!=matrix[i][0]){
					return false;
				}
				x++;
				y++;
			}
		}
		return true;
        
    }
}

498. 对角线遍历

给定一个含有 M x N 个元素的矩阵（M 行，N 列），请以对角线遍历的顺序返回这个矩阵中的所有元素，对角线遍历如下图所示。

示例:

输入:
[
[ 1, 2, 3 ],
[ 4, 5, 6 ],
[ 7, 8, 9 ]
]

输出: [1,2,4,7,5,3,6,8,9]

解释:

思路：

由图知当横纵坐标(i+j)%2 == 0 ;也就是为偶数时，走右上，否则走左下，
先看往右上，当横着也就是红线12不能往右上继续走时给列坐标+1，
也就是 i = =0 j!=col-1 j+1
当竖着也就是红线34不能往右上继续走时给行坐标+1，
j==col -1 i+1
其他情况行-1列加1；

再看往左下，j ==0 i!=row - 1 i+1
i = = row-1 j+1
其他情况 i+1 j-1

开始编写吧：

class Solution {
    public int[] findDiagonalOrder(int[][] matrix) {
		//没有元素直接返回
		if (matrix == null || matrix.length == 0) {
			return new int[] {};
		}
		int row = matrix.length;	//定义行最大
		int col = matrix[0].length;	//定义列最大

		if (col == 0) {
			return new int[] {};
		}
		// 二维数组只有一行，直接输出
		if (row == 1) {
			return matrix[0];
		}
		// 二维数组只有一列直接输出
		int[] nums = new int[row * col];
		if (col == 1) {
			for (int i = 0; i < row; i++) {
				nums[i] = matrix[i][0];
			}
			return nums;
		}

		int i = 0;	//定义行坐标
		int j = 0;	//定义列坐标
		int index = 0;
		while (i < row && j < col) {
			// 读取(i,j)元素
			nums[index++] = matrix[i][j];
			if ((i + j) % 2 == 0) {// 右上
				if (i == 0 && j != col - 1) {
					j++;
				} else if (j == col - 1) {
					i++;
				} else {
					i--;
					j++;
				}
			} else {// 左下
				if (j == 0 && i != row - 1) {
					i++;
				} else if (i == row - 1) {
					j++;
				} else {
					i++;
					j--;
				}
			}
		}
		return nums;
	}
}

over。