基本数据结构
数组
//数组排序方法
//正序
Arrays.sort(arr);
//倒序
1.
Arrays.sort(arr,new Comparator<Integer>{
//这里表示重写的方法
};)
2.
Arrays.sort(arr,(o1,o2) -> o2-o1);
集合
//结构
ArrayList<T> list = new ArrayList<>();
//方法
//添加数据 list.add();
//输出数据 list.get(index);
//删除数据 list.remove(index);
//判断列表是否为空 list.isEmpty(list);
//查找元素 se.contains(val);
//排序
//正序
Collections.sort(list);
//倒叙
==与以上的数组一致!==
Set集合
//结构
Set<Integer> se = new HashSet<Integer>();
//功能
1.去重
2.数据无序
//方法
//添加数据 se.add();
//输出数据数量 se.size();
//删除数据 se.remove();
//查找元素 se.contains(val);
//清除集合中的所有元素 se.clear();
综合练习
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了 NN 个 1 到 1000 之间的随机整数（N≤100N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
输入描述
第 1 行为 1 个正整数，表示所生成的随机数的个数：NN。
第 2 行有 NN 个用空格隔开的正整数，为所产生的随机数。
输出描述
输出 2 行，第 1 行为 1 个正整数 MM，表示不相同的随机数的个数。
第 2 行为 MM 个用空格隔开的正整数，为从小到大排好序的不相同的随机数。
示例
输入
10
20 40 32 67 40 20 89 300 400 15
输出
8
15 20 32 40 67 89 300 400
import java.util.*;
public class bule539 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//接受输入元素的个数
int n = scan.nextInt();
int[] arr = new int[n];
//给数组赋值
for(int i=0;i<arr.length;i++)
{
arr[i] = scan.nextInt();
}
//定义一个set集合
Set<Integer> set = new HashSet<>();
//定义一个集合
List<Integer> list = new ArrayList<>();
for(int i = 0;i<arr.length;i++)
{
//如果集合中没有就执行
if(!set.contains(arr[i]))
{
set.add(arr[i]);
list.add(arr[i]);
}
else {
continue;
}
}
System.out.println(list.size());
//集合排序
Collections.sort(list);
for(int x: list)
{
System.out.print(x + " ");
}
}
}
Map集合
//基本结构
Map<Integer,Integer> map = new HashMap<>();
//基本方法
//输入数据 map.put(key,val);
//输出数据 map.get(key);
//数据的个数 map.size();
//将数据变成Entry对象 map.entrySet(); //前提 Entry<Integer,integer> entry: map.entrySet()
//查找数据如果没有返回默认值val map.getOrDefault(key,0); //第二个是默认值
综合练习
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;
public class TestCup {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
//声明一个HashMap对象
Map<Integer, Integer> map = new HashMap<>();
//第二个位置存放相同的数的个数
for(int i=0;i<n;i++)
{
int a = scanner.nextInt();
map.put(a, map.getOrDefault(a, 0)+1);
}
//创建一个最大值变量，用以存放数量最多的数
int max = 0;
//增强for循环求出最大的数
for(Entry entry: map.entrySet())
{
max = Math.max(max, (int) entry.getValue());
}
//创建集合
List<Integer> list = new ArrayList<>();
for(Entry entry: map.entrySet())
{
//将Map中的键值存放在ArrayList当中
if((int)entry.getValue() == max)
{
list.add((Integer) entry.getKey());
}
}
//集合排序（从小到大）
Collections.sort(list);
for(int list2: list)
{
System.out.print(list2 + " ");
}
}
}
Stack(栈)
//基本结构
Stack<Integer> stack = new Stack<>();
//基本方法
//把数据添加到栈顶 stack.push(1);
//移除栈顶元素并返回数据 stack.pop();
//返回栈顶元素 stack.peek();
//查看栈是否为空 stack.isEmpty();
综合练习
import java.util.Scanner;
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
//在此输入您的代码...
int n = scan.nextInt();
char[] ch = scan.next().toCharArray();
//创建栈的对象
Stack<Character> stak = new Stack<>();
//声明一个boolean变量作为总的判断条件
boolean br = true;
//增强for循环遍历
for(char x: ch)
{
if(x == '(')
{
stak.push(x);
}
else if(!stak.isEmpty()) { //判断是否为空
stak.pop();
}
else {
br = false;
break;
}
}
//看看栈内是否为空
if(!stak.isEmpty())
{
br = false;
}
if(br)
{
System.out.println("Yes");
}
else {
System.out.println("No");
}
scan.close();
}
}
基础算法
排序
倒叙与正序的应用
//在数组中输入数，输出他的正序和倒序
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class Apai {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
Integer[] arr = new Integer[n];
for(int i=0;i<arr.length;i++)
{
arr[i] = scanner.nextInt();
}
//数组排序
Arrays.sort(arr);
for(int i =0;i<arr.length;i++)
{
System.out.print(arr[i] + " ");
}
//数组倒序排序
Arrays.sort(arr,new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
// TODO Auto-generated method stub
return o2-o1;
}
});
//输出换行
System.out.println();
for(int i=0;i<arr.length;i++)
{
System.out.print(arr[i] + " ");
}
}
}
数位排序
//蓝桥云课第2122题
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class NumberWei {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
//创建二维数组,f[i][0]表示数值,f[i][1]表示数位和
int[][] f = new int[n][2];
for(int i=0;i<n;i++)
{
f[i][0] = i+1;
//变为字符串便于找出每一位
String string = f[i][0] + "";
for(int j=0;j<string.length();j++)
{
//找出字符串的每一位，并变为数字
f[i][1] += string.charAt(j) - '0';
}
}
//重点，如果相等数值较小的在前面，如果不相等数位较小的在前面
Arrays.sort(f,(o1,o2)-> o1[1] == o2[1] ? o1[0]-o2[0] : o1[1]-o2[1]);
//输出第m个数值
System.out.println(f[m-1][0]);
}
}
插入排序
import java.util.Scanner;
public class InsterSort1 {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] arr = new int[n];
for (int i = 0; i < arr.length; i++) {
arr[i] = scan.nextInt();
}
for (int i = 1; i < arr.length; i++) {
int j = i;
int target = arr[i];
while(j > 0 && arr[j-1] > target)
{
arr[j] = arr[j-1];
j--;
}
if(j != i)
{
arr[j] = target;
}
}
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}
快速排序
import java.util.Scanner;
public class QuickSort {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] arr = new int[n];
for(int i=0;i<arr.length;i++)
{
arr[i] = scan.nextInt();
}
arr = quicksort(arr,0,n-1);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
public static int[] quicksort(int[] arr,int left,int right)
{
if(left < right)
{
int p = quickfen(arr,left,right);
quicksort(arr,left,p-1);
quicksort(arr,p+1,right);
}
return arr;
}
public static int quickfen(int[] arr,int left,int right)
{
int p = left;
int index = p+1;
for(int i = index;i<=right;i++)
{
if(arr[i] < arr[p])
{
swap(arr,i,index);
index++;
}
}
swap(arr,p,index-1);
return index-1;
}
public static void swap(int[] arr,int a,int b)
{
int t = arr[a];
arr[a] = arr[b];
arr[b] = t;
}
}
二分查找
//名称
binarySearch()
基础二分查找代码
public class Main {
public static void main(String[] args) {
int[] data = new int[200];
for(int i=0;i<200;i++)
{
data[i] = 4 * i + 6;
}
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int l = 0;
int r = data.length-1;
while(l <= r)
{
int mind = (l+r) >>> 1;
if(data[mind] < n)
{
l = mind+1;
}
else if(data[mind] > n)
{
r = mind-1;
}
else {
System.out.println(mind);
break;
}
}
}
}
基础操作方法汇总
String方法的用法
//补充将字符串中的大写转换为小写
toLowerCase();
//使用默认语言环境的规则将此 String 中的所有字符都转换为大写。
toUpperCase();
//特别补充'^'转换法
c ^ 32 可转换为大写C
综合练习
//字符串拼接，求最大的值
import java.util.Arrays;
import java.util.Comparator;
import java.util.Scanner;
public class MaxNumber {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
//创建一个字符串数组方便计算
String[] arr = new String[n];
for(int i=0;i<arr.length;i++)
{
arr[i] = scan.next();
}
//倒序排列的出最大的值
Arrays.sort(arr,new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
// TODO Auto-generated method stub
return (o2+o1).compareTo(o1+o2); //字符串要用+,比比两个谁大谁大就返回谁
}
});
//创建一个容器存放字符串
StringBuilder sBuilder = new StringBuilder();
for (int i = 0; i < arr.length; i++) {
sBuilder.append(arr[i]);
}
System.out.println(sBuilder.toString());
}
}
Arrays方法的用法
//此中n表示数组，x表示变量
//数组排序
Arrays.sort(n);
//以及和方式打印
Arrays.toString(n);
//二分查找
Arrays.binarySearch(n,x);
System方法的用法
//此中n表示数组，x表示变量
//输出打印
System.out.println(x);
//数组拷贝 1：原数组名 2：开始位置 3：新数组名 4：开始位置 5：要复制的个数
System.arraycopy(n , 0 , n1 , 0 , index);
//关闭虚拟机
System.exit(0);
//返回当前系统时间以毫秒形式
System.currenTimeMillis();
Math方法的用法
Runtime方法的用法
基本算法代码
求最大公约数，最小公倍数，质数
public class MaxMinZhi {
public static void main(String[] args)
{
int max = Maxyun(16,8);
System.out.println(max);
int min = MinBei(4, 3);
System.out.println(min);
boolean ifNozhi = ZhiNumber(17);
System.out.println(ifNozhi);
}
//求两个数的最大公约数
public static int Maxyun(int x,int y)
{
if(y == 0)
{
return x;
}
return Maxyun(y, x%y);
}
//求两个数的最小公倍数
public static int MinBei(int x,int y)
{
return x*y/Maxyun(x, y);
}
//求某个数是不是质数
public static boolean ZhiNumber(int number)
{
if(number == 1)
return false;
for(int i=2;i<number;i++)
{
if(number % i == 0)
return false;
}
return true;
}
}
查看某个数是不是质数(加强版)
public static boolean ZhiNumber(int number)
{
if(number == 1)
return false;
for(int i=2;i<Math.sqrt(number);i++)
{
if(number % i == 0)
return false;
}
return true;
}
水仙花数
import javax.swing.event.TableColumnModelListener;
public class ThreeFourFive {
public static void main(String[] args) {
int count = 0;
for(int i=100;i<=999;i++)
{
if(Threewhite(i))
{
System.out.println(i);
count++;
}
}
System.out.println(count);
}
//水仙花数
public static boolean Threewhite(int number)
{
int ge = number%10;
int ten = number/10%10;
int bai = number/100%10;
double sum = Math.pow(ge, 3)+ Math.pow(ten, 3)+ Math.pow(bai,3);
if(sum == number)
{
return true;
}
return false;
}
}
数字反转(蓝桥云课396题)
import java.util.Scanner;
public class reserveInt {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
//判断数字符号
if(n >= 0)
{
//创建一个StringBuilder对象
StringBuilder sBuilder = new StringBuilder();
//给容器添加数据
sBuilder.append(n);
//数据反转
sBuilder.reverse();
//将容器中的数据转换为字符串
String str = sBuilder.toString();
//将字符串强转为整数
n = Integer.valueOf(str);
}
else {
String str1 = n+"";
StringBuilder sb = new StringBuilder();
//将字符串str1索引1以及之后的数据交给容器
sb.append(str1.substring(1));
String str2 = sb.reverse().toString();
n = Integer.valueOf(str2);
//别忘了这里要将负号加回来
n = -n;
}
//打印
System.out.println(n);
}
}
求数组中的最大值，最小值以及找出数组中的每一个元素与所有元素差的绝对值的最大值
package day02;
import java.util.Scanner;
public class MaxMinAbs {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int[] arr = new int[n];
int max = 0;
//定义min为整数的最大值
int min = Integer.MAX_VALUE;
int absMax = 0;
//给数组中的每一个元素赋初值
for(int i=0;i<arr.length;i++)
{
arr[i] = sc.nextInt();
}
//找出数组中的最大值和最小值
for(int j=0;j<arr.length;j++)
{
max = Math.max(arr[j], max);
min = Math.min(arr[j], min);
}
//找出数组中的每一个元素与所有元素差的绝对值的最大值
for(int i=0;i<arr.length;i++)
{
for(int j=0;j<arr.length;j++)
{
if(i == j)
continue;
absMax = Math.max(Math.abs(arr[i] - arr[j]), absMax);
}
}
System.out.println("最大值为：" + max + " 最小值为:" + min + " 绝对值的最大值为:" + absMax);
}
}
大小写转换
package day02;
import java.util.Scanner;
public class BigtoSmall {
public static void main(String[] args)
{
Scanner sc = new Scanner(System.in);
String string = sc.next();
//创建容器StringBuilder
StringBuilder sb = new StringBuilder();
for(int i=0;i<string.length();i++)
{
//获取字符串中的每一个字符
char c= string.charAt(i);
//判断是否在26个字母当中
if(c >= 'A' && c <= 'Z' || c >= 'a' && c <= 'z')
{
//最重要!!!! 异或转换c是大写就转小写，反之亦然
c = (char)(c^32);
}
//将字符存放在容器中
sb.append(c);
}
//转化为字符串
String str = sb.toString();
System.out.println(str);
}
}
连号区间数
//枚举
//(这题的关键在于你知道连号区间是指在这个区间中最大值和最小值的差等于这个区间的长度)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int[] arr = new int[n];
int count = 0;
for (int i = 0; i < arr.length; i++) {
arr[i] = scan.nextInt();
}
for (int i = 0; i < arr.length; i++) {
int max = Integer.MIN_VALUE;
int min = Integer.MAX_VALUE;
for(int j = i;j<arr.length;j++)
{
max = Math.max(max, arr[j]);
min = Math.min(min, arr[j]);
if(j-i == max-min)
{
count++;
}
}
}
System.out.println(count);
}
}
扫雷
示例 1
输入
3 4
0 1 0 0
1 0 1 0
0 0 1 0
输出
2 9 2 1
9 4 9 2
1 3 9 2
//在一个
//n 行
//m 列的方格图上有一些位置有地雷，另外一些位置为空。
//请为每个空位置标一个整数，表示周围八个相邻的方格中有多少个地雷。
//注意在求解输出时直接输出值即可，不要改变数组的值
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
int[][] arr = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
arr[i][j] = scan.nextInt();
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if(arr[i][j] == 1)
{
System.out.print(9 +" ");
}
else {
int count=0;
for (int a = i-1; a <= i+1; a++) {
for (int b = j-1; b <= j+1; b++) {
if(a>=n || a<0 || b<0 || b>=m)
{
continue;
}
if(arr[a][b] == 1)
{
count++;
}
}
}
System.out.print(count+" ");
}
}
System.out.println();
}
}
}
