常见算法
文章目录
- 常见算法
- 常见问题
- 1.字符串数组排序（冒泡）
- 2.筛选n以内的素数
- 3.判断n是否素数
- 4.字符串转换为char数组
- 5.两个数组相似度
- 6.字符数组内是否有某一字符串
- 7.字符串排序
- 8.字符串排序
- 9.每行数组求和
- 10.每行数组求和
- 11.每行数组求和
- 12.每行数组求和
- 13.判断一个字符串中出现次数最多的字符并统计其出现的次数(面试题)
- 14.一个数组中只有一个数字是重复的，找出重复的数字
- 15.查找字符串中重复的子串，并输出重复的次数
- 16.查找一个数组中只出现了奇数次的那个数（其他数都出现了偶数次）[两个奇数次
- 17.题目：输入两个字符串，从第一字符串中删除第二个字符串中所有的字符
- 18.题目：不含有重复字符的 最长子串 的长度
- 19.题目：两数之和a+b=sum（一串数组中找出a+b）
- 20.题目：卖股票的最佳时机
- 21.题目：使用最小花费爬楼梯（动态规划）
- 22.题目：StringBuffer，StrungBuilder的区别
- 23.题目：最长回文子串
- 24.题目： List和ArrayList的区别
- 25.题目：判断字符串是否回文字符串（直接调用函数Reverse）
- 26.题目：反转链表（指针跟栈）
- 二、使用步骤
- 总结
常见问题
1.牛客力扣上默认的方法名字改了后可能会报错
2.String和Char相互转换
s.toCharArray();
String.valueOf©;//string转换成char
String转换成int
Integer.parseInt();
3.通过HashSet踢除重复元素
public static List removeDuplicate(List list) {
HashSet h = new HashSet(list);
list.clear();
list.addAll(h);
return list;
}
4.String转换为StringBuffer，StringBuffer能直接用reverse倒置数组，判断是否回文数组
1.字符串数组排序（冒泡）
package input_output;
import java.util.Scanner;
//冒泡字符串数组排序
public class stringsort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String arr = sc.nextLine();
char[] arr1 = arr.toCharArray();
for (int i = 0; i < arr1.length - 1; i++) { //记得<length-1
for (int j = i + 1; j < arr1.length; j++) { //这里小于length
if (arr1[i] > arr1[j]) {
char temp = arr1[i];
arr1[i] = arr1[j];
arr1[j] = temp;
}
}
}
for (int t = 0; t < arr1.length; t++) {
System.out.print(arr1[t] + " ");
}
}
}
2.筛选n以内的素数
筛选法求解过程为：将2~n之间的正整数放在数组内存储，
将数组中2之后的所有能被2整除的数清0，
再将3之后的所有能被3整除的数清0 ，以此类推，直到n为止。
数组中不为0 的数即为素数
输入描述：多组输入，每行输入一个正整数（不大于100）。
输出描述：针对每行输入的整数n，输出两行，第一行，输出n之内（包括n）的素数，用空格分隔，
第二行，输出数组中2之后被清0的个数。每行输出后换行。
输入：20
输出：2 3 5 7 11 13 17 19
11
public class shaixuan {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int[] a = new int[105];
int n = 0;
while (sc.hasNext()) {
n = sc.nextInt();
for (int i = 2; i <= n; i++) {
a[i] = i;
}
for (int j = 3; j <= n; j++) {
for (int k = j; k <= n; k++) {
if (a[k] % (j-1) == 0) {
a[k] = 0;
}
}
}
int count = 0;
for (int i = 2; i <= n; i++) {
if (a[i] != 0) {
System.out.print(a[i] + " ");
} else count++;
}
System.out.print("\n"+count);}}}
3.判断n是否素数
package input_output;
import java.util.Scanner;
public class sushu {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int j = sc.nextInt();
int k;
for (k = 2; k < j; k++) {
if (j % k == 0) {
break;
}
}
if (k == j) {
System.out.println(j + "是素数");
} else
System.out.println(j + "不是素数");
}
}
//法二:将循环范围定在2到指定数的二分之一（原理：任何一个数的最大因数都小于等于它的二分之一，所以只要从2查找到x/2，如果都没有被整除就是素数，因为到这里已经查找到他的最大因数了。例如24的最大因数为12，100的最大因数为50.）
public static void isPrime2(int x){
boolean flag;
int i=0;
int j=0;
flag=true;
for(j=2;j<=x/2;j++){
if(x%j==0){
flag=false;
break;
}
}
if(j>x/2){
System.out.println("是素数");
}else{
System.out.println("不是素数");
}
}
public static void main(String[] args) {
isPrime2(17);
}
4.字符串转换为char数组
package com.journaldev.util;
import java.util.Arrays;
public class StringToCharArray {
public static void main(String[] args) {
String str = "journaldev.com";
char[] charArr = str.toCharArray();
// print the char[] elements
System.out.println("String converted to char array: "
+ Arrays.toString(charArr));
}
}
5.两个数组相似度
题目描述 ：给出两幅相同大小的黑白图像（用0-1矩阵）表示，求它们的相似度。若两幅图像在相同位置上的像素点颜色相同，则称它们在该位置具有相同的像素点。两幅图像的相似度定义为相同像素点数占总像素点数的百分比。
输入描述:
第一行包含两个整数m和n，表示图像的行数和列数，用单个空格隔开。
1≤m≤100, 1≤n≤100。之后m行，每行n个整数0或1，表示第一幅黑白图像上各像素点的颜色，相邻两个数用单个空格隔开。
之后m行，每行n个整数0或1，表示第二幅黑白图像上各像素点的颜色，相邻两个数用单个空格隔开。
输出描述：一个实数，表示相似度(以百分比的形式给出)，精确到小数点后两位。
输入：3 3
1 0 1
0 0 1
1 1 0
1 1 0
0 0 1
0 0 1
输出：44.44
import java.util.Scanner;
public class xiangsidu {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
int[][] m1 = new int[m][n];
int[][] n1 = new int[m][n];
double count = 0; //必须是double类型，要不默认整型后面没办法弄
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
m1[i][j] = sc.nextInt(); //有些不用管输入一行空格分开
} }
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
n1[i][j] = sc.nextInt();
} }
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (m1[i][j] == n1[i][j]) {
count++;
} }}
double k = count / (m * n) * 100;
System.out.println(String.format("%.2f", k)); //小数点后两位 String.format
}
}
6.字符数组内是否有某一字符串
题目描述:有个软件系统登录的用户名和密码为（用户名：admin，密码：admin），用户输入用户名和密码，判断是否登录成功。
输入描述:多组测试数据，每行有两个用空格分开的字符串，第一个为用户名，第二个为密码。
输出描述：链接：针对每组输入测试数据，输出为一行，一个字符串（“Login Success!”或“Login Fail!”）。
输入：admin admin
输出：Login Success!
import java.util.Scanner;
public class login {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] login = sc.nextLine().split(" ");
String a = "admin";
String b = "admin";
if (login[0].equals(a) && login[1].equals(b)) { //包含某一字符串是cotain
System.out.println("Login Success!");
} else System.out.println("Login Fail!");
}
}
7.字符串排序
输入描述：多个测试用例，每个测试用例一行。
每行通过,隔开，有n个字符，n＜100
输出描述：对于每组用例输出一行排序后的字符串，用’,'隔开，无结尾空格
输入：a,c,bb
f,dddd
nowcoder
输出：a,bb,c
dddd,f
nowcoder
public class char_3 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
while (sc.hasNextLine()){
String[] string=sc.nextLine().split(",");
Arrays.sort(string);
System.out.println(String.join(",",string));
}
}
}
8.字符串排序
输入描述：输入有两行，第一行n
第二行是n个字符串，字符串之间用空格隔开
输出描述：输出一行排序后的字符串，空格隔开，无结尾空格
输入：5
c d a bb e
输出：a bb c d e
public class char_input {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String n=sc.nextLine();
while (sc.hasNextLine()) {
String[] array = sc.nextLine().split(" ");
Arrays.sort(array);
System.out.println(String.join(" ",array));
}
}
}
9.每行数组求和
输入描述：
输入数据有多组, 每行表示一组输入数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
输出描述：
每组数据输出求和的结果
输入：4 1 2 3 4
5 1 2 3 4 5
输出：10
15
public class duohang {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
while (sc.hasNext()) {
int a= sc.nextInt();
int sum=0;
for (int i=0;i<a;i++){
sum+= sc.nextInt();
}
System.out.println(sum);
}
}
}
10.每行数组求和
输入描述：输入数据有多组, 每行表示一组输入数据。
每行不定有n个整数，空格隔开。(1 <= n <= 100)。
输出描述：每组数据输出求和的结果
输入：1 2 3
4 5
0 0 0 0 0
输出：6
9
0
public class duozu {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
String[] array = sc.nextLine().split(" ");
int sum = 0;
for (int i = 0; i < array.length; i++) {
sum += Integer.parseInt(array[i]);
}
System.out.println(sum);
}
}
}
11.每行数组求和
public class lianghang {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int a = sc.nextInt();
for (int i = 0; i < a; a++) {
int sum = 0;
for (int j = sc.nextInt(); j > 0; j--) {
int b = sc.nextInt();
sum = sum + b; }
System.out.println(sum);
}
}}}
12.每行数组求和
输入的第一行包括一个正整数t(1 <= t <= 100), 表示数据组数。
接下来t行, 每行一组数据。
每行的第一个整数为整数的个数n(1 <= n <= 100)。
接下来n个正整数, 即需要求和的每个正整数。
每组数据输出求和的结果
输入： 2
4 1 2 3 4
5 1 2 3 4 5
输出： 10
15
public class lianghang {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (sc.hasNext()) {
int a = sc.nextInt();
for (int i = 0; i < a; a++) {
int sum = 0;
for (int j = sc.nextInt(); j > 0; j--) {
int b = sc.nextInt();
sum = sum + b;
}
System.out.println(sum);
}
}
}
}
13.判断一个字符串中出现次数最多的字符并统计其出现的次数(面试题)
法一：放在hashmap中，对字符串进行循环，如果hashmap中包含的话，给value+1，将value赋值给max，输出重复次数，找到对应字符。
在这里插入代码片package input_output;
import java.util.HashMap;
import java.util.Scanner;
public class repeata {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
char[] str1 = str.toCharArray();
HashMap<Character, Integer> map = new HashMap();
int count = 1;
int max = 0;
String repeat = "";
for (int i = 0; i < str1.length; i++) {
if (!map.containsKey(str1[i])) {
map.put(str1[i], count);
} else {
map.put(str1[i], ++count);
}
if (map.get(str1[i]) > max) {
max = map.get(str1[i]);
repeat = String.valueOf(str1[i]);
}
}
System.out.println(repeat + " " + max);
}
}
//hashmap 添加元素(map.put()) 访问元素(map.get(key)) 删除元素(map.remove()) 计算map的大小(map.size()) for (Object key : map.keySet()) 遍历key-value合集 for(Object value: map.values()) 遍历value合集
//
法二：利用两个ArrayList，ArrayList 是一个数组队列，提供了相关的添加（array.add()）、删除(array.remove())、修改(array.set(,))、遍历(for循环)、访问(array.get()).
import java.util.ArrayList;
import java.util.Scanner;
public class repeata {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str = sc.nextLine();
int j = 0;
char[] str1 = str.toCharArray();
ArrayList<Character> list1 = new ArrayList<>();
ArrayList<Integer> list2 = new ArrayList<>();
int count = 0;
int max = 0;
String a = null;
for (int i = 0; i < str1.length; i++) {
if (!list1.contains(str1[i])) {
list1.add(str1[i]);
list2.add(1);
} else {
list2.set(list1.indexOf(str1[i]), list2.get(list1.indexOf(str1[i])) + 1); //Arraylist修改元素
}
}
for (int i = 0; i < list2.size(); i++) {
if (list2.get(i) > max) {
max = list2.get(i);
a = String.valueOf(list1.get(i));
// 或者直接赋值给j
j = i;
}
}
System.out.println(a + " " + max);
System.out.println(list1.get(j) + " " + max);
}
}
14.一个数组中只有一个数字是重复的，找出重复的数字
题目描述：数字1-1000放在一个长度为1001的int 类型的数组中，其中只有一个数字是重复的，求这个重复数字是哪个？（要求所有元素最多只能取一次）
调用put方法时，如果已经存在一个相同的key， 则返回的是前一个key对应的value，同时该key的新value覆盖旧value；
如果是新的一个key，则返回的是null；
import java.util.ArrayList;
public class getrepeat {
public static void main(String[] args) {
int a[] = {1, 2, 3, 4, 5, 1};
System.out.println(getrepeat(a));
}
public static int getrepeat(int e[]) {
Integer key = 0;
int i = 0;
HashMap<Integer, Integer> map = new HashMap<>();
for (key = 0; i < e.length; i++) {
key = map.put(e[i], e[i]);
if (key != null)
break;
}
return key;
}
}
2.一个字符串中只有一个字符是重复的，找出重复的字符，用hashmap
import java.util.ArrayList;
public class getrepeat {
public static void main(String[] args) {
String a = "abcskidhtuvekf";
char[] str = a.toCharArray();
getrepeat(str);
}
public static void getrepeat(char[] str) {
ArrayList<Character> list = new ArrayList<>();
for (int i = 0; i < str.length; i++) {
if (!list.contains(str[i])) {
list.add(str[i]);
} else {
System.out.println(str[i]);
break;
}
}
}
}
15.查找字符串中重复的子串，并输出重复的次数
对一个字符串，从第一个字符开始，检查前两个字符组成的字符串，是否被它后面的子串包含。如果没有包含，则从第二个字符开始同样的方法检查；如果包含则统计包含数量。
import java.util.HashMap;
public class RepeatString
{
public static void main(String[] args)
{
String str="abcdefghcdefaecdehkcdefdedehkcfa";
HashMap<string,integer=""> map=new HashMap<>();
for(int i=0;i<str.length()-3;i++)//处理的字符串向后移动
{
int k=i;
String str1=str.substring(i,i+2);
String str2=str.substring(i+2);
while(str2.contains(str1))//后面的字串包含前面的
{
int cnt=1;
String strtemp=str2;
while(strtemp.contains(str1))
{
cnt++;
strtemp=strtemp.substring(strtemp.indexOf(str1)+str1.length());
//被查找的字符串更新
}
if(!map.containsKey(str1))
map.put(str1,cnt);//放入HashMap
str1=str.substring(i,++k+2);//”可能的重复串“扩展
str2=str.substring(k+2);
}
}
int j=0;//以下程序为了格式化输出
for(Object key:map.keySet())
{
j++;
System.out.print(key+":"+map.get(key)+"\t");
if(j%5==0)
System.out.println();
}
}
}
16.查找一个数组中只出现了奇数次的那个数（其他数都出现了偶数次）[两个奇数次
]
异或运算。00=0 | 01=1 | 01=1 | 11=0 只有两个真值不同才是1
数字转换为二进制不断异或。两个相同的数异或等于0，所以只要偶数个相同的数异或肯定为0，奇数个数异或最后剩下一个数就是它本身
异或中运算和异或顺序无关，所以不用在乎数组中数字的顺序
package input_output;
import java.util.Scanner;
public class yihuo {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] array = sc.nextLine().split(" ");
int[] arr = new int[array.length];
int ero = 0;
for (int i = 0; i < array.length; i++) {
arr[i] = Integer.parseInt(array[i]);
}
for (int j = 0; j < arr.length; j++) {
ero ^= arr[j];
}
System.out.println(ero);
}
}
有两种数出现了奇数次，其他所有数出现了偶数次。怎么样找到这两种数。
获取全部异或结果。然后获取到二进制中最右边的那一个1。用这个1来区别a和b。得到a或者b以后，a^ (a^b)=b。可以得出另外一个数。
public static void findNum2(int[] arr){
int tem = 0;
for (int i:arr){
tem ^= i;
}//tem 必然为 a^b。因为不是0。所以肯定二进制中肯定有一位1
int rightOne = tem & (~tem +1);//获取二进制中最右边的那一位1
int onlyOne = 0;
for (int j:arr){
if ((j&rightOne)==0){
//找出其中一个a^b。a或者b。就是用最右边它俩不同的1来区分的。
onlyOne ^= j;
}
}
System.out.println(onlyOne + " " + (onlyOne^tem) );
}
17.题目：输入两个字符串，从第一字符串中删除第二个字符串中所有的字符
输入两个字符串，从第一字符串中删除第二个字符串中所有的字符。
例如，输入”They are students.”和”aeiou”，则删除之后的字符串变成”Thy r stdnts.
思路：首先要将第一个字符串中的每个字符截取出来，截取成单个字符，然后用contains方法进去比较，如果第二个字符串中包含有第一个字符串中的字符，就舍弃掉，如果不包含则保留使用StringBuffer的append方法进行拼接；实现如下 :
StringBuffer:追加字符串: a.append(String str) 替换字符: a.setCharAt(int index, char ch)
反转字符串: a.reverse(); 删除字符串: 指定位置的字符 a.deleteCharAt(int index) 移除序列中子字符串的字符 a.delete(int start,int end);
法一：
package input_output;
import java.util.Scanner;
public class delete3 {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String str1=sc.nextLine();
String str2=sc.nextLine();
StringBuffer s=new StringBuffer();
String[] a=str1.split("");
for (int i=0;i<a.length;i++){
if (!str2.contains(a[i])){
s.append(a[i]);
}
}
System.out.println(s);
}
}
法二：用一个ArrayList存放删除后的字符，要注意的是String.Contains()括号里需要的是CharSequence，直接String.Contains(a.charAt(i))返回值是char ，所以需要用String.valueOf(由基本数据型态转换成String)转换一下
public class delete1 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str1 = sc.nextLine();
String str2 = sc.nextLine();
ArrayList s = deletePattern(str1, str2);
for (int i = 0; i < s.size(); i++) {
System.out.print(s.get(i));
}
}
public static ArrayList<Character> deletePattern(String a, String b) {
ArrayList<Character> s = new ArrayList<>();
for (int i = 0; i < a.length(); i++) {
if (!b.contains(String.valueOf(a.charAt(i)))){
//Required type:CharSequence
//Provided:char 不转成String会没办法用contain
s.add(a.charAt(i));
}
}
return s;
}
}
法三：将第一个字符串转换为String类型字符串，每一个字符占位一个单位，而非直接转换为char类型
b.contains()里面就可以直接输入String字符串a[i]
package input_output;
import java.util.ArrayList;
import java.util.Scanner;
public class delete {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String str1 = sc.nextLine();
String str2 = sc.nextLine();
ArrayList s = deletePattern(str1, str2);
for (int i = 0; i < s.size(); i++) {
System.out.print(s.get(i));
}
}
public static ArrayList<String> deletePattern(String a, String b) {
ArrayList<String> s = new ArrayList<>();
String[] arr=a.split("");
for (int i = 0; i < a.length(); i++) {
if (!b.contains(arr[i])) {
s.add(arr[i]);
}
}
return s;
}
}
18.题目：不含有重复字符的 最长子串 的长度
给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
输入: s = “abcabcbb”
输出: 3
解释: 因为无重复字符的最长子串是 “abc”，所以其长度为 3
输入: s = “pwwkew”
输出: 3
解释: 因为无重复字符的最长子串是"wke"，所以其长度为 3
public class buchongfu {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String s = sc.nextLine();
System.out.println(lengthOfLongestSubstring(s));
}
/*法二：优化滑动窗口
public static int length(String s) {
int[] last = new int[128];
for (int i = 0; i < 128; i++) {
last[i] = -1;
}
int n = s.length();
int res = 0;
int start = 0;
for (int i = 0; i < n; i++) {
int index = s.charAt(i);
start = Math.max(start, last[index] + 1);
res = Math.max(res, i - start + 1);
last[index] = i;
}
return res;
}
*/
public static int lengthOfLongestSubstring(String s) {
int max = 0;
char t = ' ';
Map<Character, Integer> map = new HashMap<>();
for (int start = 0, end = 0; end < s.length(); end++) {
if (map.containsKey(s.charAt(end))) {
Integer value = map.get(s.charAt(end));
if (value >= start) start = value + 1; //上一个重复元素需要在窗口内
}
map.put(s.charAt(end), end);//map的key一样，不新添加
int windowLength = end - start + 1;
if (max < windowLength) {
max = Math.max(max, windowLength);
}
}
return max;
}
}
19.题目：两数之和a+b=sum（一串数组中找出a+b）
给定一个整数数组 nums和一个整数目标值 target，请你在该数组中找出 和为目标值 target的那两个整数，并返回它们的数组下标。
你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。
你可以按任意顺序返回答案。
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1]
package input_output;
import java.util.HashMap;
import java.util.Scanner;
public class laingshuzhihe {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] a = sc.nextLine().split(",");
int[] b = new int[a.length];
int target = sc.nextInt();
for (int i = 0; i < a.length; i++) {
b[i] = Integer.parseInt(a[i]);
}
int[] c = sum(b, target);
for (int i = 0; i < c.length; i++) {
System.out.println(c[i]);
}
}
/*输出数组最后一个不带逗号[2,3,4,5]而非[2,3,4,5,]
if (i=c.length-1){
System.out.println(c[i]);
}else System.out.println(c[i]+",");
*/
public static int[] towsum(int[] nums, int target) {
for (int i = 0; i < nums.length; i++) {
for (int j = i + 1; j < nums.length; j++) {
if (nums[i] + nums[j] == target) {
return new int[]{i, j};
}
}
}
return new int[0];
}
//法二：hashmap,时空复杂度都是on
public static int[] sum(int[] nums, int target) {
HashMap<Integer, Integer> map = new HashMap<>();
for (int i = 0; i < nums.length; i++) {
if (map.containsKey(target - nums[i])) {
return new int[]{map.get(target - nums[i]), i};
}
map.put(nums[i], i);
}
return new int[0];
}
}
20.题目：卖股票的最佳时机
给定一个数组 prices ，它的第i个元素prices[i]表示一支给定股票第 i 天的价格。
你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。
返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0
输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 没有交易完成, 所以最大利润为 0。
package input_output;
import java.util.Scanner;
public class maxprofit {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
String[] a = sc.nextLine().split(",");
int[] b = new int[a.length];
for (int i = 0; i < b.length; i++) {
b[i] = Integer.parseInt(a[i]);
}
System.out.println(max(b));
}
public static int max(int[] a) {
int maxp = 0;
for (int i = 0; i < a.length-1; i++) { //注意一定要减1
for (int j = i + 1; j < a.length; j++) {
int b = a[j] - a[i];
if (b>maxp){
maxp=b;
}
// maxp=Math.max(maxp,b);
}
}
return maxp;
}
}
21.题目：使用最小花费爬楼梯（动态规划）
package input_output;
/*给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。
你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。
请你计算并返回达到楼梯顶部的最低花费。
输入：cost = [10,15,20]
输出：15
解释：你将从下标为 1 的台阶开始。
- 支付 15 ，向上爬两个台阶，到达楼梯顶部。
总花费为 15 。
*/
import java.util.Scanner;
public class shit {
public static int minCostClimbingStairs(int[] cost) {
int[] dp=new int[cost.length+1];
dp[0]=0;
dp[1]=0;
int i=0;
for(i=2;i<=dp.length-1;i++){
dp[i]=Math.min(dp[i-1]+cost[i-1],dp[i-2]+cost[i-2]);
}
return dp[cost.length];
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String[] s=sc.nextLine().split(",");
int[] cost=new int[s.length];
for (int i=0;i<s.length;i++){
cost[i]=Integer.parseInt(s[i]);
}
System.out.println((minCostClimbingStairs(cost)));
}
}
22.题目：StringBuffer，StrungBuilder的区别
1.都是final类,不允许被继承，主要是从性能和安全性上考虑的
2.StringBuffer是线程安全，可以不需要额外的同步用于多线程中;
3.StringBuilder是非同步,运行于多线程中就需要使用着单独同步处理，但是速度就比StringBuffer快多了
String：适用于少量的字符串操作的情况
StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况
StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况
23.题目：最长回文子串
package input_output;
/*最长回文子串
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。
输入：s = "cbbd"
输出："bb"
*/
public class huiwen {
public static boolean ishuiwen(String s) {
int mid = s.length() / 2;
int j = s.length();
for (int i = 0; i < mid; i++) {
if (s.charAt(i) != s.charAt(j - i - 1)) {
return false;
}
//也可以j--；
}
return true;
}
public static String zuida(String t) {
String ans = "";
String sub = "";
int max = 0;
for (int i = 0; i < t.length(); i++) {
for (int j = i + 1; j < t.length(); j++) {
ans = t.substring(i, j);
if (ishuiwen(ans) && ans.length() > max) {
sub = t.substring(i, j);
max = Math.max(max, ans.length());
}
}
}
return sub;
}
public static void main(String[] args) {
System.out.println(zuida("sndabadhdn"));
}
}
24.题目： List和ArrayList的区别
List是一个接口，而ArrayList是List接口的一个实现类
ArrayList类继承并实现了List接口
//尽量用
List list = new ArrayList()；
问题的关键：为什么要用List list = new ArrayList(),而不用ArrayList alist = new ArrayList()呢?
问题就在于List接口有多个实现类，现在你用的是ArrayList，也许哪一天你需要换成其它的实现类，如LinkedList或者Vector等等，这时你只要改变这一行就行了： List list = new LinkedList(); 其它使用了list地方的代码根本不需要改动。
假设你开始用ArrayList alist = new ArrayList(), 这下你有的改了，特别是如果你使用了ArrayList实现类特有的方法和属性。
这样的好处是为了代码的可维护性，可复用性，可扩展性以及灵活性，再者就是这符合了里氏代换原则和开闭原则。
25.题目：判断字符串是否回文字符串（直接调用函数Reverse）
package input_output;
import java.util.Scanner;
public class hui {
/*判断回文字符串
String转换为StringBUffer： StringBuffer t=new StringBuffer(str);
StringBuffer有reverse函数，调用之后直接在原来的字符串上更改
t.reverse(); 不用再赋值
跟字符串判断相等StringBuffer类型的需要ToString转换为String类型的
*/
public static Boolean ishui(String s){
StringBuffer t=new StringBuffer(s);
t.reverse();
if(t.toString().equals(s)){
return true;
}
return false;
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s=sc.nextLine();
System.out.println(ishui(s));
}
}
26.题目：反转链表（指针跟栈）
package input_output;
import java.util.Stack;
public class reverse {
public class ListNode {
int val;
ListNode next;
ListNode() {
}
ListNode(int val) {
this.val = val;
}
ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
//指针反转
public static ListNode re(ListNode head) {
ListNode pre = null;
ListNode cur = head;
ListNode temp = null;
while (cur != null) {
temp = cur.next;
cur.next = pre;
pre = cur;
cur = temp;
}
return pre;
}
//用栈的方法
public static ListNode zhan(ListNode head) {
Stack<ListNode> s = new Stack<>();
while (head != null) {
s.push(head);
head = head.next;
}
if (s.isEmpty()) {
return null;
}
ListNode cur = s.pop();
ListNode temp = cur;
while (!s.isEmpty()) {
temp.next = s.pop();
temp = temp.next;
}
return cur;
}
}
二、使用步骤
1.引入库
代码如下（示例）：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
2.读入数据
代码如下（示例）：
data = pd.read_csv(
'https://labfile.oss.aliyuncs.com/courses/1283/adult.data.csv')
print(data.head())
该处使用的url网络请求的数据。
总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
2816
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
