文章目录
常规的读输入输出:scanner基本用法
多行输入输出怎么处理
由字符串变数组再变二叉树，以及反过来怎么操作
由字符串变数组再变链表，以及反过来怎么操作
BufferedRead
一、简单的数组输入
[2,7,11,15]
9
import java.util.Scanner;
//建议直接都写 * ，这样就可以导进来所有包了
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String line = s.nextLine(); //读取字符串
System.out.println("字符串："line);
int a = s.nextInt(); //读取整数
System.out.println("整数："+a);
}
}
二、构造二叉树(输入)
/**
* 构造树:层序遍历的思想
* 这都可以当成一道题了...
*/
public class Main {
private static class TreeNode { //二叉树类
int val;
TreeNode left, right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val,TreeNode left,TreeNode right){
this.val = val;
this.left = left;
this.right = right;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
String str = scanner.nextLine();
TreeNode root = StringToTreeNode(str);
//System.out.println(root.left.val);
}
private static TreeNode StringToTreeNode(String str) {
String[] parts = str
.substring(1, str.length() - 1)
.split(",");
//变成字符串后,逐一处理
String item = parts[0];
TreeNode root = new TreeNode(Integer.parseInt(item)); //二叉树的根节点
Queue<TreeNode> q = new LinkedList<>(); //使用队列添加结点
q.offer(root);
int index = 1;
while (!q.isEmpty()) {
TreeNode node = q.poll();
if (index == parts.length) break;
item = parts[index ++];
if (!item.equals("null")) {
node.left = new TreeNode(Integer.parseInt(item));
q.offer(node.left);
}
if (index == parts.length) break;
item = parts[index ++];
if (!item.equals("null")) {
node.right = new TreeNode(Integer.parseInt(item));
q.offer(node.right);
}
}
return root;
}
}
//输出
[1,2,3]
2
三、构造数组
/**
* 构造数组
*/
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
//System.out.println(line);
int[] nums = StringToIntArray(line);
//for(int num:nums){
//System.out.println(num);
//}
}
private static int[] StringToIntArray(String str) {
String[] parts = str //根据“,”分割成字符串数组
.substring(1, str.length() - 1)
.split(",");
int[] nums = new int[parts.length];
for (int i = 0; i < parts.length; i ++)
nums[i] = Integer.parseInt(parts[i]); //转为整型数组
return nums;
}
}
//输入输出
[1,2,3,4]
[1,2,3,4]
1
2
3
4
四、构造链表
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
System.out.println(line);
ListNode node = StringToListNode(line);
System.out.println(node.val);
System.out.println(node.next.next.next.val);
}
private static class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
private static ListNode StringToListNode(String str) {
String[] parts = str //分割字符串
.substring(1, str.length() - 1)
.split(",");
ListNode dummy = new ListNode(-1), cur = dummy; //虚拟头结点
for (String s: parts) {
cur.next = new ListNode(Integer.parseInt(s)); //逐个添加链表的结点
cur = cur.next;
}
return dummy.next; //返回真正的头结点
}
}
五、二叉树变成数组或者字符串(输出)
/**
* ACM模式:二叉树 删除搜索二叉树的节点
* 输入:
* 5 3 6 2 4 null 7
* 3
* 输出:
* [5,4,6,2,null,null,7]
* 5 4 6 2 null null 7
*/
public class Solution7 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
int key = sc.nextInt();
String[] parts = line.split(" ");//字符串变数组
int len = parts.length;
TreeNode root = strToTree(parts);//数组变树
TreeNode res = deleteNode(root,key);//题目的处理逻辑
//树变数组
Integer[] nums = new Integer[len];
treeToArray(nums,res,0);
// //输出1：[5,4,6,2,null,null,7]
// System.out.println(Arrays.toString(nums));
String str = Arrays.toString(nums);
str = str.substring(1,str.length()-1);
System.out.println(str.replace(","," "));
}
private static void treeToArray(Integer[] arr,TreeNode node,int index){
if(node==null){
return;
}
arr[index] = node.val;
treeToArray(arr,node.left,2*index+1);
treeToArray(arr,node.right,index*2+2);
}
六、其他情况
1. 数字+字符串
import java.util.Scanner;
/**
* leetcode 回文子串
* 输入描述:
* 2
* abc
* aaa
* 输出描述:
* 3
* 6
*/
public class Solution5 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int num = sc.nextInt();
sc.nextLine();//注意一定要有
for(int i=0;i<num;i++){
String str = sc.nextLine();
int res = countSubString(str);
System.out.println(res);
}
}
public static int countSubString(String s){
boolean[][] dp = new boolean[s.length()][s.length()];
int res = 0;
for(int i=s.length()-1;i>=0;i--){
for(int j=i;j<s.length();j++){
if(s.charAt(i)==s.charAt(j)){
if(j-i<=1){
dp[i][j] = true;
}else{
dp[i][j] = dp[i+1][j-1];
}
}
}
}
for(int i=0;i<s.length();i++){
for(int j=0;j<s.length();j++){
if(dp[i][j]){
res++;
}
}
}
return res;
}
}
2. BufferedRead用法
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.io.IOException;
//导入的都是java.io的包
public class Main {
//记得抛异常
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
String line = reader.readLine();//读取某一行 为字符串
writer.write(String X);//输出 必须是字符串形式
writer.newLine();//换行
writer.flush();//放在最后,flush()表示强制将缓冲区中的数据发送出去,不必等到缓冲区满.
}
}
3. 需要定义全局变量
public class Main {
static int n;
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
n = in.nextInt();
}
private static void test(int m){
int x = m + n;
}
}
4. 未知多少行输入
有些输入可能是：
输入一个矩阵，每行以空格分隔。
1 2 3
56 8 2 9
对于这种没有给定矩阵行列数的输入，我们只能按照字符串拆分来进行。
public class test {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<List<Integer>> list = new ArrayList<>();
while (sc.hasNextLine()) { //每行都是一个List数组
List<Integer> line = new ArrayList<>();
String str = sc.nextLine();
String[] arr = str.split(" ");
for (String s : arr) {
line.add(Integer.valueOf(s));
}
list.add(line);
}
System.out.println(list); //[[1, 2, 3], [56, 8, 2, 9]]
}
}
典型例子
1. 二叉树:LeetCode删除二叉搜索树的节点(基于Scanner)
/**
* ACM模式:二叉树 删除搜索二叉树的节点
* 输入:
* 5 3 6 2 4 null 7
* 3
* 输出:
* [5,4,6,2,null,null,7]
* 5 4 6 2 null null 7
*/
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Solution7 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
int key = sc.nextInt();
String[] parts = line.split(" ");//字符串变数组
int len = parts.length;
TreeNode root = strToTree(parts);//数组变树
TreeNode res = deleteNode(root,key);//题目的处理逻辑
//树变数组
Integer[] nums = new Integer[len];
treeToArray(nums,res,0);
// //输出1：[5,4,6,2,null,null,7]
// System.out.println(Arrays.toString(nums));
String str = Arrays.toString(nums);
str = str.substring(1,str.length()-1);
System.out.println(str.replace(","," "));
}
private static class TreeNode{
int val;
TreeNode left;
TreeNode right;
TreeNode(){}
TreeNode(int val){this.val=val;}
TreeNode(int val,TreeNode left,TreeNode right){
this.val = val;
this.left = left;
this.right = right;
}
}
private static TreeNode strToTree(String[] parts){
TreeNode root = new TreeNode(Integer.parseInt(parts[0]));
int index = 1;
Queue<TreeNode> que = new LinkedList<>();
que.offer(root);
while(!que.isEmpty()){
TreeNode node = que.poll();
if(index == parts.length) break;
String item = parts[index];
index++;
if(!item.equals("null")){
TreeNode left = new TreeNode(Integer.parseInt(item));
node.left = left;
que.offer(left);
}
if(index == parts.length) break;
item = parts[index];
index++;
if(!item.equals("null")){
TreeNode right = new TreeNode(Integer.parseInt(item));
node.right = right;
que.offer(right);
}
}
return root;
}
//树转数组
private static void treeToArray(Integer[] arr,TreeNode node,int index){
if(node==null){
return;
}
arr[index] = node.val;
treeToArray(arr,node.left,2*index+1);
treeToArray(arr,node.right,index*2+2);
}
//处理逻辑
private static TreeNode deleteNode(TreeNode root,int key){
if(root == null){
return null;
}
//找到了节点
if(root.val == key){
//左右都为空
if(root.left == null && root.right == null){
return null;
}
//左为空
if(root.left == null && root.right != null){
return root.right;
}
//右为空
if(root.left != null && root.right == null){
return root.left;
}
//左右非空，把左孩子移到右孩子最左的孩子
if(root.left != null && root.right != null){
TreeNode node = root.right;
while(node.left!=null){
node = node.left;
}
node.left = root.left;
return root.right;
}
}
//没找到
if(root.val>key){
root.left = deleteNode(root.left,key);
}else{
root.right = deleteNode(root.right,key);
}
return root;
}
}
2. 链表(基于Scanner)
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;
/**
* ACM模式:链表 删除链表的倒数第N个结点
* 输入:
* 2
* [1,2,3,4,5]
* 输出
* [1,2,3,5]
*/
public class Solution8 {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int index = sc.nextInt();
sc.nextLine();
String line = sc.nextLine();
ListNode head = strToListnode(line);//字符串变成链表
ListNode res = removeNthFromEnd(head,index);//处理逻辑
ArrayList arr = listnodeToArr(res);
System.out.println(arr.toString());
}
//构造链表节点类
private static class ListNode{
int val;
ListNode next;
ListNode(){}
ListNode(int val){
this.val = val;
}
ListNode(int val,ListNode next){
this.val = val;
this.next = next;
}
}
//字符串变链表
private static ListNode strToListnode(String line){
String[] parts = line.substring(1,line.length()-1).split(",");
ListNode dummy = new ListNode(-1);
ListNode cur = dummy;
for (String part : parts) {
cur.next = new ListNode(Integer.parseInt(part));
cur = cur.next;
}
return dummy.next;
}
//链表变数组
private static ArrayList listnodeToArr(ListNode head){
ArrayList arr = new ArrayList();
ListNode dummy = new ListNode(-1);
dummy = head;
while(dummy!=null){
arr.add(dummy.val);
dummy = dummy.next;
}
return arr;
}
//处理逻辑
private static ListNode removeNthFromEnd(ListNode head, int n) {
ListNode dummyNode = new ListNode(-1);
dummyNode.next = head;
ListNode slow = dummyNode;
ListNode fast = dummyNode;
//设slow走的路程是x，fast是y,画图有y-x=n+1,即fast比slow多走n+1
for(int i = 0;i<n+1;i++){
fast = fast.next;
}
while(fast!=null){
fast = fast.next;
slow = slow.next;
}
slow.next = slow.next.next;
return dummyNode.next;
}
}
3. Scanner超时,使用BufferedRead
//本题逻辑很简单，但是由于有时间要求，如果用普通的for遍历来实现，会导致超时，用sout的方式的会造成时间增加，
//所以需要用BufferedReader和BufferedWriter来进行读写操作
public class Test03 {
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(System.out));
int T = Integer.parseInt(reader.readLine());
for (int i0 = 0; i0 < T; i0++) {
int N = Integer.parseInt(reader.readLine());
char[] a = reader.readLine().toCharArray();
int M = Integer.parseInt(reader.readLine());
char[] b = reader.readLine().toCharArray();
//创建一个对象为优先队列的集合，集合0是0人桌队列，集合1是1人桌队列
//优先队列数据结构为二叉堆(默认小顶堆，大顶堆需要添加逆序比较器Collections.reverseOrder)
List<PriorityQueue<Integer>> queueList = new ArrayList<>();
queueList.add(new PriorityQueue<>());
queueList.add(new PriorityQueue<>());
for (int i = 0; i < N; i++) {
if (a[i] - '0' < 2) {
//不同人桌的队列里放从小到大的桌号
queueList.get(a[i] - '0').offer(i + 1);
}
}
int x;
for (int i = 0; i < M; i++) {
if (b[i] == 'M') {
//找1人桌的桌子，假如不为空
if (!queueList.get(1).isEmpty()) {
//找到1人桌的桌子，输出桌号并出堆
x = queueList.get(1).poll();
writer.write(String.valueOf(x));
writer.newLine();
} else {
//找到0人桌的桌子，输出桌号并出堆
x = queueList.get(0).poll();
//将出堆的0人桌插入到1人桌的队列
queueList.get(1).offer(x);
writer.write(String.valueOf(x));
writer.newLine();
}
} else {
if (!queueList.get(0).isEmpty()) {
x = queueList.get(0).poll();
queueList.get(1).offer(x);
writer.write(String.valueOf(x));
writer.newLine();
} else {
x = queueList.get(1).poll();
writer.write(String.valueOf(x));
writer.newLine();
}
}
}
writer.flush();
}
}
}
4. 对结果去模
int mod = 1000000007
for(int i=1;i<trees.length;i++){
sum=sum*i%mod;
}
for(int i=0;i<trees.length;i++){
sum=sum*2*nums[i]%mod;
}
for(int i=0;i<trees.length;i++){
res=(res+sum*call(2*nums[i])%mod)%mod;
1737
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
