leetcode刷题第一天

给你一个按 非递减顺序 排序的整数数组 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];
	}
}