秋招之遇见过的编程题
一.翻转单词顺序列
I am a student .---->student. a am I
1.两次翻转
//两次翻转
public class Solution {
public String ReverseSentence(String str) {
if(str==null||str.trim().equals(""))
return str;
char[] c=str.toCharArray();
reverse(c, 0, str.length()-1);//翻转整个句子
//翻转句子中的每个单词
int begin=0;
int end=0;
while(begin!=c.length){
if(c[begin]==' '){//若起始字符为空格，则begin和end都自加
begin++;
end++;
}
else if(c[end]==' '){//遍历到终止字符为空格，就进行翻转
reverse(c, begin, --end);
begin=++end;//把begin移到下一个单词的头
}
else if(end==c.length-1){//若遍历结束，就进行翻转
reverse(c, begin,end);
begin=++end;//跳出while循环的条件
}
else{//没有遍历到空格或者遍历没有结束，则对end自加，找全这个单词
end++;
}
}
return String.valueOf(c);
}
//完成翻转功能
private void reverse(char[] c,int begin,int end){
while(begin2.字符串处理
public class Solution {
public String ReverseSentence(String str) {
if(str.trim().equals("")){//去掉字符序列左边和右边的空格
return str;
}
String[] a = str.split(" ");//这个是不是也只能搞一个空格
StringBuffer o = new StringBuffer();
int i;
for (i = a.length; i >0;i--){
o.append(a[i-1]);
if(i > 1){
o.append(" ");
}
}
return o.toString();
}
}3.栈
1.
import java.util.Stack;
public class Solution {
public String ReverseSentence(String str) {
Stack s = new Stack<>();
StringBuffer str1=new StringBuffer();
for(int i=0 ;i 0) {
return str;
}
Stack reverse = new Stack();
String string = str.trim();
String[] strings = string.split(" ");
for (int i = 0; i 二.在一个字符串中查找重复最多的字符
如：abbbccccc。输出ccccc
public static void main(String[] args) {
String str="abbbccccc";
System.out.println(getMaxCountChar(str);
}
public static String getMaxCountChar(String str){
if(str==null ||str.length()<=1) return str;
//保存临时变量
char first=str.charAt(0);
int firstCount=1;
//保存结果
char result='0';
int resultCount=0;
for(int i=1;i三.
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。
你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
class Solution {
public int[] twoSum(int[] nums, int target) {
int[] index=new int[2];
HashMap map=new HashMap();
for(int i=0;i 四.统计字符串中字符出现的次数，并按照次数降序排列
baaabca
a:4
b:2
c:1
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
public class K3 {
public static void count(String str){
char[] chars = str.toCharArray();
HashMap hm = new HashMap();
for(char c : chars){
if(!hm.containsKey(c)){
hm.put(c,1);
}else{
hm.put(c, hm.get(c)+1);
}
}
StringBuilder sb=new StringBuilder();
List list=new ArrayList<>();
for(Character key: hm.keySet()){
C c=new C(key,hm.get(key));
list.add(c);
}
Collections.sort(list);
for(C c:list){
sb.append(c.value + ":" + c.count+",");
}
System.out.println(sb.toString().substring(0,sb.length()-1));
}
public static void main(String[] args) {
String str = "abcaabbbbbbbaefdabbhg";
count(str);
}
static class C implements Comparable{
char value;
Integer count;
public C(char value,int count){
this.count=count;
this.value=value;
}
@Override
public int compareTo(C o) {
return o.count-count;
}
}
}
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MyTest {
public static void count(String str){
//将字符串转化为字符数组
char[] chars = str.toCharArray();
//创建一个HashMap名为hm
HashMap hm = new HashMap();
List> list = new ArrayList<>();
//定义一个字符串c，循环遍历遍历chars数组
for(char c : chars){
//containsKey(c),当c不存在于hm中
if(!hm.containsKey(c)){
hm.put(c,1);
}else{
hm.put(c, hm.get(c)+1);
}
}
// 遍历map，存到list中
list.addAll(hm.entrySet());
// 根据字符个数进行比较
Collections.sort(list, new Comparator>() {
@Override
public int compare(Map.Entry o1, Map.Entry o2) {
//return o1.getValue() - o2.getValue(); // 升序
return o2.getValue() - o1.getValue(); // 降序
}
});
// 遍历排序后输出
StringBuffer sb=new StringBuffer();
for (Map.Entry entry : list) {
sb.append(entry.getKey() + ":" + entry.getValue()+",");
}
System.out.println(sb.toString().substring(0,sb.length()-1));
}
public static void main(String[] args) {
// TODO 自动生成的方法存根
String str = "baaabca";
count(str);
}
}