目录
class Solution {
public int calPoints(String[] operations) {
//创建一个栈,来存储实际的得分
Stack<Integer> stack=new Stack<>();
//定义一个String类型的变量用于存储每一个记录的数据
String element="";
//定义一个int类型的变量,用于返回最后的结果
int result=0;
//使用for循环,拿到每一次记录的字符串
for (int i = 0; i <operations.length ; i++) {
//将每一次记录的字符串赋值给element
element=operations[i];
//使用switch判断每一次的字符串
switch (element){
//如果是C,就将栈顶元素移除
case "C":
stack.pop();
break;
//如果是D,就拿到栈顶元素,定义两个局部变量存储栈顶元素和新一轮得分(前一次得分的二倍),再讲栈顶元素和新一轮得分元素入栈
case "D":
int last=stack.pop();
int num=last*2;
stack.push(last);
stack.push(num);
break;
//如果是+,定义三个局部变量,存储两次出栈的元素以及他们相加的结果,再以第二次出栈的元素,第一次出栈的元素,相加的结果的顺序入栈
case "+":
int last1=stack.pop();
int last2=stack.pop();
int newNum=last1+last2;
stack.push(last2);
stack.push(last1);
stack.push(newNum);
break;
//除以上结果,记录的是得分,将字符串以int类型接收,再直接入栈
default:
int number=Integer.parseInt(element);
stack.push(number);
}
}
//对栈内的元素进行遍历输出,使用result存储最终的结果
while (!stack.isEmpty()){
result+=stack.pop();
}
//返回最后的结果
return result;
}
}1047. 删除字符串中的所有相邻重复项
class Solution {
public String removeDuplicates(String s) {
//创建一个栈,用于存储符合条件的字符
Stack<Character> stack = new Stack<>();
//对字符串进行遍历,取出每一个字符
for (int i = 0; i < s.length(); i++) {
//如果栈为空或者当前字符和栈顶元素不相同就直接入栈
if (stack.empty() || s.charAt(i) != stack.peek()) {
stack.push(s.charAt(i));
} else {
//如果当前字符和栈顶元素相同就会将相同元素出栈
stack.pop();
}
}
//使用stringbuffer存储字符
StringBuffer stringBuffer = new StringBuffer();
//遍历栈,并将栈中元素添加到stringbuffer中
while (!stack.empty()) {
stringBuffer.append(stack.pop());
}
//将stringbuffer逆序并且转换为string类型返回
return stringBuffer.reverse().toString();
}
}剑指 Offer 09. 用两个栈实现队列
import java.util.Stack;
public class CQueue {
//定义第一个栈用于做入队操作
Stack<Integer> stack1 = new Stack<>();
//定义第二个栈用于出队操作
Stack<Integer> stack2 = new Stack<>();
public CQueue() {
}
//入队
public void appendTail(int value) {
stack1.push(value);
}
//出队
public int deleteHead() {
if(stack2.isEmpty()){
if(!stack1.empty()){
//如果出队栈为空的话,判断入队栈不为空,就将入队栈的元素全部赋给出队栈
while (!stack1.empty()){
stack2.push(stack1.pop());
}
}
//出队栈为空,入队栈也为空,则返回-1
else return -1;
}
//出队栈中有元素,则直接出栈
return stack2.pop();
}
}面试题59 - II. 队列的最大值
import java.util.LinkedList;
import java.util.Queue;
class MaxQueue {
Queue<Integer> queue;
public MaxQueue() {
//创建队列
queue = new LinkedList<>();
}
public int max_value() {
//定义一个变量存储最大值
int mark = 0;
if (queue.isEmpty()) {
return -1;
}
for(int i:queue){
mark=Math.max(i, mark);
}
return mark;
}
public void push_back(int value) {
queue.offer(value);
}
public int pop_front() {
//如果队列为空直接返回-1,不为空直接出队并且返回
if (queue.isEmpty()) {
return -1;
} else return queue.poll();
}
}import java.util.LinkedList;
import java.util.Queue;
class MaxQueue {
Queue<Integer> queue;
LinkedList<Integer> linkedList ;
public MaxQueue() {
queue = new LinkedList<>();
linkedList=new LinkedList<>();
}
public int max_value() {
if (linkedList.isEmpty()) {
return -1;
}
return linkedList.peekFirst();
}
public void push_back(int value) {
queue.offer(value);
while (!linkedList.isEmpty()) {
if (linkedList.peekLast() < value) {
linkedList.pollLast();
}
else {
break;
}
}
linkedList.offerLast(value);
}
public int pop_front() {
if (queue.isEmpty()) {
return -1;
}
int value = queue.poll();
if (value == linkedList.peekFirst()) {
linkedList.pollFirst();
}
return value;
}
}第一种:
class Solution {
public int removeDuplicates(int[] nums) {
//定义一个treeSet集合
TreeSet<Integer> treeSet=new TreeSet<>();
for (int i = 0; i <nums.length; i++) {
//将数组中的每个元素遍历添加到集合中,treeset去重且底层能进行自然排序
treeSet.add(nums[i]);
}
//定义一个遍历,用于表示数组的索引
int index=0;
//使用迭代器遍历集合
Iterator<Integer>iterator=treeSet.iterator();
while(iterator.hasNext()){
//将集合中的元素赋值给原数组
nums[index]=iterator.next();
//索引自加
index++;
}
//返回集合的容量
return treeSet.size();
}
}第二种
class Solution {
public int removeDuplicates(int[] nums) {
//定义一个变量来记录最后不重复项的个数
int num=0;
//遍历数组
for (int i = 1; i < nums.length; i++) {
//如果遍历的当前项和上面定义的变量所指向的数据不相同,将将他的值赋给num+1指向的数据,并且num++
if(nums[i]!=nums[num]){
nums[num+1]=nums[i];
num++;
}
}
//返回不重复的个数
return num+1;
}
}27. 移除元素
import java.util.*;
public class Solution {
public int removeElement(int[] nums, int val) {
int [] newArr= Arrays.stream(nums)//将传过来的数组转换为流
.filter(item->item!=val)//使用该方法过滤掉与指定值相等的元素
.toArray();//将流转换为数组
for (int i = 0; i <newArr.length ; i++) {
//将新数组的元素赋值给旧数组
nums[i]=newArr[i];
}
//返回新数组的长度
return newArr.length;
}
public static void main(String[] args) {
Solution solution = new Solution();
}
}80. 删除有序数组中的重复项 II
class Solution {
public int removeDuplicates(int[] nums) {
int index =0;
int num=1;
for (int i = 1; i < nums.length ; i++) {
if(nums[i]!=nums[index]){
nums[index+1]=nums[i];
num=1;
index++;
}else if(num>=2){
continue;
}else {
nums[index+1]=nums[i];
num++;
index++;
}
}
return index+1;
}
}1. 两数之和
class Solution {
public int[] twoSum(int[] nums, int target) {
//遍历数组
for(int i=0;i<nums.length-1;i++){
for(int j=i+1;j<nums.length;j++){
//如果两个值相加结果等于预期结果
if((nums[i]+nums[j])==target){
//就将角标放入一个新数组并返回
return new int[]{i,j};
}
}
}
//没有符合条件的返回null
return null;
}
}9. 回文数
class Solution {
public boolean isPalindrome(int x) {
//将数值转为字符串
String num=Integer.toString(x);
//使用stringbuffer将字符串反转
String revNum=new StringBuffer(Integer.toString(x)).reverse().toString();
//返回对比的结果
return num.equals(revNum);
}
}20. 有效的括号
class Solution {
public boolean isValid(String s) {
//定义一个栈
Stack<String> stack = new Stack<>();
//遍历字符串
for (int i = 0; i < s.length(); i++) {
//用于存储当前的字符
String ss = "";
ss+=s.charAt(i);
//如果是左括号中的一个,就入栈,并且把ss重新变为空
if(ss.equals("[")||ss.equals("{")||ss.equals("(")){
stack.push(ss);
ss="";
}else if(stack.isEmpty()){
//如果是右括号,并且栈为空,直接返回false
return false;
}else {
//如果为右括号,从栈顶获取一个左括号再加上当前的括号,判断是否为有效括号,如果是就让栈顶的左括号出栈,并且将临时存储的字符串清空,如果不是,直接返回false
ss="";
ss+=stack.peek();
ss+=s.charAt(i);
if(ss.equals("()") || ss.equals("[]") || ss.equals("{}")){
stack.pop();
ss="";
}else
return false;
}
}
//返回判断栈是否为空的结果
return stack.isEmpty();
}
}
195
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
