最近发现了一个挺厉害的人工智能学习网站,内容通俗易懂,风趣幽默,感兴趣的可以点击此链接进行查看:床长人工智能教程
废话不多说,请看正文!
1、数组中重复的数字
找出数组中重复的数字。
在一个长度为 n 的数组 nums 里的所有数字都在 0~n-1 的范围内。数
组中某些数字是重复的,但不知道有几个数字重复了,也不知道每个数字
重复了几次。请找出数组中任意一个重复的数字。
import java.util.*;
class Solution {
public int findRepeatNumber(int[] nums) {
Set s = new HashSet();
for(int i = 0; i < nums.length; i++){
if(s.contains(nums[i])){
return nums[i];
}else{
s.add(nums[i]);
}
}
return -1;
}
}
2、删除有序数组中的重复项
给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使每个元素
只出现一次 ,返回删除后数组的新长度。不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1)
额外空间的条件下完成。
时间复杂度:$O(n)
空间复杂度:$O(1)
class Solution {
public int removeDuplicates(int[] nums) {
if(nums == null || nums.length == 0){
return 0;
}
int slow = 0;
int fast = 1;
while(fast < nums.length){
if(nums[slow] != nums[fast]){
nums[++slow] = nums[fast];
}
fast++;
}
return slow + 1;
}
}
3、移除元素
给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于
val 的元素,并返回移除后数组的新长度。不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并原地修改输入数组。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。
时间复杂度:$O(n)
空间复杂度:$O(1)
class Main {
public int main(int[] nums, int val) {
if(nums.length == 0 || nums == null){
return 0;
}
int slow = 0;
int fast = 0;
while(fast < nums.length){
if(nums[fast] != val){
nums[slow++] = nums[fast];
}
fast++;
}
return slow;
}
}
4、移动零
给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保
持非零元素的相对顺序。
时间复杂度:$O(n)
空间复杂度:$O(1)
class Main {
public void main(int[] nums) {
if(nums.length == 0 || nums == null){
return;
}
int slow = 0;
int fast = 0;
while(fast < nums.length){
if(nums[fast] != 0){
nums[slow++] = nums[fast];
}
fast++;
}
for(int i=slow;i < nums.length;i++){
nums[i] = 0;
}
}
}
5、移除链表元素
给你一个链表的头节点 head 和一个整数 val ,请你删除链表中所有满
足 Node.val == val 的节点,并返回 新的头节点 。
时间复杂度:$O(n)
空间复杂度:$O(1)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode removeElements(ListNode head, int val) {
ListNode node = new ListNode();
node.next = head;
ListNode slow = node;
ListNode fast = head;
while(fast != null){
if(fast.val != val){
slow = fast;
}else{
slow.next = fast.next;
}
fast = fast.next;
}
return node.next;
}
}
6、删除排序链表中的重复元素
存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除所
有重复的元素,使每个元素 只出现一次 。返回同样按升序排列的结果链表。
时间复杂度:$O(n)
空间复杂度:$O(1)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
ListNode p1 = head;
while(p1 != null && p1.next != null) {
if(p1.val != p1.next.val) {
p1 = p1.next;
}else {
p1.next = p1.next.next;
}
}
return head;
}
}
7、删除排序链表中的重复元素 II
存在一个按升序排列的链表,给你这个链表的头节点 head ,请你删除链
表中所有存在数字重复情况的节点,只保留原始链表中 没有重复出现的
数字。返回同样按升序排列的结果链表。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode deleteDuplicates(ListNode head) {
if (head == null) {
return head;
}
ListNode node = new ListNode();
node.next = head;
ListNode p1 = node;
while (p1.next != null && p1.next.next != null) {
if (p1.next.val != p1.next.next.val) {
p1 = p1.next;
} else {
int temp = p1.next.val;
while (p1.next != null && p1.next.val == temp) {
p1.next = p1.next.next;
}
}
}
return node.next;
}
}
8、删除链表中的节点
请编写一个函数,用于 删除单链表中某个特定节点 。在设计函数时需要
注意,你无法访问链表的头节点 head ,只能直接访问 要被删除的节点 。
题目数据保证需要删除的节点 不是末尾节点 。
时间复杂度:$O(1)
空间复杂度:$O(1)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public void deleteNode(ListNode node) {
node.val = node.next.val;
node.next = node.next.next;
}
}
9、删除链表的节点
给定单向链表的头指针和一个要删除的节点的值,定义一个函数删除该节点。
返回删除后的链表的头节点。
时间复杂度:$O(n)
空间复杂度:$O(1)
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode deleteNode(ListNode head, int val) {
ListNode node = new ListNode();
node.next = head;
ListNode slow = node;
ListNode fast = head;
while(fast != null){
if(fast.val != val){
slow = fast;
fast = fast.next;
}else{
break;
}
}
slow.next = fast.next;
return node.next;
}
}
10、删除链表的倒数第 N 个结点
给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode() {}
* ListNode(int val) { this.val = val; }
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
* }
*/
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
if(head == null){
return null;
}
ListNode node = new ListNode();
node.next = head;
ListNode slow = node;
ListNode fast = node;
for(int i = 0; i <= n; i++){
fast = fast.next;
}
while(fast != null){
slow = slow.next;
fast = fast.next;
}
slow.next = slow.next.next;
return node.next;
}
}