标签：03 ListNode int Solution class null public 刷题
移除元素
class Solution {
public int removeElement(int[] nums, int val) {
int slow=0;
int fast=0;
for(fast=0;fast<nums.length;fast++)
{
if(nums[fast]!=val)
{
nums[slow++]=nums[fast];
}
}
return slow;
}
}
反转字符串
class Solution {
public void reverseString(char[] s) {
for(int left=0,right=s.length-1;left<=right;left++,right--)
{
char temp=s[left];
s[left]=s[right];
s[right]=temp;
}
}
}
替换空格
class Solution {
public String replaceSpace(String s) {
if(s==null) return null;
StringBuilder sb=new StringBuilder();
for(int i=0;i<s.length();i++)
{
if(s.charAt(i)==' ')
{
sb.append("%20");
}
else{
sb.append(s.charAt(i));
}
}
return sb.toString();
}
}
反转字符串里的单词
class Solution {
public String reverseWords(String s) {
StringBuilder sb=removeSpace(s);
reverse(sb,0,sb.length()-1);
reverseEach(sb);
return sb.toString();
}
public StringBuilder removeSpace(String s)
{
int left=0;
int right=s.length()-1;
while(s.charAt(left)==' ') left++;
while(s.charAt(right)==' ') right--;
StringBuilder sb=new StringBuilder();
while(left<=right)
{
char c=s.charAt(left);
if(c!=' '||sb.charAt(sb.length()-1)!=' ')
{
sb.append(c);
}
left++;
}
return sb;
}
public void reverse(StringBuilder sb,int left,int right)
{
while(left<=right){
char temp=sb.charAt(left);
sb.setCharAt(left,sb.charAt(right));
sb.setCharAt(right,temp);
left++;
right--;
}
}
public void reverseEach(StringBuilder sb)
{
int start=0;
int end=1;
while(start<sb.length())
{
while(end<sb.length()&&sb.charAt(end)!=' ')
{
end++;
}
reverse(sb,start,end-1);
start=end+1;
end=start+1;
}
}
}
反转链表
class Solution {
public ListNode reverseList(ListNode head) {
if(head==null) return null;
ListNode pre=null;
ListNode cur=head;
ListNode temp=null;
while(cur!=null)
{
temp=cur.next;
cur.next=pre;
pre=cur;
cur=temp;
}
return pre;
}
}
删除链表倒数第n个节点
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if(head==null) return null;
ListNode dummyNode=new ListNode(0);
dummyNode.next=head;
ListNode slow=dummyNode;
ListNode fast=dummyNode;
for(int i=0;i<n;i++)
{
fast=fast.next;
}
while(fast.next!=null)
{
slow=slow.next;
fast=fast.next;
}
slow.next=slow.next.next;
return dummyNode.next;
}
}
链表相交
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode l1=headA;
ListNode l2=headB;
while(l1!=l2)
{
l1=l1==null?headB:l1.next;
l2=l2==null?headA:l2.next;
}
return l1;
}
//假设相交（相交点8->8）：headA（1->2->3->8->8）： 3+2；headB（7->6->8->8）: 2+2。则 h1走3+2+2+2 = 9步（每一步访问：1->2->3->8->8->7->6->8->8）; h2走2+2+2+3 = 9步（每一步访问：7->6->8->8->1->2->3->8->8）。 看最后两步。 不相交最终满足 h1 == h2 == null
}
环形链表
public class Solution {
public ListNode detectCycle(ListNode head) {
if(head==null) return null;
ListNode slow=head;
ListNode fast=head;
while(fast!=null&&fast.next!=null)
{
slow=slow.next;
fast=fast.next.next;
if(slow==fast)
{
ListNode x=head;
ListNode y=slow;
while(x!=y)
{
x=x.next;
y=y.next;
}
return x;
}
}
return null;
}
}
有效的括号
class Solution {
public boolean isValid(String s) {
char[] m=s.toCharArray();
Stack<Character> stack=new Stack<>();
for(int i=0;i<m.length;i++)
{
if(m[i]=='{')
{
stack.push('}');
}
else if(m[i]=='[')
{
stack.push(']');
}
else if(m[i]=='(')
{
stack.push(')');
}
else if(stack.isEmpty()||stack.peek()!=m[i])
{
return false;
}
else{
stack.pop();
}
}
return stack.isEmpty();
}
}
删除字符串相邻重复项
class Solution {
public String removeDuplicates(String s) {
//Stack<Character> m=new Stack<>();
char[] m=s.toCharArray();
Stack<Character> stack=new Stack<>();
for(int i=0;i<m.length;i++)
{
if(!stack.isEmpty()&&m[i]==stack.peek())
{
stack.pop();
}
else{
stack.push(m[i]);
}
}
String str="";
while(!stack.isEmpty())
{
str=stack.pop()+str;
}
return str;
}
}
逆波兰表达式求值
class Solution {
public int evalRPN(String[] tokens) {
int n=tokens.length;
Stack<Integer> stack=new Stack<>();
for(int i=0;i<n;i++)
{
String token=tokens[i];
if(isNumber(tokens[i]))
{
stack.push(Integer.parseInt(token));
}
else{
int nums2=stack.pop();
int nums1=stack.pop();
switch(tokens[i])
{
case "+":
stack.push(nums1+nums2);
break;
case "-":
stack.push(nums1-nums2);
break;
case "*":
stack.push(nums1*nums2);
break;
case "/":
stack.push(nums1/nums2);
break;
}
}
}
return stack.peek();
}
public boolean isNumber(String token)
{
return !(token.equals("+")||token.equals("/")||token.equals("*")||token.equals("-"));
//return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
}
}
滑动窗口最大值
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
Deque<Integer> queue=new ArrayDeque<>();
int n=nums.length;
int[] res=new int[n-k+1];
int idx=0;
for(int i=0;i<nums.length;i++)
{
while(!queue.isEmpty()&&queue.peek()<(i-k+1))
{
queue.poll();
}
while(!queue.isEmpty()&&nums[queue.peekLast()]<nums[i])
{
queue.pollLast();
}
queue.offer(i);
if(i>=k-1)
{
res[idx++]=nums[queue.peek()];
}
}
return res;
}
}
前k个高频元素（Stream流）
class Solution {
public int[] topKFrequent(int[] nums, int k) {
Map<Integer, Integer> map = new HashMap<>();
for (int num : nums) {
map.put(num, map.getOrDefault(num, 0) + 1);
}
return map.entrySet()
.stream()
.sorted((m1, m2) -> m2.getValue() - m1.getValue())
.limit(k)
.mapToInt(Map.Entry::getKey)
.toArray();
}
}
标签：03,ListNode,int,Solution,class,null,public,刷题 来源： https://www.cnblogs.com/Liuyunsan/p/15861341.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。