程序博客网 > linux wine官网

15道使用频率极高的基础算法题（完整代码实现）

来源：互联网 发布：linux wine官网 编辑：程序博客网 时间：2024/05/16 10:47
15道常见的基础算法题：
1、合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;
2、合并两个已经排序的单链表;
3、倒序打印一个单链表; 
4、给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;
5、找到链表倒数第K个节点;
6、反转单链表;
7、通过两个栈实现一个队列;
8、二分查找;
9、快速排序;
10、获得一个int型的数中二进制中的个数;
11、输入一个数组，实现一个函数，让所有奇数都在偶数前面;
12、判断一个字符串是否是另一个字符串的子串;
13、把一个int型数组中的数字拼成一个串，这个串代表的数字最小;
14、输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;
15、输入两个链表，找到它们第一个公共节点;
  1. //链表节点
  2. struct NodeL 
  3. {
  4. int value;
  5. NodeL* next;
  6. NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
  7. }; 
  8. //二叉树节点
  9. struct NodeT
  10. {
  11. int value;
  12. NodeT* left;
  13. NodeT* right;
  14. NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
  15. };
复制代码

1、合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素;

合并排序一般的思路都是创建一个更大数组C，刚好容纳两个数组的元素，先是一个while循环比较，将其中一个数组A比较完成，将另一个数组B中所有的小于前一个数组A的数及A中所有的数按顺序存入C中，再将A中剩下的数存入C中，但这里是已经有一个数组能存下两个数组的全部元素，就不用在创建数组了，但只能从后往前面存，从前往后存，要移动元素很麻烦。

  1. //合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素
  2. void MergeArray(int a[],int alen,int b[],int blen)
  3. {
  4. int len=alen+blen-1; 
  5. alen--;
  6. blen--;
  7. while (alen>=0 && blen>=0)
  8. {
  9. if (a[alen]>b[blen])
  10. {
  11. a[len--]=a[alen--];
  12. }else{
  13. a[len--]=b[blen--]; 
  14. }
  15. }

  17. while (alen>=0)
  18. {
  19. a[len--]=a[alen--];
  20. } 
  21. while (blen>=0)
  22. {
  23. a[len--]=b[blen--];
  24. } 
  25. }

  27. void MergeArrayTest()
  28. {
  29. int a[]={2,4,6,8,10,0,0,0,0,0};
  30. int b[]={1,3,5,7,9};
  31. MergeArray(a,5,b,5);
  32. for (int i=0;i<sizeof(a)/sizeof(a[0]);i++)
  33. {
  34. cout<<a[i]<<" ";
  35. }
  36. }
复制代码

2、合并两个单链表;

合并链表和合并数组，我用了大致相同的代码，就不多少了，那本书用的是递归实现。

  1. //链表节点
  2. struct NodeL 
  3. {
  4. int value;
  5. NodeL* next;
  6. NodeL(int value_=0,NodeL* next_=NULL):value(value_),next(next_){}
  7. }; 

  9. //合并两个单链表
  10. NodeL* MergeList(NodeL* head1,NodeL* head2)
  11. {
  12. if (head1==NULL)
  13. return head2;
  14. if (head2==NULL)
  15. return head1;

  17. NodeL* head=NULL; 
  18. if (head1->value<head2->value)
  19. {
  20. head=head1;
  21. head1=head1->next;
  22. }else{
  23. head=head2;
  24. head2=head2->next;
  25. }
  26. NodeL* tmpNode=head;
  27. while (head1 && head2)
  28. {
  29. if (head1->value<head2->value)
  30. {
  31. head->next=head1;
  32. head1=head1->next;
  33. }else{
  34. head->next=head2;
  35. head2=head2->next;
  36. }
  37. head=head->next;
  38. }
  39. if (head1)
  40. {
  41. head->next=head1;
  42. }
  43. if (head2)
  44. {
  45. head->next=head2;
  46. } 
  47. return tmpNode;
  48. }

  50. void MergeListTest()
  51. {
  52. NodeL* head1=new NodeL(1);
  53. NodeL* cur=head1;
  54. for (int i=3;i<10;i+=2)
  55. {
  56. NodeL* tmpNode=new NodeL(i);
  57. cur->next=tmpNode;
  58. cur=tmpNode;
  59. }
  60. NodeL* head2=new NodeL(2);
  61. cur=head2;
  62. for (int i=4;i<10;i+=2)
  63. {
  64. NodeL* tmpNode=new NodeL(i);
  65. cur->next=tmpNode;
  66. cur=tmpNode;
  67. }
  68. NodeL* head=MergeList(head1,head2);
  69. while (head)
  70. {
  71. cout<<head->value<<" ";
  72. head=head->next;
  73. }
  74. }
