devbox
天景科技苑
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

初阶数据结构—算法的时间复杂度和空间复杂度

作者：天景科技苑 | 2024-08-02 17:37:44

赞

踩

初阶数据结构—算法的时间复杂度和空间复杂度

第一章：数据结构前言（Lesson 1）

1. 什么是数据结构？

数据结构 (Data Structure) 是计算机存储、组织数据的方式，指相互之间存在一种或多种特定关系的
数据元素的集合。

2. 什么是算法？

算法(Algorithm):就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。

第一章：算法的时间复杂度和空间复杂度（Lesson 2）

1. 算法效率

1.1 如何衡量一个算法的好坏
  1. long long Fib(int N)
  2. {
  3. 	if (N < 3)
  4. 		return 1;
  5.  
  6. 	return Fib(N - 1) + Fib(N - 2);
  7. }

斐波那契数列的递归实现方式非常简洁，但简洁一定好吗？那该如何衡量其好与坏呢？

1.2 算法的复杂度 
算法在编写成可执行程序后，运行时需要耗费时间资源和空间 ( 内存 ) 资源 。因此 衡量一个算法的好坏，一般 是从时间和空间两个维度来衡量的 ，即时间复杂度和空间复杂度。
时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。在计算机发展的早期，计算机的存储容量很小。所以对空间复杂度很是在乎。但是经过计算机行业的迅速发展，计算机的存储容量已经达到了很高的程度。所以我们如今已经不需要再特别关注一个算法的空间复杂度。

第二章：时间复杂度

2.1 时间复杂度概念

时间复杂度的定义：在计算机科学中， 算法的时间复杂度是一个函数 ，它定量描述了该算法的运行时间。一个算法执行所耗费的时间，从理论上说，是不能算出来的，只有你把你的程序放在机器上跑起来，才能知道。但是我们需要每个算法都上机测试吗？是可以都上机测试，但是这很麻烦，所以才有了时间复杂度这个分析方式。一个算法所花费的时间与其中语句的执行次数成正比例，算法中的基本操作的执行次数，为算法 的时间复杂度。
即：找到某条基本语句与问题规模 N 之间的数学表达式，就是算出了该算法的时间复杂度。 
  1. // 请计算一下Func1中++count语句总共执行了多少次？
  2. void Func1(int N)
  3. {
  4. 	int count = 0;
  5. 	for (int i = 0; i < N; ++i) {
  6. 		for (int j = 0; j < N; ++j)
  7. 			++count;
  8. 	}
  9.  
  10. 	for (int k = 0; k < 2 * N; ++k)
  11. 		++count;
  12.  
  13. 	int M = 10;
  14. 	while (M--)
  15. 		++count;

前面两个for循环的时间复杂度是N*N，第三个for循环的时间复杂度是2N，最后一个while循环的时间复杂度是10。最终的时间复杂度函数式：F(N)=N*N + 2*N + 10

实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这里我们使用大O的渐进表示法。

2.2 大O的渐进表示法

大O符号（Big O notation）：是用于描述函数渐进行为的数学符号。
推导大O阶方法：

  1. 用常数1取代运行时间中的所有加法常数。F(N)=N*N + 2*N + 10
  2. 在修改后的运行次数函数中，只保留最高阶项。N^2
  3. 如果最高阶项存在且不是1,则去除与这个项目相乘的常数。得到的结果就是大O阶。O(N^2)
 F(N) = N*N + 2*N + 10
N = 10F(N) = 130
N = 100F(N) = 10210
N = 1000F(N) = 1002010
O(N^2)
N = 10F(N) = 100
N = 100F(N) = 10000
N = 1000F(N) = 1000000

通过上面我们会发现大O的渐进表示法去掉了那些对结果影响不大的项，简洁明了的表示出了执行次数。当N越大，后面项对结果的影响就越小
另外有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)

例如：在一个长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

2.3 常见时间复杂度计算举例 

