秋招之遇见过的编程题

一.翻转单词顺序列

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(begin<end){
        char temp=c[begin];
        c[begin]=c[end];
        c[end]=temp;
         
        begin++;
        end--;
    }
    }

2.字符串处理

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<String> s = new Stack<>();
        StringBuffer str1=new StringBuffer();
        for(int i=0 ;i<str.length();i++ )
        {
            if(str.charAt(i)==' ')
        {
                s.push(str1.toString());
                s.push(" ");
                 str1.delete(0,10);//??
            
        }
           else
            str1.append(str.charAt(i));
    }
        s.push(str1.toString());
        StringBuffer str2=new StringBuffer();
        while(!s.isEmpty())
        {  str2.append(s.pop());
      
        }
        return str2.toString();
}
}
2.

public String ReverseSentence(String str) {
    if (str.trim().equals("") && str.length() > 0) {
        return str; 
    }
    Stack reverse = new Stack();
    String string = str.trim();
    String[] strings = string.split(" ");
    for (int i = 0; i <length; i++) {
        reverse.push(strings[i]);
    }
    string = reverse.pop();
    while (!reverse.isEmpty()) {
        string = string + " " + reverse.pop();
    }
    return string;
}

二.在一个字符串中查找重复最多的字符

如：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<str.length();i++){
            if(first==str.charAt(i)){
                firstCount++;
            }else {
                if(resultCount<firstCount){
                    result=first;
                    resultCount=firstCount;
                }
                first=str.charAt(i);
                firstCount=1;
            }
        }

        if(resultCount<firstCount){
            resultCount=firstCount;
            result=first;
        }

        //专程字符串
        return result+" ";
     
    }

三.

给定一个整数数组 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<Integer,Integer> map=new HashMap<Integer,Integer>();
        for(int i=0;i<nums.length;i++){
            if(map.containsKey(nums[i])){
                index[0]=map.get(nums[i]);
                index[1]=i;
                return index;
            }else{
                map.put(target-nums[i],i);
            }
        }
        return index;
    }
}

四.统计字符串中字符出现的次数，并按照次数降序排列

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<Character,Integer> 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<C> 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<C>{
        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<Character,Integer> hm = new HashMap();
        List<Map.Entry<Character,Integer>> 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<Map.Entry<Character,Integer>>() {
            @Override
            public int compare(Map.Entry<Character,Integer> o1, Map.Entry<Character,Integer> o2) {
                //return o1.getValue() - o2.getValue(); // 升序
                return o2.getValue() - o1.getValue(); // 降序
            }
        });

        
     // 遍历排序后输出    
        StringBuffer sb=new StringBuffer();
        for (Map.Entry<Character, Integer> 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);
    }

}