复制代码

3、倒序打印一个单链表;

递归实现，先递归在打印就变成倒序打印了，如果先打印在调用自己就是顺序打印了。

  1. //倒序打印一个单链表
  2. void ReversePrintNode(NodeL* head)
  3. {
  4. if (head)
  5. {
  6. ReversePrintNode(head->next);
  7. cout<<head->value<<endl;
  8. } 
  9. } 
  10. void ReversePrintNodeTest()
  11. {
  12. NodeL* head=new NodeL();
  13. NodeL* cur=head;
  14. for (int i=1;i<10;i++)
  15. {
  16. NodeL* tmpNode=new NodeL(i);
  17. cur->next=tmpNode;
  18. cur=tmpNode;
  19. }
  20. ReversePrintNode(head);
  21. }
复制代码

4、给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点;

删除节点的核心还是将这个节点的下一个节点，代替当前节点。

  1. //给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点
  2. void DeleteNode(NodeL* head,NodeL* delNode)
  3. {
  4. if (!head || !delNode)
  5. {
  6. return;
  7. }

  9. if (delNode->next!=NULL)//删除中间节点
  10. {
  11. NodeL* next=delNode->next;
  12. delNode->next=next->next;
  13. delNode->value=next->value;
  14. delete next;
  15. next=NULL;
  16. }else if (head==delNode)//删除头结点
  17. {
  18. delete delNode;
  19. delNode=NULL;
  20. *head=NULL;
  21. }else//删除尾节点，考虑到delNode不在head所在的链表上的情况
  22. {
  23. NodeL* tmpNode=head;
  24. while (tmpNode && tmpNode->next!=delNode)
  25. {
  26. tmpNode=tmpNode->next;
  27. }
  28. if (tmpNode!=NULL)
  29. {
  30. delete delNode;
  31. delNode=NULL;
  32. tmpNode->next=NULL;
  33. }
  34. }
  35. }

  37. void DeleteNodeTest()
  38. {
  39. int nodeCount=10;
  40. for (int K=0;K<nodeCount;K++)
  41. {
  42. NodeL* head=NULL;
  43. NodeL* cur=NULL;
  44. NodeL* delNode=NULL;
  45. for (int i=0;i<nodeCount;i++)
  46. {
  47. NodeL* tmpNode=new NodeL(i);
  48. if (i==0)
  49. {
  50. cur=head=tmpNode;
  51. }else{
  52. cur->next=tmpNode;
  53. cur=tmpNode; 
  54. }
  55. if (i==K)
  56. {
  57. delNode=tmpNode;
  58. } 
  59. }
  60. DeleteNode(head,delNode) ;
  61. } 
  62. }
复制代码

5、找到链表倒数第K个节点;