实例1：
  1. // 计算Func2的时间复杂度？
  2. void Func2(int N)
  3. {
  4. 	int count = 0;
  5. 	for (int k = 0; k < 2 * N; ++k)
  6. 		++count;
  7.  
  8. 	int M = 10;
  9. 	while (M--)
  10. 		++count;
  11.  
  12. 	printf("%d\n", count);
  13. }
  14. //时间复杂度函数式：F(N) = 2*N + 10；时间复杂度：O(N)

在分析算法的时间复杂度时，通常关注的是算法的增长趋势，而不是具体的常数因子。因此，当时间复杂度中出现类似2N和10N这样的情况时，它们都会被认为是线性增长的，即O(N)。

在大规模问题上，常数因子不再影响算法的增长趋势。例如，假设一个算法的时间复杂度是2N，而另一个是10N，如果输入规模为100时，第一个算法的执行时间是200个单位时间，而第二个算法的执行时间是1000个单位时间。尽管第二个算法的执行时间更长，但它们的增长率是一样的，都是线性增长。

因此，当我们分析算法的时间复杂度时，会将常数因子视为可以忽略的因素，只关注随着输入规模增长时，算法执行时间的增长趋势，而这种增长趋势决定了算法的时间复杂度。

实例2：
  1. // 计算Func3的时间复杂度？
  2. void Func3(int N, int M)
  3. {
  4. 	int count = 0;
  5. 	for (int k = 0; k < M; ++k)
  6. 		++count;
  7. 	
  8. 	for (int k = 0; k < N; ++k)
  9. 		++count;
  10. 	
  11. 	printf("%d\n", count);
  12. }
  13. //时间复杂度函数式：F(N) = M + N；时间复杂度：O(M+N)
  14. //M和N相互独立，某一项的增加和减少都会导致时间复杂度变化，所以不能省略其中一个

实例3：
  1. // 计算Func4的时间复杂度？
  2. void Func4(int N)
  3. {
  4. 	int count = 0;
  5. 	for (int k = 0; k < 100; ++k)
  6. 	{
  7. 		++count;
  8. 	}
  9. 	printf("%d\n", count);
  10. }
  11. //时间复杂度函数式：F(N) = 100；时间复杂度：O(1) - 代表常数次
  12. //常数时间复杂度表示算法的执行时间与输入规模无关，
  13. //因此不管执行一次还是一亿次，都可以认为是常数次

实例4：
  1. // 计算strchr的时间复杂度？
  2. const char * strchr ( const char * str, int character );
  3.  
  4. //实现
  5. while (*str)
  6. {
  7. 	if (*str == character)
  8. 		return str;
  9. 	else
  10. 		++str;
  11. }
  12. //该算法时间复杂度O(N)

在该长度为N数组中搜索一个数据x
最好情况：1次找到
最坏情况：N次找到
平均情况：N/2次找到
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)

实例5：
  1. // 计算BubbleSort的时间复杂度？
  2. void BubbleSort(int* a, int n)
  3. {
  4. 	assert(a);
  5. 	for (size_t end = n; end > 0; --end)
  6. 	{
  7. 		int exchange = 0;
  8. 		for (size_t i = 1; i < end; ++i)
  9. 		{
  10. 			if (a[i - 1] > a[i])
  11. 			{
  12. 				Swap(&a[i - 1], &a[i]);
  13. 				exchange = 1;
  14. 			}
  15. 		}
  16. 		if (exchange == 0)
  17. 			break;
  18. 	}
  19. }
  20. //时间复杂度函数式：F(N) = N*(N-1) / 2；时间复杂度：O(N^2)
  21. //第一轮：n - 1次
  22. //第二轮：n - 2次
  23. //第三轮：n - 3次
  24. //......
  25. //倒数第二轮：2次
  26. //倒数第一轮：1次
  27. //总共n-1轮
  28. //全部加起来就是等差数列。首项1，尾项n-1，项数(n-1轮)

