3. 树的层序遍历
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public int[] levelOrder(TreeNode root) {
//层序遍历
if(root==null)
return new int[0];
Queue<TreeNode> queue = new LinkedList<TreeNode>();
List<Integer> list = new ArrayList<>();
queue.add(root);
while(!queue.isEmpty()){
TreeNode node = queue.poll();
list.add(node.val);
if(node.left != null)
queue.add(node.left);
if(node.right != null)
queue.add(node.right);
}
int[] res = new int[list.size()];
for(int i = 0; i < list.size(); i++)
res[i] = list.get(i);
return res;
}
}
2. 树的层序遍历2
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ret = new ArrayList<List<Integer>>();
if (root == null) {
return ret;
}
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> level = new ArrayList<Integer>();
int currentLevelSize = queue.size();
for (int i = 1; i <= currentLevelSize; ++i) {
TreeNode node = queue.poll();
level.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
ret.add(level);
}
return ret;
}
}
3. 层序遍历3
class Solution {
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> res = new ArrayList<>();
Queue<TreeNode> que = new LinkedList<>();
if(root==null){
return res;
}
int level = 0;
que.add(root);
while(!que.isEmpty()){
level++;
int size = que.size();
LinkedList<Integer> list = new LinkedList<>();
for(int i=0;i<size;i++){
TreeNode node = que.poll();
if(level % 2 == 1)
list.add(node.val);
else{
list.addFirst(node.val);
}
if(node.left!=null)que.add(node.left);
if(node.right!=null)que.add(node.right);
}
res.add(list);
}
return res;
}
}
4. 执行操作后字典序最小的字符串
BFS:暴力穷举所有的解,找到最小值
首先定义队列q,将初始s入队,定义一个hash表vis,用于记录字符串是否出现过。
不断对字符串进行操作,并存入队列中,不断从队列中取出字符串,进行相加和轮转操作,得到新的字符串。
class Solution{
public String findLexSmallestString(String s, int a, int b){
Deque<String> que = new ArrayDeque<>();
Set<String> vis = new HashSet<>();
que.offer(s);
vis.add(s);
String ans = s;
int n = s.length();
while(!que.isEmpty()){
s = q.poll();
if(ans.cpmpareTo(s)>0)
ans = s;
//进行累加操作
char[] ch = s.toCharArray();
for(int i=1; i<len; i+=2){
ch[i] = (char)(((ch[i]-'0'+a)%10)+'0');
}
//把字符数组转换成字符串,
String t1 = String.valueOf(ch);
//进行轮转操作
String t2 = s.substring(b) + s.substring(0,b);
for(String t: List.of(t1, t2){
if(vis.add(t))
que.offer(t)
}
}
return ans;
}
}