通过两个指针，两个指针都指向链表的开始，一个指针先向前走K个节点，然后再以前向前走，当先走的那个节点到达末尾时，另一个节点就刚好与末尾节点相差K个节点。

  1. //找到链表倒数第K个节点
  2. NodeL* FindKthToTail(NodeL* head,unsigned int k)
  3. {
  4. if(head==NULL || k==0)
  5. return NULL;
  6. NodeL* tmpNode=head;
  7. for (int i=0;i<k;i++)
  8. {
  9. if (tmpNode!=NULL)
  10. {
  11. tmpNode=tmpNode->next;
  12. }else{
  13. return NULL;
  14. } 
  15. }
  16. NodeL* kNode=head;
  17. while (tmpNode!=NULL)
  18. {
  19. kNode=kNode->next;
  20. tmpNode=tmpNode->next;
  21. }
  22. return kNode;
  23. }

  25. void FindKthToTailTest()
  26. {
  27. int nodeCount=10;
  28. for (int K=0;K<nodeCount;K++)
  29. {
  30. NodeL* head=NULL;
  31. NodeL* cur=NULL; 
  32. for (int i=0;i<nodeCount;i++)
  33. {
  34. NodeL* tmpNode=new NodeL(i);
  35. if (i==0)
  36. {
  37. cur=head=tmpNode;
  38. }else{
  39. cur->next=tmpNode;
  40. cur=tmpNode; 
  41. }
  42. }
  43. NodeL* kNode=FindKthToTail(head,K+3) ;
  44. if (kNode)
  45. {
  46. cout<<"倒数第 "<<K+3<<" 个节点是："<<kNode->value<<endl;
  47. }else{
  48. cout<<"倒数第 "<<K+3<<" 个节点不在链表中" <<endl;
  49. }
  50. } 
  51. }
复制代码

6、反转单链表;

按顺序一个个的翻转就是了。

  1. //反转单链表
  2. NodeL* ReverseList(NodeL* head)
  3. {
  4. if (head==NULL)
  5. {
  6. return NULL;
  7. }
  8. NodeL* reverseHead=NULL;
  9. NodeL* curNode=head;
  10. NodeL* preNode=NULL;
  11. while (curNode!=NULL)
  12. {
  13. NodeL* nextNode=curNode->next;
  14. if (nextNode==NULL)
  15. reverseHead=curNode; 

  17. curNode->next=preNode;
  18. preNode=curNode;
  19. curNode=nextNode;
  20. }
  21. return reverseHead;
  22. }

  24. void ReverseListTest()
  25. {
  26. for (int K=0;K<=10;K++)
  27. {
  28. NodeL* head=NULL;
  29. NodeL* cur=NULL; 
  30. for (int i=0;i<K;i++)
  31. {
  32. NodeL* tmpNode=new NodeL(i);
  33. if (i==0)
  34. {
  35. cur=head=tmpNode;
  36. }else{
  37. cur->next=tmpNode;
  38. cur=tmpNode; 
  39. }
  40. }

  42. cur=ReverseList( head);
  43. while (cur)
  44. {
  45. cout<<cur->value<<" ";
  46. cur=cur->next;
  47. }
  48. cout<<endl;
  49. }
  50. cout<<endl;
  51. }
复制代码

7、通过两个栈实现一个队列;

直接上代码

  1. //通过两个栈实现一个队列
  2. template<typename T>
  3. class CQueue
  4. {
  5. public:
  6. void push(const T& val)
  7. {
  8. while (s2.size()>0)
  9. {
  10. s1.push(s2.top());
  11. s2.pop();
  12. }
  13. s1.push(val);
  14. }
  15. void pop()
  16. { 
  17. while (s1.size()>0)
  18. {
  19. s2.push(s1.top());
  20. s1.pop();
  21. }
  22. s2.pop();
  23. }

  25. T& front()
  26. { 
  27. while (s1.size()>0)
  28. {
  29. s2.push(s1.top());
  30. s1.pop();
  31. }
  32. return s2.top();
  33. }
  34. int size()
  35. {
  36. return s1.size()+s2.size();
  37. }
  38. private:
  39. stack<T> s1;
  40. stack<T> s2;
  41. };

  43. void CQueueTest()
  44. {
  45. CQueue<int> q;
  46. for (int i=0;i<10;i++)
  47. {
  48. q.push(i);
  49. }
  50. while (q.size()>0)
  51. {
  52. cout<<q.front()<<" ";
  53. q.pop();
  54. }
  55. }
复制代码

8、二分查找;

二分查找记住几个要点就行了，代码也就那几行，反正我现在是可以背出来了，start=0，end=数组长度-1，while(start<=end)，注意溢出。

  1. //二分查找
  2. int binarySearch(int a[],int len,int val)
  3. {
  4. int start=0;
  5. int end=len-1;
  6. int index=-1;
  7. while (start<=end)
  8. {
  9. index=start+(end-start)/2;
  10. if (a[index]==val)
  11. {
  12. return index;
  13. }else if (a[index]<val)
  14. {
  15. start=index+1;
  16. }else
  17. {
  18. end=index-1;
  19. }
  20. }
  21. return -1;
  22. }
