每日算法十道

最近发现了一个挺厉害的人工智能学习网站，内容通俗易懂，风趣幽默，感兴趣的可以点击此链接进行查看：床长人工智能教程

 废话不多说，请看正文！

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;
    }
}