实例6：
  1. // 计算BinarySearch的时间复杂度？
  2. int BinarySearch(int* a, int n, int x)
  3. {
  4. 	assert(a);
  5. 	int begin = 0;
  6. 	int end = n - 1;
  7. 	// [begin, end]：begin和end是左闭右闭区间，因此有=号
  8. 	while (begin <= end)
  9. 	{
  10. 		int mid = begin + ((end - begin) >> 1);
  11. 		if (a[mid] < x)
  12. 			begin = mid + 1;
  13. 		else if (a[mid] > x)
  14. 			end = mid - 1;
  15. 		else
  16. 			return mid;
  17. 	}
  18. 	return -1;
  19. }
  20. //时间复杂度函数式：F(N) = log_2 N；时间复杂度：O(logN)
  21. //每查找一次少一半，所以每次除以2。N/2/2/2.../2 = 1
  22. //反过来就是每次*2，（假设查找了x次），2^x = N
  23. //查找次数和输入规模的关系就是log_2 N = 1（2为底）

实例7：
  1. // 计算阶乘递归Fac的时间复杂度？
  2. long long Fac(size_t N)
  3. {
  4. 	if (0 == N)
  5. 		return 1;
  6.  
  7. 	return Fac(N - 1) * N;
  8. }
  9. //时间复杂度函数式：F(N) = N + 1；时间复杂度：O(N)
  10. //调用如下，每次函数调用内部固定执行if判断和递减操作，可视为O(1)            
  11. //Fac(N)
  12. //Fac(N-1)
  13. //Fac(N-2)
  14. //.......
  15. //Fac(2)
  16. //Fac(1)
  17. //Fac(0)

实例8：
  1. // 计算斐波那契递归Fib的时间复杂度？
  2. long long Fib(size_t N)
  3. {
  4. 	if (N < 3)
  5. 		return 1;
  6.  
  7. 	return Fib(N - 1) + Fib(N - 2);
  8. }
  9. 时间复杂度：O(2^N)
  10.  
  11. //调用如下
  12. //2^0	  Fib(N)
  13. //2^1     Fib(N-1) Fib(N-2)
  14. //2^2     Fib(N-2) Fib(N-3)  Fib(N-3) Fib(N-4)
  15. //..........
  16. //2^(n-4) Fib(4)
  17. //2^(n-3) Fib(3)
  18. //2^(n-2) Fib(2)
  19. //每一层都是上一层的2倍，就是一个等比为2的等比数列
  20. //通过下方错位相减法可得结果
  21. //FN(n)= 2^0+2^1+2^2+......+2^(n-4)+2^(n-3)+2^(n-2)           1式
  22. //2FN(n)=    2^1+2^2+......+2^(n-4)+2^(n-3)+2^(n-2) +2^(n-1)  2式
  23. //两边乘以公比2，再用2式减1式
  24. //FN(n)= 2^(n-1) - 1

第三章：空间复杂度

空间复杂度也是一个数学表达式，是对一个算法在运行过程中临时占用额外存储空间大小的量度。

空间复杂度不是程序占用了多少bytes的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。空间复杂度计算规则基本跟时间复杂度类似，也使用大O渐进表示法。

注意：函数运行时所需要的栈空间(存储参数、局部变量、一些寄存器信息等)在编译期间已经确定好了，因此空间复杂度主要通过函数在运行时候显式申请的额外空间来确定。

实例1：

  1. // 计算BubbleSort的空间复杂度？
  2. void BubbleSort(int* a, int n)
  3. {
  4. 	assert(a);
  5. 	for (size_t end = n; end > 0; --end)
  6. 	{
  7. 		int exchange = 0;
  8. 		for (size_t i = 1; i < end; ++i)
  9. 		{
  10. 			if (a[i - 1] > a[i])
  11. 			{
  12. 				Swap(&a[i - 1], &a[i]);
  13. 				exchange = 1;
  14. 			}
  15. 		}
  16. 		if (exchange == 0)
  17. 			break;
  18. 	}
  19. }
  20. //额外的空间复杂度是常量级别的，不随输入规模 n 的增加而增加
  21. //空间复杂度为 O(1)