复制代码

9、快速排序;

来自百度百科，说不清楚

  1. //快速排序
  2. //之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科
  3. void Qsort(int a[],int low,int high)
  4. {
  5. if(low>=high)
  6. {
  7. return;
  8. }
  9. int first=low;
  10. int last=high;
  11. int key=a[first];//用字表的第一个记录作为枢轴
  12. while(first<last)
  13. {
  14. while(first<last && a[last]>=key )--last;
  15. a[first]=a[last];//将比第一个小的移到低端
  16. while(first<last && a[first]<=key )++first;
  17. a[last]=a[first];//将比第一个大的移到高端
  18. }
  19. a[first]=key;//枢轴记录到位
  20. Qsort(a,low,first-1);
  21. Qsort(a,last+1,high);
  22. }

  24. void QsortTest()
  25. {
  26. int a[]={1,3,5,7,9,2,4,6,8,0};
  27. int len=sizeof(a)/sizeof(a[0])-1;
  28. Qsort(a,0,len); 
  29. for(int i=0;i<=len;i++)
  30. {
  31. cout<<a[i]<<" ";
  32. } 
  33. cout<<endl;
  34. }
复制代码

10、获得一个int型的数中二进制中的个数;

核心实现就是while (num= num & (num-1))，通过这个数和比它小1的数的二进制进行&运算，将二进制中1慢慢的从后往前去掉，直到没有。

  1. //获得一个int型的数中二进制中1的个数
  2. int Find1Count(int num)
  3. {
  4. if (num==0)
  5. {
  6. return 0;
  7. }
  8. int count=1;
  9. while (num= num & (num-1))
  10. {
  11. count++;
  12. }
  13. return count;
  14. }
复制代码

11、输入一个数组，实现一个函数，让所有奇数都在偶数前面;

两个指针，一个从前往后，一个从后往前，前面的指针遇到奇数就往后走，后面的指针遇到偶数就往前走，只要两个指针没有相遇，就奇偶交换。

  1. //输入一个数组，实现一个函数，让所有奇数都在偶数前面
  2. void RecordOddEven(int A[],int len)
  3. {
  4. int i=0,j=len-1;
  5. while (i<j)
  6. {
  7. while (i<len && A[i]%2==1) 
  8. i++; 

  10. while (j>=0 && A[j]%2==0) 
  11. j--; 

  13. if (i<j)
  14. {
  15. A[i]^=A[j]^=A[i]^=A[j]; 
  16. }
  17. }
  18. }

  20. void RecordOddEvenTest()
  21. {
  22. int A[]={1,2,3,4,5,6,7,8,9,0,11};
  23. int len=sizeof(A)/sizeof(A[0]);
  24. RecordOddEven( A , len);
  25. for (int i=0;i<len;i++)
  26. {
  27. cout<<A[i]<<" ";
  28. }
  29. cout<<endl;
  30. for (int i=0;i<len;i++)
  31. {
  32. A[i]=2;
  33. }
  34. RecordOddEven( A , len);
  35. for (int i=0;i<len;i++)
  36. {
  37. cout<<A[i]<<" ";
  38. }
  39. cout<<endl;
  40. for (int i=0;i<len;i++)
  41. {
  42. A[i]=1;
  43. }
  44. RecordOddEven( A , len);
  45. for (int i=0;i<len;i++)
  46. {
  47. cout<<A[i]<<" ";
  48. }
  49. }
复制代码

12、判断一个字符串是否是另一个字符串的子串;

我这里就是暴力的对比

  1. //判断一个字符串是否是另一个字符串的子串
  2. int substr(const char* source,const char* sub)
  3. {
  4. if (source==NULL || sub==NULL)
  5. {
  6. return -1;
  7. }
  8. int souLen=strlen(source);
  9. int subLen=strlen(sub);
  10. if (souLen<subLen)
  11. {
  12. return -1;
  13. }

  15. int cmpCount=souLen-subLen;
  16. for (int i=0;i<=cmpCount;i++)
  17. {
  18. int j=0;
  19. for (;j<subLen;j++)
  20. {
  21. if (source[i+j]!=sub[j])
  22. {
  23. break;
  24. }
  25. }
  26. if (j==subLen)
  27. {
  28. return i ;
  29. }
  30. }
  31. return -1;
  32. }
