算法复杂度和简单排序

最新推荐文章于 2024-08-10 07:14:43 发布

Sutter09

最新推荐文章于 2024-08-10 07:14:43 发布

阅读量135

点赞数 1

文章标签：算法排序算法数据结构

本文链接：https://blog.csdn.net/m0_52421468/article/details/128318885

版权

时间复杂度

一个操作如果和样本的数据量没有关系，每次都是固定时间内完成，叫做常数操作

int a[14] = 100;
包含了寻址和赋值操作，它是固定时间的，和数据量无关，它是一个常数操作

时间复杂度为一个算法流程中，反映常数操作数量的指标。常用O(big O)来表示。

在表达式中，只要高阶项，不要低阶项，也不要高阶项的系数。

一个算法流程除了时间复杂度外，还要看"常数项时间",当两个算法的时间复杂度相同时，比拼的就是它们的"常数项时间"了，用复杂度的系数估计并不准确，需要实际运行测试。

有些算法根据实际情况的不同可能复杂度也不一样，一律按最差的情况来估计。

额外空间复杂度

完成算法需要多少个额外变量，如果只需要几个变量，那么额外空间复杂度就是O(1)，如果需要额外开辟一个数组的空间，而且这个数组是和所处理的数据是等规模的，那么就是O(N)

冒泡排序

相邻元素两两比较，较小的放前面，大的放后面，将最大值一路带到最后面，一次循环完成一个位置的排序，循环N(总长)次即完成排序

void bubble_sort(std::vector<int>& nums)
{
	int len = nums.size();
	int i = 0, j = 0;
	for (i = 1; i < len; ++i) {// put the i_th biggest in place
		for (j = 0; j < len - i; ++j) {
			if (nums[j] > nums[j + 1]) {
				swap(nums[j],nums[j + 1]);
			}
		}
	}
}

选择排序

每次循环找到当前范围内的最大值，循环完后放在当前范围最后的位置，即：第一次在N个数中找出第一个最大的数放在末尾，第二次找在N-1个数中最大的数

void select_sort(std::vector<int>& nums)
{
	int len = nums.size();
	if(len == 0)
		return;
	int i = 0, j = 0;
	int max_index = 0;
	for (i = len; i > 0; --i) {// range every time
		max_index = 0;
		for (j = 0; j < i; ++j) {// find the biggest in range
			if (nums[j] > nums[max_index]) {
				max_index = j;// record the index
			}
		}
		swap(nums[j - 1], nums[max_index]);// put the biggest one in the last
	}
}

通过异或运算来交换两个整数的值

异或操作满足交换律和结合律

先将A和B异或存在第一个数中，再用第二个数(此时为B)通过异或操作取出A，A通过异或操作取出B(注意两个数不能相同)

void swap_xor(int& num1, int& num2)
{
	num1 = num1 ^ num2;// num1 = numA ^ numB
	num2 = num1 ^ num2;// num2 = numA ^ numB ^ numB = numA
	num1 = num1 ^ num2;// num1 = numA ^ numB ^ numA = numB
}

假如一组数中，有一个数出现了奇数次，其他所有数都出现偶数次，怎样分离出该数？要求时间复杂度O(N),额外空间复杂度O(1)

将所有数都异或起来，出现偶数次的数会两两抵消，最后结果就是出现奇数次的数。

int find_ocurr(std::vector<int> nums)
{
	int num_xor = 0;
	for(int num : nums){
		num_xor ^= num;
	}
	return num_xor;
}

假如一组数中，有两个数出现了奇数次，其他所有数都出现偶数次，怎样分离出这两个数？要求时间复杂度O(N),额外空间复杂度O(1)

假设这两个要求的数为A和B，我们仍然将所有数都异或，得到的是A^{B。设法从A}B中获取可用信息，求出A^B的最小不为0位(假设它为第k位)，我们通过第k位为0和第k位为1将这一组数分为两批，A和B则分别在其中的一批中，再通过第一问的方法即可求出A和B。

std::vector<int> find_ocurr_two(std::vector<int>& nums)
{
	std::vector<int> ocurr_two;
	int num_xor = 0;
	for(int num : nums) {
		num_xor ^= num;
	}// num_xor = A^B

	// find lowest bit
	int low_bit = num_xor & (~num_xor + 1);
	int xor1 = 0, xor2 = 0;
	for(int num : nums){
		if ((num & low_bit) != 0) {
			xor1 ^= num;
		} else {
			xor2 ^= num;
		}
	}
	ocurr_two.push_back(xor1);
	ocurr_two.push_back(xor2);
	return ocurr_two;
}

插入排序

从0位置开始，每次做到0-k位置上有序，将新加入的数逐个往前比较，直到它比前一个数大，做了N轮后排序完成。

void insert_sort(std::vector<int>& nums)
{
	int len = nums.size();
	if (len <= 2) {
		return;
	}
	int i = 0, j = 0;
	for (i = 1; i < len; ++i) {
		j = i;//保持前i个位置有序
		while (j >= 0 && nums[j] < nums[j - 1]) {
			swap(nums[j],nums[j - 1]);
			--j;
		}
	}
}