解题--＞在线OJ(十二)
解题-->力扣
- 1.子集
- 2.单词搜索
- 3.不同的二叉搜索树
- 4.验证二叉搜索树
- 5.二叉树展开为链表
-
- 6.最长连续序列
- 7.单词拆分（139）
- 8. 2的幂
- 9.反转字符串（344）
- 10.Nim游戏（292）
1.子集
解题：
class Solution {
List<List<Integer>> result=new ArrayList<>();
List<Integer> list=new ArrayList<>();
public List<List<Integer>> subsets(int[] nums) {
result.add(new ArrayList<>(list));
backtracking(0,nums);
return result;
}
public void backtracking(int index,int[] nums){
for(int i=index;i<nums.length;i++){
list.add(nums[i]);
result.add(new ArrayList<>(list));
backtracking(i+1,nums);
list.remove(list.size()-1);
}
}
}
2.单词搜索
解题：
class Solution {
int m;
int n;
char[] letter;
char[][] board1;
boolean[][] visited;
public boolean exist(char[][] board, String word) {
this.m=board.length;
this.n=board[0].length;
this.letter=word.toCharArray();
this.board1=board;
this.visited=new boolean[m][n];
for(int i=0;i<m;i++) {
for (int j = 0; j < n; j++) {
boolean result=judge(i,j,0);
if(result){
return true;
}
}
}
return false;
}
public boolean judge(int i,int j,int k){
if(k>=letter.length){
return true;
}
if(i<0 || j<0 || i>=m || j>=n || visited[i][j] || letter[k]!=board1[i][j]){
return false;
}
visited[i][j]=true;
boolean res=judge(i+1,j,k+1)||judge(i-1,j,k+1)
|| judge(i,j-1,k+1) || judge(i,j+1,k+1);
visited[i][j]=false;
return res;
}
}
3.不同的二叉搜索树
解题：动态规划
class Solution {
public int numTrees(int n) {
int[] result=new int[n+1];
result[0]=1;
result[1]=1;
for(int i=2;i<=n;i++){
result[i]=0;
for(int j=1;j<=i;j++){
result[i]+=result[j-1]*result[i-j];
}
}
return result[n];
}
}
4.验证二叉搜索树
解题：
二叉搜索树的特点是：左<中<右；
中序遍历===》左，中，右
所以，将树中序遍历，所得结果，遍历一下，如果每个结点都比上一个结点大的话，就证明这棵树是二叉搜索树，如果出现当前结点比上一个结点值小的话，就直接返回false。
class Solution {
List<Integer> list=new ArrayList<>();
public boolean isValidBST(TreeNode root) {
inorderTraversal(root);
int ret=list.get(0);
for(int i=1;i<list.size();i++){
if(list.get(i)<=ret){
return false;
}
ret=list.get(i);
}
return true;
}
public void inorderTraversal(TreeNode root){
if(root==null){
return;
}
inorderTraversal(root.left);
list.add(root.val);
inorderTraversal(root.right);
}
}
5.二叉树展开为链表
解题思路：
递归调用
class Solution {
public void flatten(TreeNode root) {
if(root==null){
return;
}
root=flatten2(root);
}
public TreeNode flatten2(TreeNode root){
if(root==null){
return null;
}
TreeNode l=flatten2(root.left);
TreeNode r=flatten2(root.right);
if(l==null){
root.right=r;
}else{
root.right=l;
TreeNode current=l;
while(current.right!=null){
current=current.right;
}
current.right=r;
}
root.left=null;
return root;
}
}
6.最长连续序列
解题思路：
1.利用Arrays.sort()，将数组进行排序；
2.从头到尾遍历数组，如果当前元素-前一个数组=1，就证明这两个数数字是连续的,count++,如果结果>1,就证明这两个数字不是连续的，就将count=1;
3.每遍历一次，就更新max，max取max和count的最大值。
class Solution {
public static int longestConsecutive(int[] nums) {
if(nums==null || nums.length==0){
return 0;
}
if(nums.length==1){
return 1;
}
Arrays.sort(nums);
int max=0;
int ret=nums[0];
int count=1;
for(int i=1;i<nums.length;i++){
if(nums[i]-ret==1){
count++;
}else if(nums[i]-ret>1){
count=1;
}
ret=nums[i];
max=Math.max(count,max);
}
return max;
}
}
7.单词拆分（139）
解题：
class Solution {
public static boolean wordBreak(String s, List<String> wordDict) {
if(s==null){
return true;
}
if(s!=null && wordDict==null){
return false;
}
boolean[] result=new boolean[s.length()+1];
result[0]=true;
for(int i=1;i<=s.length();i++){
for(int j=0;j<i;j++){
if(result[j]&& wordDict.contains(s.substring(j,i))){
result[i]=true;
break;
}
}
}
return result[s.length()];
}
}
8. 2的幂
解题思路：
如果一个数字是2的幂次方，这个数有一个特点就是，不断的除以2，最终结果是1，并且，在这个过程中，结果都是偶数。根据这个特点，写循环，最终就能判断一个数字是否是2的幂次方。
class Solution {
public static boolean isPowerOfTwo(int n) {
if(n<=0){
return false;
}
if(n==1){
return true;
}
while(n!=1){
if(n%2!=0){
return false;
}
n=n/2;
}
return true;
}
}
9.反转字符串（344）
解题：
class Solution {
public void reverseString(char[] s) {
int left=0;
int right=s.length-1;
while(left<right){
char temp=s[left];
s[left]=s[right];
s[right]=temp;
left++;
right--;
}
}
}
10.Nim游戏（292）
当n=4或者是4的倍数的时候，此时，你一定是输的，所以在这个题目中，只需要判断n是否为4的倍数即可。
class Solution {
public boolean canWinNim(int n) {
if(n%4==0){
return false;
}
return true;
}
}