这里写自定义目录标题
给你一个按 非递减顺序 排序的整数数组 nums,返回 每个数字的平方 组成的新数组,要求也按 非递减顺序 排序。进阶要求:时间复杂度为O(n).
题目分析
nums 是一个非递减数组,要想实现其平方后再排序,并且时间复杂度不能超过O(n)。将每个数据都进行平方很简单,且时间复杂度为O(n),那么我们要解决的就是平方之后的排序问题。
据我现在的知识储备,我所知道时间复杂度为O(n)的排序算法只有桶排序和O(log n)的快速排序我们这里就是用快速排序吧。
解法一:暴力求解
int* sortedSquares(int* nums, int numsSize, int* returnSize)
{
//int* arr = (int*)malloc(sizeof(int) * numsSize);
for (int i = 0; i < numsSize; ++i)
{
returnSize[i] = nums[i] * nums[i];
}
for (int i = 0; i < numsSize ; ++i)
{
//注意j越界问题,j可能没问题,但是要考虑j+1会超出数组范围
for (int j = 0; j < numsSize - i-1; ++j)
{
if (returnSize[j] > returnSize[j + 1])
{
int tmp = returnSize[j];
returnSize[j] = returnSize[j + 1];
returnSize[j + 1] = tmp;
}
}
}
//returnSize = arr;
return returnSize;
}
这么做排序算法用的是冒泡排序,时间复杂度为O(n^2).可以正确求解但是时间复杂度太高。
解法二:因为数组本来就是有序的一般情况下,平方之后还是按照原来的顺序进行排列,特殊情况是出现负数,这个时候要考虑绝对值问题。如果在排序之前直接将负数进行绝对值并将其放到其应该待的位置,然后再进行排序时间可能会节省一点。
int* sortedSquares(int* nums, int numsSize, int* returnSize)
{
for (int i = 0; ; )
{
if (nums[i] < 0&&i < numsSize)
{
nums[i] = abs(nums[i]);
int tmp = nums[i];
int j = i + 1;
while (tmp > nums[j])
{
nums[j - 1] = nums[j];
nums[j] = tmp;
++j;
}
continue;
}
break;
}
for (int i = 0; i < numsSize; ++i)
{
returnSize[i] = nums[i] * nums[i];
}
return returnSize;
这种解法得到的结果也正确,且它的时间复杂度取决于负数的个数,相对于解法一来说相对省时,但是遇到特殊情况,如数组中全是负数的情况就不可行了,时间复杂度会退化到O(n^2)。
解法三:双指针法
这种方法就特别的巧妙了,利用两个指针一个指向头,一个指向尾,头尾同时平方然后比较二者的大小,大的放在POS位置,其指针也前进或者后退一步,继续下一轮比较。当走过一轮的时候,刚好就排序完了,时间复杂度也为O(n);
int* sortedSquares(int* nums, int numsSize, int* returnSize) {
int* ans = (int *)malloc(sizeof(int) * numsSize);
//*returnSize = numsSize;
for (int i = 0, j = numsSize - 1, pos = numsSize - 1; i <= j;) {
if (nums[i] * nums[i] > nums[j] * nums[j])
{
ans[pos] = nums[i] * nums[i];
++i;
}
else
{
ans[pos] = nums[j] * nums[j];
--j;
}
--pos;
}
return ans;
}
双指针的实质其实是以空间换时间的原理,利用创建的数组将每次比较之后较大的数从后到前依次存储起来,这样就节省了时间,只需要比较一遍。
给你一个数组,将数组中的元素向右轮转 k 个位置,其中 k 是非负数。进阶: 尽可能想出更多的解决方案,至少有 三种 不同的方法可以解决这个问题。你可以使用空间复杂度为 O(1) 的 原地 算法解决这个问题吗?
解法一:循环移动
void rotate(int* nums, int numsSize, int k) {
for (int i = 0; i < k; ++i)
{
int tmp = nums[numsSize - 1];
for (int j = numsSize - 2; j >= 0; --j)
{
nums[j + 1] = nums[j];
}
nums[0] = tmp;
}
}
这种方法,是利用循环的方法,每一次移动一位(将最后一位挪到第一位,其余位置依次后移一位),连续操作三次即可得到结果。时间复杂度较高
解法二:收到上一道题的启发,我想试试双指针法对于此类题目有没有效果。
/*
void rotate(int* nums, int numsSize, int k)
{
int left = 0, right = numsSize - k;
for (int i = 0; i < k && right<numsSize; ++i)
{
int temp = nums[left];
nums[left] = nums[right];
nums[right] = temp;
left++;
right++;
}
}
本次做法有一定的问题,还需要进行更正,但是我还是坚持认为双指针法是可行的
*/
上述做法有一定的问题,还需要进行改正。
解法三:大循环法
用一个临时空间数组将后k个数据存下来,然后向后移动,再把存起来的数据放到前面。
int gcd(int a, int b) {
return b ? gcd(b, a % b) : a;
}
void swap(int* a, int* b) {
int t = *a;
*a = *b, *b = t;
}
void rotate(int* nums, int numsSize, int k) {
k = k % numsSize;
int count = gcd(k, numsSize);
for (int start = 0; start < count; ++start) {
int current = start;
int prev = nums[start];
do {
int next = (current + k) % numsSize;
swap(&nums[next], &prev);
current = next;
} while (start != current);
}
}
```c
void rotate(int* nums, int numsSize, int k)
{
int* tmp = (int*)malloc(sizeof(int) * (k));
for (int i = 0; i < k; ++i)
{
tmp[i] = nums[numsSize - 1 - i];
}
for (int i = 0; i < numsSize - k; ++i)
{
nums[numsSize - 1 - i] = nums[numsSize - 1 - k - i];
}
for (int i = 0; i < k; ++i)
{
nums[k - 1 - i] = tmp[i];
}
}