Algorithm Day 1 —— 旋转数组，两个数组的交集 II，反转字符串

题目一：给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。

示例 1:

输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右旋转 1 步: [7,1,2,3,4,5,6]
向右旋转 2 步: [6,7,1,2,3,4,5]
向右旋转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入: [-1,-100,3,99] 和 k = 2
输出: [3,99,-1,-100]
解释:
向右旋转 1 步: [99,-1,-100,3]
向右旋转 2 步: [3,99,-1,-100]

说明:

• 尽可能想出更多的解决方案，至少有三种不同的方法可以解决这个问题。
• 要求使用空间复杂度为 O(1) 的原地算法。

Java实现

// 方法一：循环移动
class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n;
        for(int i = 0; i < k; i++) {
            int temp = nums[n - 1];
            for(int j = n-1; j > 0; j--) {
                nums[j] = nums[j-1];
            }
            nums[0] = temp;
        }
    }
}
// 方法二：使用 ^ 操作
/*
* 这种方式会超时，但是值得注意的是交换两个数的位置的方法
* todo: 分析时间复杂度
* a = a ^ b
* b = b ^ a
* a = a ^ b
*/
class Solution {
    public void rotate(int[] nums, int k) {
        int n = nums.length;
        k = k % n;
        for(int i = 0; i < k; i++) {
            for(int j = n-1; j > 0; j--) {
                nums[j-1] = nums[j-1] ^ nums[j];
                nums[j] = nums[j] ^ nums[j-1];
                nums[j-1] = nums[j-1] ^ nums[j];
            }
        }
    }
}

Go语言实现

func rotate(nums []int, k int)  {
    n := len(nums)
    k = k % n
    for i := 0; i < k; i++ {
        for j := n - 1; j > 0; j-- {
            nums[j-1], nums[j] = nums[j], nums[j-1]
        }
    }
}

题目二：两个数组的交集 II
给定两个数组，编写一个函数来计算它们的交集。

示例 1:

输入: nums1 = [1,2,2,1], nums2 = [2,2]
输出: [2,2]

示例 2:

输入: nums1 = [4,9,5], nums2 = [9,4,9,8,4]
输出: [4,9]

说明：

• 输出结果中每个元素出现的次数，应与元素在两个数组中出现的次数一致。
• 我们可以不考虑输出结果的顺序。

进阶:

• 如果给定的数组已经排好序呢？你将如何优化你的算法？
• 如果 nums1 的大小比 nums2 小很多，哪种方法更优？
• 如果 nums2 的元素存储在磁盘上，磁盘内存是有限的，并且你不能一次加载所有的元素到内存中，你该怎么办？

Java实现

class Solution {
    public int[] intersect(int[] nums1, int[] nums2) {
        
        int len = nums1.length;
        
        if(nums1.length > nums2.length) {
            int num[] = nums1;
            nums1 = nums2;
            nums2 = num;
            len = nums2.length;
        } 
        int res[] = new int[len];
        int index = 0;
        for(int i = 0; i < nums1.length; i++) {
            for(int j = 0; j < nums2.length; j++) {
                if(nums1[i] == nums2[j]) {
                    res[index] = nums1[i];
                    nums2[j] = Integer.MAX_VALUE;
                    index++;
                    break;
                }
            }
        }
        return Arrays.copyOfRange(res, 0, index);        
    }   
}

题目三：反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：

输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]

示例 2：

输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

Java实现

//方法一：两次循环
class Solution {
    public void reverseString(char[] s) {
        int len = s.length;
        for(int i = 0; i < len - 1; i++) {
            char temp = s[len - 1];
            for(int j = len - 1; j > i; j--) {
                s[j] = s[j - 1];
            }
            s[i] = temp;
        }
    }
}
//方法二：一次循环
class Solution {
    public void reverseString(char[] s) {
        int len = s.length;
        for(int i = 0, j = len - 1; i < j; i++, j--) {
            char temp = s[i];
            s[i] = s[j];
            s[j] = temp;
        }
    }
}

Go实现

func reverseString(s []byte)  {
    
    for i := 0; i < len(s) - 1; i++ {
        for j := len(s) - 1; j > i; j-- {
            s[j - 1], s[j] = s[j], s[j - 1]
        }
    }
}