复制代码

13、把一个int型数组中的数字拼成一个串，这个串代表的数字最小;

先将数字转换成字符串存在数组中，在通过qsort排序，在排序用到的比较函数中，将要比较的两个字符串进行组合，如要比较的两个字符串分别是A,B，那么组合成，A+B，和B+A，在比较A+B和B+A，返回strcmp(A+B, B+A)，经过qsort这么一排序,数组就变成从小到大的顺序了，组成的数自然是最小的。

  1. //把一个int型数组中的数字拼成一个串，是这个串代表的数组最小
  2. #define MaxLen 10 
  3. int Compare(const void* str1,const void* str2)
  4. {
  5. char cmp1[MaxLen*2+1];
  6. char cmp2[MaxLen*2+1];
  7. strcpy(cmp1,*(char**)str1);
  8. strcat(cmp1,*(char**)str2);

  10. strcpy(cmp2,*(char**)str2);
  11. strcat(cmp2,*(char**)str1);
  12. return strcmp(cmp1,cmp2);
  13. } 
  14. void GetLinkMin(int a[],int len)
  15. {
  16. char** str=(char**)new int[len];
  17. for (int i=0;i<len;i++)
  18. {
  19. str[i]=new char[MaxLen+1];
  20. sprintf(str[i],"%d",a[i]); 
  21. }

  23. qsort(str,len,sizeof(char*),Compare);
  24. for (int i=0;i<len;i++)
  25. {
  26. cout<<str[i]<<" ";
  27. delete[] str[i] ;
  28. }
  29. delete[] str;
  30. } 
  31. void GetLinkMinTest()
  32. {
  33. int arr[]={123,132,213,231,321,312};
  34. GetLinkMin(arr,sizeof(arr)/sizeof(int));
  35. }
复制代码

14、输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）;