实例2：

  1. // 计算Fibonacci的空间复杂度？
  2. // 返回斐波那契数列的前n项
  3. long long* Fibonacci(size_t n)
  4. {
  5. 	if (n == 0)
  6. 		return NULL;
  7.  
  8. 	long long* fibArray = (long long*)malloc((n + 1) * sizeof(long long));
  9. 	fibArray[0] = 0;
  10. 	fibArray[1] = 1;
  11.  
  12. 	for (int i = 2; i <= n; ++i)
  13. 		fibArray[i] = fibArray[i - 1] + fibArray[i - 2];
  14.  
  15. 	return fibArray;
  16. }
  17. //额外开辟了1个数组，元素个数为n+1
  18. 空间复杂度为 O(N)

实例3：

  1. // 计算阶乘递归Fac的空间复杂度？
  2. long long Fac(size_t N)
  3. {
  4. 	if (N == 0)
  5. 		return 1;
  6.  
  7. 	return Fac(N - 1) * N;
  8. }
  9. //递归调用了N次，开辟了N个栈帧，每个栈帧使用了常数个空间。
  10. //空间复杂度为O(N)

实例4：

  1. // 计算斐波那契递归Fib的空间复杂度？
  2. long long Fib(size_t N)
  3. {
  4. 	if (N < 3)
  5. 		return 1;
  6.  
  7. 	return Fib(N - 1) + Fib(N - 2);
  8. }
  9. //空间复杂度为O(N)

调用顺序为红色箭头→蓝色箭头→绿色箭头。总共开辟0~0-2层，即n-1层栈帧。每一层的栈帧是共用的。例如调用Fib(2)创建栈帧，返回后，栈帧销毁；再调用Fib(1)，再创建栈帧，返回，销毁。

时间是累积计算的，空间可以重复利用。所以空间复杂度为O(N)。

（下图证明栈帧可以共用）

作业：

1. 消失的数字

面试题 17.04. 消失的数字 - 力扣（LeetCode）

数组nums包含从0到n的所有整数，但其中缺了一个。请编写代码找出那个缺失的整数。你有办法在O(n)时间内完成吗？
示例 1：
输入：[3, 0, 1]
输出：2

示例 2：
输入：[9, 6, 4, 2, 3, 5, 7, 0, 1]
输出：8

  1. //方法一：异或
  2. int missingNumber(int* nums, int numsSize) {
  3.     int i = 0;
  4.     int ret = 0;//0异或任何数还是任何数
  5.     for (i = 0; i < numsSize; i++)//将nums数组所有元素异或
  6.         ret ^= nums[i];
  7.  
  8.     for (i = 0; i < numsSize + 1; i++)//因为nums数组少了个1个元素，在异或完整数组
  9.         ret ^= i;
  10.  
  11.     //相当于用完整数组和少1个元素的数组(nums数组)所有元素异或，最后相同的为0，
  12.     //剩下的就是少了的那个元素
  13.     return ret;
  14. }
  15.  
  16. //方法二：两数组相减
  17. int missingNumber(int* nums, int numsSize) {
  18.     // 计算从 0 到 n 的所有整数之和
  19.     int total = numsSize * (numsSize + 1) / 2;
  20.     // 计算 nums 中所有元素的和
  21.     int sum = 0;
  22.     for (int i = 0; i < numsSize; i++)
  23.         sum += nums[i];
  24.     // 返回缺失的整数
  25.     return total - sum;
  26. }
  27.  
  28. //方法三：排序后再比较
  29. //排序，依次查找。如果下一个数不是上一个数+1，那么上一个数+1就是消失的数字
  30. int missingNumber(int* nums, int numsSize) {
  31.     // 如果数组只有一个数，返回缺失的整数
  32.     if (numsSize == 1) 
  33.         return (nums[0] == 0) ? 1 : 0;
  34.     //当数组只包含一个元素时，我们需要确定缺失的整数是0还是1。
  35.     //因为对于一个只包含一个元素的数组而言，如果这个元素是0，则缺失的整数可能是1；
  36.     //如果这个元素不是0，则缺失的整数可能是0。
  37.  
  38.     // 如果数组中没有0，则0为缺失的整数
  39.     if (nums[0] != 0) 
  40.         return 0;
  41.  
  42.     // 遍历数组，检查是否存在断号
  43.     for (int i = 1; i < numsSize; ++i) 
  44.         if (nums[i] != nums[i - 1] + 1) 
  45.             // 如果下一个数不是上一个数+1，那么上一个数+1就是缺失的整数
  46.             return nums[i - 1] + 1;
  47.         
  48.     // 如果数组中没有缺失的整数，则返回数组最后一个数加一
  49.     return nums[numsSize - 1] + 1;
  50. }
  51.

