01
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param numbers int整型一维数组
* @return int整型
*/
public int duplicate (int[] numbers) {
// write code here
int [] arr = new int[numbers.length];
for(int i=0;i<numbers.length;i++)
{
arr[numbers[i]]++;
if(arr[numbers[i]]==2){
return numbers[i];
}
}
return -1;
}
}
02
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param s string字符串
* @return string字符串
*/
public String replaceSpace (String s) {
StringBuilder str = new StringBuilder();
// write code here
for(int i=0;i<s.length();i++)
{
if(s.charAt(i)==' ')
str.append("%20");
else
str.append(s.charAt(i));
}
return str.toString();
}
}
知识点:
03
import java.util.ArrayList;
public class Solution {
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
ArrayList<Integer> list = new ArrayList<>();
ListNode tmp = listNode;
while(tmp!=null)
{
list.add(0,tmp.val);//每次都插入列表的头部,最终得到逆序列表
tmp = tmp.next;
}
return list;
}
}
或者递归:
import java.util.*;
public class Solution {
ArrayList<Integer> list = new ArrayList();
public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
if(listNode!=null){
printListFromTailToHead(listNode.next);
list.add(listNode.val);
}
return list;
}
}
04
import java.util.*;
import java.util.Stack;
public class Solution {
Stack<Integer> stack1 = new Stack<Integer>();
Stack<Integer> stack2 = new Stack<Integer>();
public void push(int node) {
stack1.push(node);
}
public int pop() {
while(!stack1.empty()){
stack2.push(stack1.pop());
}
int res = stack2.pop();
while(!stack2.empty()){
stack1.push(stack2.pop());
}
return res;
}
}
题解中的思路:注意最后从栈2中出栈的元素还得入栈1.
05
遍历:时间复杂度o(n)
import java.util.*;
public class Solution {
public int minNumberInRotateArray (int[] nums) {
// write code here
for(int i=0;i<nums.length-1;i++){
if(nums[i]>nums[i+1])
return nums[i+1];
}
return nums[0];
}
}
二分法:时间复杂度o(logn)
import java.util.*;
public class Solution {
public int minNumberInRotateArray (int[] nums) {
if(nums.length==0)
return 0;
int i=0, j=nums.length-1;
while(i<j)
{
int mid = (i+j)/2;
if(nums[mid]>nums[j]) i=mid+1;
else if(nums[mid]<nums[j]) j=mid;
else j--;//应对连续重复的情况
}
return nums[i];
}
}
06
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param n int整型
* @return int整型
*/
public int NumberOf1 (int n) {
int res = 0;
// write code here
for(int i=0;i<32;i++)
{
if((n&(1<<i))!=0)
res++;
}
return res;
}
}
07
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param n int整型 最大位数
* @return int整型一维数组
*/
public int[] printNumbers (int n) {
int c = (int)Math.pow(10,n);
int [] arr = new int[c-1];
// write code here
for(int i=1;i<c;i++)
{
arr[i-1] = i;
}
return arr;
}
}
08
import java.util.*;
/*
* public class ListNode {
* int val;
* ListNode next = null;
* public ListNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param head ListNode类
* @param val int整型
* @return ListNode类
*/
public ListNode deleteNode (ListNode head, int val) {
// write code here
//加入一个头结点
ListNode res = new ListNode(0);
res.next = head;
ListNode pre = res;
ListNode cur = head;
while(cur!=null){
if(cur.val==val){
pre.next=cur.next;
cur = cur.next;
}
else{
pre=cur;
cur=cur.next;
}
}
return res.next;
}
}
思路:重点是设置一个头结点,便于删除和返回。
09
解法:快慢指针,快指针先走K步,慢指针再开始走。那么当快指针走完的时候,慢指针刚好指向倒数第K个节点。
import java.util.*;
/*
* public class ListNode {
* int val;
* ListNode next = null;
* public ListNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定,请勿修改,直接返回方法规定的值即可
*
*
* @param pHead ListNode类
* @param k int整型
* @return ListNode类
*/
public ListNode FindKthToTail (ListNode pHead, int k) {
// write code here
ListNode fast = pHead;
ListNode slow = pHead;
for(int i=0;i<k;i++)
{
if(fast!=null) fast=fast.next;
else return null;//说明总长度不足K步,返回Null
}
//快慢指针一起走,快指针到尾,慢指针到倒数K
while(fast!=null){
fast=fast.next;
slow=slow.next;
}
return slow;
}
}
10
import java.util.Stack;
public class Solution {
public ListNode ReverseList(ListNode head) {
Stack<ListNode> stack = new Stack<>();
//把链表节点全部摘掉放到栈中
while(head!=null)
{
stack.push(head);
head = head.next;
}
if(stack.isEmpty()) return null;
//栈中的结点全部出栈,然后重新连成一个新的链表
ListNode res = stack.pop();
ListNode cur = res;
while(!stack.isEmpty()){
cur.next = stack.pop();
cur = cur.next;
}
//最后一个结点就是反转前的头结点,一定要让他的next等于空,否则会构成环
cur.next = null;
return res;
}
}