递归实现，只要某个节点的两个子节点都不为空，就左右交换，让左子树交换，让右子树交换。

  1. struct NodeT
  2. {
  3. int value;
  4. NodeT* left;
  5. NodeT* right;
  6. NodeT(int value_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
  7. };

  9. //输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）
  10. void TreeClass(NodeT* root)
  11. {
  12. if( root==NULL || (root->left==NULL && root->right==NULL) ) 
  13. return; 
  14. NodeT* tmpNode=root->left;
  15. root->left=root->right;
  16. root->right=tmpNode;
  17. TreeClass(root->left);
  18. TreeClass(root->right); 
  19. }

  21. void PrintTree(NodeT* root)
  22. {
  23. if(root)
  24. {
  25. cout<<root->value<<" ";
  26. PrintTree(root->left);
  27. PrintTree(root->right);
  28. } 
  29. }

  31. void TreeClassTest()
  32. {
  33. NodeT* root=new NodeT(8);
  34. NodeT* n1=new NodeT(6);
  35. NodeT* n2=new NodeT(10);
  36. NodeT* n3=new NodeT(5);
  37. NodeT* n4=new NodeT(7);
  38. NodeT* n5=new NodeT(9);
  39. NodeT* n6=new NodeT(11);
  40. root->left=n1;
  41. root->right=n2;
  42. n1->left=n3;
  43. n1->right=n4;
  44. n2->left=n5;
  45. n2->right=n6;
  46. PrintTree(root);
  47. cout<<endl;
  48. TreeClass( root );
  49. PrintTree(root);
  50. cout<<endl;
  51. }
复制代码

15、输入两个链表，找到它们第一个公共节点;

如果两个链表有公共的节点，那么第一个公共的节点及往后的节点都是公共的。从后往前数N个节点（N=短链表的长度节点个数）,长链表先往前走K个节点（K=长链表的节点个数-N），这时两个链表都距离末尾N个节点，现在可以一一比较了，最多比较N次，如果有两个节点相同就是第一个公共节点，否则就没有公共节点。

  1. //输入两个链表，找到它们第一个公共节点
  2. int GetLinkLength(NodeL* head)
  3. { 
  4. int count=0;
  5. while (head)
  6. {
  7. head=head->next;
  8. count++;
  9. }
  10. return count;
  11. }

  13. NodeL* FindFirstEqualNode(NodeL* head1,NodeL* head2)
  14. {
  15. if (head1==NULL || head2==NULL)
  16. return NULL;
  17. int len1=GetLinkLength(head1);
  18. int len2=GetLinkLength(head2);
  19. NodeL* longNode;
  20. NodeL* shortNode;
  21. int leftNodeCount;
  22. if (len1>len2)
  23. {
  24. longNode=head1;
  25. shortNode=head2;
  26. leftNodeCount=len1-len2;
  27. }else{
  28. longNode=head2;
  29. shortNode=head1;
  30. leftNodeCount=len2-len1;
  31. }
  32. for (int i=0;i<leftNodeCount;i++)
  33. {
  34. longNode=longNode->next;
  35. }
  36. while (longNode && shortNode && longNode!=shortNode)
  37. {
  38. longNode=longNode->next;
  39. shortNode=shortNode->next;
  40. }
  41. if (longNode)//如果有公共节点，必不为NULL
  42. {
  43. return longNode;
  44. }
  45. return NULL; 
  46. }

  48. void FindFirstEqualNodeTest()
  49. {
  50. NodeL* head1=new NodeL(0);
  51. NodeL* head2=new NodeL(0);
  52. NodeL* node1=new NodeL(1);
  53. NodeL* node2=new NodeL(2);
  54. NodeL* node3=new NodeL(3);
  55. NodeL* node4=new NodeL(4);
  56. NodeL* node5=new NodeL(5);
  57. NodeL* node6=new NodeL(6);
  58. NodeL* node7=new NodeL(7);

  60. head1->next=node1;
  61. node1->next=node2;
  62. node2->next=node3;
  63. node3->next=node6;//两个链表相交于节点node6

  65. head2->next=node4;
  66. node4->next=node5;
  67. node5->next=node6;//两个链表相交于节点node6
  68. node6->next=node7;

  70. NodeL* node= FindFirstEqualNode(head1,head2);
  71. if (node)
  72. {
  73. cout<<node->value<<endl;
  74. }else{
  75. cout<<"没有共同节点"<<endl;
  76. }
  77. }
复制代码

转载：obroot

0 0
linux wine官网 linux wine官网
原创粉丝点击
热门IT博客
马踏棋盘贪心算法c马踏棋盘贪心算法c
sap软件费用sap软件费用
windows 挂载
知乎 长期熬夜保健品
mac免费软件推荐
星球大战顺序 知乎
如何打造淘宝店铺爆款
gps网络平台网址
淘宝上的康之家
淘宝美工详情页
skinspotlights软件
ubuntu更改启动顺序
海信ip906h安装软件
淘宝客服议价话术
app软件怎么用
asp网站挂php商城
僵尸生存指南知乎
比蓝墨云班好用的软件
软件测试原理
java给数组添加元素
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 木棉花的春天歌曲全部 木棉之旅阅读答案 秦木棉纪寒卿 木棉喜暖在南方 木棉花的花语是什么 木棉花有几种颜色 木棉花是什么颜色 木棉花象征着什么 关于木棉花的诗句 木棉花是什么颜色的 木棉花的花语 木棉春天卫生巾 木棉酒店怎么样 木棉是什么颜色 木棉花宾馆电话 金木棉阳光在线 木棉花的样子 木棉花的诗句 木棉是什么面料 木棉被子好吗 木棉春天主题曲 木棉枕头价格 木棉花开的春天 木棉花怎么吃 十字绣木棉花 木棉象征什么 网王之木棉花 木棉花开时间 白色木棉花图片 木棉花树苗 木棉花树 格林木棉花楼盘 格林木棉花 木棉花花期 木棉花开花时间 木棍 木棍拼音 木棍的拼音 小木棍 桃木棍 木棍图片

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里