2. 轮转数组

轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。
示例 1:
输入: nums = [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 :
    输入：nums = [-1, -100, 3, 99], k = 2
    输出：[3, 99, -1, -100]
    解释 :
    向右轮转 1 步 : [99, -1, -100, 3]
    向右轮转 2 步 : [3, 99, -1, -100]
 

  1. //方法一：3段逆序
  2. void reverse(int* left, int* right) {
  3. 	while (left < right) {
  4. 		int tmp = *left;
  5. 		*left = *right;
  6. 		*right = tmp;
  7. 		left++;
  8. 		right--;
  9. 	}
  10. }
  11.  
  12. void rotate(int* nums, int numsSize, int k) {
  13. 	k %= numsSize;
  14. 	reverse(nums, nums + numsSize - k - 1); // 逆序前n-k个数字 4 3 2 1 5 6 7
  15. 	reverse(nums + numsSize - k, nums + numsSize - 1); // 逆序后k个数字 4 3 2 1 7 6 5
  16. 	reverse(nums, nums + numsSize - 1); // 逆序整个数组 5 6 7 1 2 3 4
  17. }
  18.  
  19. //与上方逆序顺序不同
  20. void rotate(int* nums, int numsSize, int k) {
  21. 	k %= numsSize;
  22. 	reverse(nums, nums + numsSize - 1);//逆序整个数组 7 6 5 4 3 2 1
  23. 	reverse(nums, nums + k - 1);//逆序前k个元素 5 6 7 4 3 2 1
  24. 	reverse(nums + k, nums + numsSize - 1);//逆序后n-k个元素 5 6 7 1 2 3 4
  25. }
  26. //时间复杂度：前n-k+后k个是n，逆序整个数组是n，加起来是2n，所以O(n)
  27. //空间复杂度：O(1)
  28.  
  29.  
  30.  
  31. //方法二：拷贝
  32. void rotate(int* nums, int numsSize, int k) {
  33.     int* tmp = (int*)malloc(numsSize * sizeof(int));
  34.     k %= numsSize;
  35.     memcpy(tmp + k, nums, (numsSize - k) * sizeof(int));
  36.     memcpy(tmp, nums + (numsSize - k), k * sizeof(int));
  37.     memcpy(nums, tmp, numsSize * sizeof(int));
  38. }

3. 两个单身狗数

撞色搭配

  1. int* sockCollocation(int* sockets, int socketsSize, int* returnSize) {
  2.     int ret = 0;
  3.     for (int i = 0; i < socketsSize; i++)
  4.         ret ^= sockets[i];
  5.  
  6.  
  7.     // 找到 ret 中的某一位是1的位置。因为 ret 是两个唯一数的异或结果，
  8.     //这意味着这两个数在这一位上是不同的：一个是0，一个是1。
  9.     int pos = 0;
  10.     for (pos = 0; pos < 32; pos++)
  11.         if ((ret >> pos) & 1 == 1)
  12.             break;
  13.  
  14.  
  15.     int* result = (int*)malloc(sizeof(int) * 2);  
  16.     int dog1 = 0;
  17.     int dog2 = 0;
  18.     // 根据第 pos 位的值，将数组中的数分为两组。
  19.     //这样，两个唯一数会被分到不同的组，而其他成对出现的数也会被分到各自的组中。
  20.     for (int i = 0; i < socketsSize; i++) {
  21.         if ((sockets[i] >> pos) & 1 == 1)
  22.             dog1 ^= sockets[i];
  23.         else
  24.             dog2 ^= sockets[i];
  25.     }
  26.     result[0] = dog1;
  27.     result[1] = dog2;
  28.     *returnSize = 2;  
  29.     return result;   
  30. }

4. 给定一个整数sum，从有N个有序元素的数组中寻找元素a，b，使得a+b的结果最接近sum，最快的平均时间复杂度是（   ）

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案：A
此题目中，数组元素有序，所以a,b两个数可以分别从开始和结尾处开始搜，根据首尾元素的和是否大于sum,决定搜索的移动，整个数组被搜索一遍，就可以得到结果，所以最好时间复杂度为n

5. 下面算法的时间复杂度是（   ）

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案：A
此函数会被递归调用n - 1次，每次操作都是一次，所以时间复杂度为n

6. 设某算法的递推公式是T(n)=T(n-1)+n，T(0)=1，则求该算法中第n项的时间复杂度为（）

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案：A
T(n)
=T(n-1)+n
=T(n-2)+(n-1)+n
=T(n-3)+(n-2)+(n-1)+n
...
=T(0)+1+2+...+(n-2)+(n-1)+n
=1+1+2+...+(n-2)+(n-1)+n
从递推公式中可以看到，第n项的值需要从n-1开始递归，一直递归到0次结束，共递归了n-1次
所以时间复杂度为n

7. 分析以下函数的时间复杂度

  1. void fun(int n) {
  2.     int i = l;
  3.     while (i <= n)
  4.         i = i * 2;
  5. }

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案：D
此函数有一个循环，但是循环没有被执行n次，i每次都是2倍进行递增，所以循环只会被执行log2(n)次。

8. 分析以下程序的时间复杂度

  1. for (int i = 0; i < n; i++)
  2.     for (int j = 0; j < n; j++)
  3.         a[i][j] = i * j;

A. O(n)
B. O(n^2)
C. O(nlogn)
D. O(logn)

答案：B
程序有两次循环，每个循环都有n次操作，所以时间复杂度为n^2

9. 下列有关大O表示法的说法错误的是

A.大O表示法只是对程序执行时间的一个估算
B.大O表示法只保留最高阶项
C.大O表示法会保留一个系数来更准确的表示复杂度
D.大O表示法一般表示的是算法最差的运行时间

答案：C
大O是一个渐进表示法，不会去表示精确的次数，cpu的运算速度很快，估计精确的没有意义。

10. 分析以下函数的空间复杂度（   ）

  1. int** fun(int n) {
  2.     int** s = (int**)malloc(n * sizeof(int*));
  3.     while (n--)
  4.         s[n] = (int*)malloc(n * sizeof(int));
  5.     return s;
  6. }

A. O(n)
B. O(n^2)
C. O(1)
D. O(nlogn)

答案：B
此处开辟的是一个二维数组，数组有n行，每行分别有1,2,3,...n列，所以是n(n + 1)/2个元素空间，空间复杂度为n^2。（开辟了一个二维数组，每一行比上一行少一个元素）

11. 如果一个函数的内部中只定义了一个二维数组a[3][6]，请问这个函数的空间复杂度为（   ）

A. O(n)
B. O(n^2)
C. O(1)
D. O(m*n)

答案：C
函数内部数组的大小是固定的，不论函数运行多少次，所需空间都是固定大小的，因此空间复杂度为O(1)

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/天景科技苑/article/detail/919260
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号