删除给定字符串中出现次数最少的字符
<pre name="code" class="java">public class MaxCharacter {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
System.out.println("输入字母序列：");
String input = sc.nextLine();
System.out.println(new MaxCharacter().getMaxCharacters(input));
}
public String getMaxCharacters(String input){
char[] chars = new char[255];
char[] in = input.toCharArray();
Set<Character> set = new HashSet<Character>();//记录所有出现的最大的字符
int maxCount = 0;//最大的次数
for (int i = 0; i < in.length; i++) {
int tempCount = (int)++chars[in[i]];//统计字符出现的次数，数组下标代表字符，数组内容记录次数
if(tempCount >= maxCount){
if(tempCount > maxCount)//如果当前的字符次数比最大的大则清除记录
set.clear();
maxCount = tempCount;
set.add(in[i]);
}
}
StringBuilder sb = new StringBuilder();
Object[] array = set.toArray();//保存所有出现次数最大的字符的数组
for (int i = 0; i < array.length; i++) { //可能有多个字符出现次数都是最大
for (int j = 1; j <= maxCount; j++) {//最大的次数
sb.append((array[i]).toString());
}
}
return sb.toString();
}
}
NC19 子数组的最大累加和问题 java
import java.util.*;
public class Solution {
/**
* max sum of the subarray
* @param arr int整型一维数组 the array
* @return int整型
*/
public int maxsumofSubarray (int[] arr) {
// write code here
int sum = 0,max=0;
for(int i = 0;i<arr.length;i++){
if(arr[i]>0){
sum = sum + arr[i];
}else{
sum = Math.max(sum + arr[i],0);
}
max = Math.max(max,sum);
}
return max;
}
}
项目难点
volatile 和 synchronized 的区别
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
int x = 0; // 进位
ListNode dummy = new ListNode(0); // 哑节点
ListNode node = dummy;
while(l1 != null || l2 != null || x != 0) {
int sum = x; // 当前位的和
if (l1 != null) {
sum += l1.val;
l1 = l1.next;
}
if (l2 != null) {
sum += l2.val;
l2 = l2.next;
}
node.next = new ListNode(sum % 10);
x = sum / 10;
node = node.next;
}
return dummy.next;
}
}
区别一，定长和变长
char 表示定长，长度固定，varchar表示变长，即长度可变。char如果插入的长度小于定义长度时，则用空格填充；varchar小于定义长度时，还是按实际长度存储，插入多长就存多长。
因为其长度固定，char的存取速度还是要比varchar要快得多，方便程序的存储与查找；但是char也为此付出的是空间的代价，因为其长度固定，所以会占据多余的空间，可谓是以空间换取时间效率。varchar则刚好相反，以时间换空间。
区别之二，存储的容量不同
对 char 来说，最多能存放的字符个数 255，和编码无关。
而 varchar 呢，最多能存放 65532 个字符。varchar的最大有效长度由最大行大小和使用的字符集确定。整体最大长度是 65,532字节。
/***********************
* 判断一个字符串是否是回文串（左右对称） 单个数字默认为是
* @param str 需要进行判断的字符串
* @return 返回该整数是否为回文串
*/
public static boolean isPlalindrome(String str) {
//将字符串转化为字符数组
char[] array=str.toCharArray();
int left=0,right=array.length-1;//记录数组的开始位置和结束位置
while(left<right)//开始位置小于结束位置时，进行判断 两位置处于对称位置上
{
if(array[left++]!=array[right--])//如果两位值的字符不相同 则不对称
return false;//返回false
}
//所有位除奇数位时的中间位均对应 返回true
return true;
}
class Solution {
public int findCircleNum(int[][] M) {
int[] visited = new int[M.length];
int count = 0;
for (int i = 0; i < M.length; i++) {
if (visited[i] == 0) {
dfs(M, visited, i);
count++;
}
}
return count;
}
public void dfs(int[][] M, int[] visited, int i) {
for (int j = 0; j < M.length; j++) {
if (M[i][j] == 1 && visited[j] == 0) {
visited[j] = 1;
dfs(M, visited, j);
}
}
}
}
项目中遇到的问题？怎么解决？
项目中遇到委屈的事？
项目中另外几个同学负责什么？
六连杆优化结果有用到公司吗？为什么没有？
遇到的挫折？怎么解决？
public class Solution {
public List<List<String>> groupAnagrams(String[] strs) {
//创建新变量
List<List<String>> result=new ArrayList<List<String>>();
//首先先判断Strs的长度
if(strs.length<1){
return result;
}
//定义hashMap
Map<String,List<String>> ans=new HashMap<String,List<String>>();
String tmp="";
for(int i=0;i<strs.length;i++){
tmp=strs[i];
//将string装换char进行排序
char[] item1=tmp.toCharArray();
Arrays.sort(item1);
// 再转换成String
tmp=new String(item1);
//判断map中是否存在item1
if(ans.containsKey(tmp)){
//存在则添加
ans.get(tmp).add(strs[i]);
}
else{
List<String> ans1=new ArrayList<String>();
ans1.add(strs[i]);
ans.put(tmp,ans1);
}
}
for(List<String> value:ans.values()){
result.add(value);
}
return result;
}
}
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
static class Entry{
public int index;
public int val;
public Entry(int index, int val){
this.index = index;
this.val = val;
}
}
public int[] nextLargerNodes(ListNode head) {
Stack<Entry> stack = new Stack<Entry>();
int index = 0;
int length = 0;
for(ListNode p = head;p != null;p = p.next){
length++;
}
int[] res = new int[length];
for(ListNode p = head;p != null;p = p.next){
//持续弹栈结算，知道栈顶元素大于当前节点或者栈为空
while(!stack.isEmpty() && stack.peek().val < p.val){
Entry x = stack.pop();
res[x.index] = p.val;
}
stack.push(new Entry(index++, p.val));
}
while(!stack.isEmpty()){
Entry x = stack.pop();
res[x.index] = 0;
}
return res;
}
}
class Solution {
public int findLength(int[] A, int[] B) {
int res = 0;
// 创建 初始化 dp，是二维数组
int[][] dp = new int[A.length][B.length];
// 向前步进
for (int i = 0; i < A.length; i++) {
for (int j = 0; j < B.length; j++) {
// 当前指向的两个元素相等，才进行操作，不相等面谈
if (A[i] == B[j]) {
if (i == 0 || j == 0) {//任何一个为0
dp[i][j] = 1;
} else {
// 状态转移方程
dp[i][j] = dp[i - 1][j - 1] + 1;//上一次最大值加一
}
// 更新公共子数组的最大长度
res = Math.max(res, dp[i][j]);
}
}
}
return res;
}
}
规律
class Solution {
public int balancedStringSplit(String s) {
int num = 0;
int n = 0;
for (int i = 0; i < s.length(); i++) {
if (s.charAt(i)=='R')
n++;
if (s.charAt(i) == 'L')
n--;
if (n == 0)
num++;
}
return num;
}
}
面试时，问：重载（Overload）和重写（Override）的区别？
答：方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的参数列表，有兼容的返回类型，比父类被重写方法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求，不能根据返回类型进行区分。
问我现在用的 jdk 几的 java？新版本的 jdk 对于旧版本有啥变化？
单例模式下如何破坏当前的构造器私有？反射 setaccessible = true，如何避免呢？使用双/
三重检测锁，最安全的方法是用枚举类。
java 默认几个线程？2 个: main 跟辅助 gc 线程
gc 回收机制有了解吗，gc root 可以是哪些？我是背出来的
多情况字符串遍历
class Solution {
public int calculate(String s) {
Stack<Integer> stack = new Stack<Integer>();//为了处理括号
// sign 代表正负，res变量维护结果
int sign = 1, res = 0;
int length = s.length();
for (int i = 0; i < length; i++) {
char ch = s.charAt(i);
if (Character.isDigit(ch)) {
int cur = ch - '0';
while (i + 1 < length && Character.isDigit(s.charAt(i + 1)))
cur = cur * 10 + s.charAt(++i) - '0';
res = res + sign * cur;
} else if (ch == '+') {
sign = 1;
} else if (ch == '-') {
sign = -1;
} else if (ch == '(') {
stack.push(res);
res = 0;
stack.push(sign);
sign = 1;
} else if (ch == ')') {
res = stack.pop() * res + stack.pop();
}
}
return res;
}
}
审题：只是删除相邻重复项，不是不相邻的
代入示例写代码，例子法来审题。
数组及其双指针的操作
class Solution {
public String removeDuplicates(String S) {
int n = S.length();
int i = 0;
char[] c = new char[n]; //结果数组
for (int j = 0; j < n; j++) { //遍历字符串S
if (i > 0 && c[i - 1] == S.charAt(j)) { //标记i>0并且相邻的两个字符相等时
i--; //标记i--
} else {
c[i++] = S.charAt(j); //将当前字符存入数组c中
}
}
return new String(c, 0, i); //以字符串的形式返回数组中从角标0开始的i个元素
}
}
请添加图片描述
队列遍历
/**
* Definition for a binary tree node.
* public 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;
* }
* }
*/
class Solution {
public List<Integer> largestValues(TreeNode root) {
//为了避免队列中的节点混淆，分别使用两个计数器来记录当前队列中当前层节点的个数和下一层节点的个数
int current = 0;
int next = 0;
Queue<TreeNode> queue = new LinkedList<>();
int max = Integer.MIN_VALUE;
if(root != null){
queue.offer(root);
current = 1;
}
//使用动态数组来存储结果
ArrayList<Integer> result = new ArrayList<>();
//层次遍历二叉树
while(!queue.isEmpty()){
//遍历每一层的节点遍历时需要减去当前成的计数器，计入子节点时需要加上下一层节点的个数
TreeNode node = queue.poll();
if(max < node.val){
max = node.val;
}
current--;
if(node.left != null){
queue.offer(node.left);
next++;
}
if(node.right != null){
queue.offer(node.right);
next++;
}
//m当每层遍历结束时需要对计数器和结果重新处理
if(current == 0){
current = next;
next = 0;
result.add(max);
max = Integer.MIN_VALUE;
}
}
return result;
}
}
冒泡：双指针
public static void BubbleSort(int[] arr) {
int temp;//定义一个临时变量
for(int i=0;i<arr.length-1;i++){//冒泡趟数
for(int j=0;j<arr.length-i-1;j++){//数组指针
if(arr[j+1]<arr[j]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
扫一扫
100万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
