程序博客网 > 逆袭网络剧7第一集哇趣

链表的常见实现

来源：互联网 发布：逆袭网络剧7第一集哇趣 编辑：程序博客网 时间：2024/05/24 07:16

链表结点声明如下：

[cpp] view plain copy
  1. struct LinkList {  
  2.     int value;  
  3.     LinkList *next;  
  4. };  


以下是不带头结点的单链表的操作。

1. 根据输入建立单链表

将输入的节点插入到链表头部。

[cpp] view plain copy
  1. //根据输入建立单链表：链表头部插入  
  2. LinkList *BuildList() {  
  3.     LinkList *head = NULL;  
  4.     int data;  
  5.     int i = 0;  
  6.     while (scanf("%d", &data) != EOF) {  
  7.         //scanf("%d", &data);++i;  
  8.         LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));  
  9.         if (NULL == new_node) {  
  10.             fprintf(stderr, "malloc failed");  
  11.             return head;  
  12.         }  
  13.         new_node->value = data;  
  14.         if (head == NULL) {  
  15.             new_node->next = NULL;  
  16.             head = new_node;  
  17.         }  
  18.         else {  
  19.             new_node->next = head;  
  20.             head = new_node;  
  21.         }  
  22.     }  
  23.     return head;  
  24. }  

2. 链表插入操作

链表插入时注意当链表为空的情况。

（1）在链表头插入

[cpp] view plain copy
  1. //在链表头部插入节点  
  2. LinkList *InsertToHead(int value, LinkList *head) {  
  3.     LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));  
  4.     if (new_node == NULL) {  
  5.         fprintf(stderr, "malloc failed");  
  6.         return head;  
  7.     }  
  8.     new_node->value = value;  
  9.     new_node->next = NULL;  
  10.     if (head == NULL) {  
  11.         head = new_node;  
  12.     }  
  13.     else {  
  14.         new_node->next = head;  
  15.         head = new_node;  
  16.     }  
  17.     return head;  
  18. }  

（2）在链表尾部插入

[cpp] view plain copy
  1. //链表尾部插入节点  
  2. LinkList *InsertToTail(int value, LinkList *head) {  
  3.     LinkList *new_node = (LinkList *)malloc(sizeof(LinkList));  
  4.     if (new_node == NULL) {  
  5.         fprintf(stderr, "malloc failed");  
  6.         return head;  
  7.     }  
  8.     new_node->value = value;  
  9.     new_node->next = NULL;  
  10.   
  11.     if (head == NULL)  
  12.         head = new_node;  
  13.     else {  
  14.         LinkList *pnode = head;  
  15.         while (pnode->next != NULL)  
  16.             pnode = pnode->next;  
  17.         pnode->next = new_node;  
  18.     }  
  19.     return head;  
  20. }  

3. 链表的删除操作

注意当链表仅有一个节点时的删除。

[cpp] view plain copy
  1. //删除某节点  
  2. LinkList *DeletebyValue(int value, LinkList* head) {  
  3.     if (head == NULL)  
  4.         return head;  
  5.     LinkList *pToDelete = NULL;  
  6.     if (head->value == value) {  
  7.         pToDelete = head;  
  8.         head = head->next;  
  9.     }  
  10.     else {  
  11.         LinkList *p = head;  
  12.         while (p->next != NULL && p->next->value != value)  
  13.             p = p->next;  
  14.         if (p->next != NULL) {  
  15.             pToDelete = p->next;  
  16.             p->next = pToDelete->next;  
  17.         }  
  18.     }  
  19.     if (pToDelete != NULL) {  
  20.         free(pToDelete);  
  21.         pToDelete = NULL;  
  22.     }  
  23.     return head;  
  24. }  


4. 求单链表中结点的个数

注意检查链表是否为空。时间复杂度为O（n）。该操作不用特意检查链表是否为空，如下代码，链表为空会返回0。

[cpp] view plain copy
  1. unsigned int Length(LinkList *head) {  
  2.     unsigned int length = 0;  
  3.     LinkList *p = head;  
  4.     while (p) {  
  5.         ++length;  
  6.         p = p->next;  
  7.     }  
  8.     return length;  
  9. }  

5. 打印链表元素

（1）正向打印链表

[cpp] view plain copy
  1. //打印单链表  
  2. void PrintList(LinkList *head) {  
  3.     LinkList *p = head;  
  4.     while (p) {  
  5.         printf("%d ", p->value);  
  6.         p = p->next;  
  7.     }  
  8.     printf("\n");  
  9. }  

（2）逆序打印链表

[cpp] view plain copy
  1. //逆序打印单链表：非递归  
  2. void RPrintList(LinkList* head) {  
  3.     if (NULL == head)  
  4.         return;  
  5.     stack<int> list_stack;  
  6.     while (head) {  
  7.         list_stack.push(head->value);  
  8.         head = head->next;  
  9.     }  
  10.     while (!list_stack.empty()) {  
  11.         printf("%d ", list_stack.top());  
  12.         list_stack.pop();  
  13.     }  
  14.     printf("\n");  
  15. }  
  16.   
  17. //逆序打印单链表：递归  
  18. void RPrintListRecursively(LinkList* head) {  
  19.     if (NULL == head)  
  20.         return;  
  21.     else {  
  22.         RPrintListRecursively(head->next);  
  23.         printf("%d ", head->value);  
  24.     }  
  25. }  

6.为单链表的元素排序

由于单链表只有通过其next指针才能获取下一个元素，因此，对单链表的排序只能采用向后遍历的排序方法，例如冒泡排序的改进。而不能使用如插入排序、快速排序等需要向前查找的算法。如下算法是用冒泡排序进行的。一趟排序将未排序子序列中最大的元素放到链表已经排序子序列的头部（此最大元素是已排序子序列中的最小值）。

[cpp] view plain copy
  1. //冒泡排序单链表  
  2. LinkList* Sort(LinkList *head) {  
  3.     if (NULL == head)  
  4.         return head;  
  5.     int length = Length(head);  
  6.     int unorder_size = length;  
  7.     int flag = 1;  
  8.     while (flag) {  
  9.         flag = 0;  
  10.         LinkList *p = head;  
  11.         for (int i = 0; p->next && i < unorder_size; ++i) {  
  12.             if (p->value > p->next->value) {  
  13.                 int temp = p->value;  
  14.                 p->value = p->next->value;  
  15.                 p->next->value = temp;  
  16.                 flag = 1;  
  17.             }  
  18.             p = p->next;  
  19.         }   
  20.         --unorder_size;  
  21.     }  
  22.     return head;  
  23. }  

7. 单链表的翻转

从头到尾遍历原链表，每遍历一个结点，将其摘下放在新链表的最前端。注意链表为空和只有一个结点的情况。时间复杂度为O（n）

[cpp] view plain copy
  1. //翻转单链表  
  2. LinkList* ReverseList(LinkList *head) {  
  3.     //其实这里if判断当链表节点个数小于两个的情况  
  4.     //不是必须的，因为之后的程序包含这里的判断  
  5.     if (NULL == head || NULL == head->next){  
  6.         return head;  
  7.     }  
  8.     LinkList *reverse_head = NULL;  //翻转后链表的头指针  
  9.     LinkList *pcurrent = head;      //pcurrent遍历链表  
  10.     while (pcurrent) {  
  11.         LinkList* temp = pcurrent;  
  12.         pcurrent = pcurrent->next;  
  13.         temp->next = reverse_head;  
  14.         reverse_head = temp;  
  15.     }  
  16.     return reverse_head;  
  17. }  

8. 查找单链表中的倒数第K个结点（k > 0）

最容易想到的方法：先统计单链表中结点的个数，然后再找到第（n-k）个结点。注意链表为空，k为0，k为1，k大于链表中节点个数时的情况。时间复杂度为O（n）。

另一种思路：仅需遍历一次单链表。

主要思路就是使用两个指针，先让前面的指针走到正向第k个结点，这样前后两个指针的距离差是k-1，之后前后两个指针一起向前走，前面的指针走到最后一个结点时，后面指针所指结点就是倒数第k个结点。

注意链表节点个数小于k的情况。

[cpp] view plain copy
  1. //找出链表倒数第k个节点（k > 0)  
  2. LinkList * GetRKthNode(LinkList *head, int k) {  
  3.     if (k < 1 || NULL == head)  
  4.         return NULL;  
  5.     LinkList *first = head;  
  6.     LinkList *second = head;  
  7.   
  8.     //如果节点个数小于k返回NULL  
  9.     for (int i = 1; i < k; ++i) {  
  10.         if (second->next)  
  11.             second = second->next;  
  12.         else  
  13.             return NULL;  
  14.     }  
  15.   
  16.     //两个指针同时移动，直到快的second指针走到最后一个节点，  
  17.     //此时慢的first指针指向的就是倒数第k个节点  
  18.     while (second->next != NULL) {   
  19.         first = first->next;  
  20.         second = second->next;  
  21.     }  
  22.     return first;  
  23. }  


9. 查找单链表的中间结点

此题可用于上一题类似的思想。也是设置两个指针，只不过这里是，两个指针同时向前走，前面的指针每次走两步，后面的指针每次走一步，前面的指针走到最后一个结点时，后面的指针所指结点就是中间结点：第n / 2 + 1个结点。

当链表元素个数为偶数时，代码返回的是n/2 + 1个结点，这个应该讨论：也许需要返回的是中间两个节点或者他们的平均值。

注意链表为空，链表结点个数为1和2的情况。时间复杂度O（n）：

[cpp] view plain copy
  1. //返回单链表的中间节点，当链表节点个数为偶数时  
  2. //该函数返回链表第n/2 + 1个节点  
  3. LinkList *GetMiddleNode (LinkList* head) {  
  4.     //链表为空或者仅有一个节点  
  5.     if (NULL == head || NULL == head->next)  
  6.         return head;  
  7.   
  8.     LinkList *first = head;  
  9.     LinkList *second = head;  
  10.     while (second->next) {  
  11.         first = first->next;  
  12.         second = second->next;  
  13.         if (second->next) {  //当节点个数为偶数时情况比较特殊  
  14.             second = second->next;  
  15.         }  
  16.     }  
  17.     return first;  
  18. }  


10. 合并两个有序的单链表

使得合并后链表仍有序，如下代码保留值相同的元素。

这个类似归并排序。尤其注意两个链表都为空的情况，和其中一个为空时的情况。只需要O（1）的空间。时间复杂度为O（max(len1, len2)）。

[cpp] view plain copy
  1. //合并两个有序的单链表：非递归  
  2. //链表原来相等的元素都保留  
  3. LinkList* MergeList(LinkList* heada, LinkList *headb) {  
  4.     if (NULL == heada)  
  5.         return headb;  
  6.     if (NULL == headb)  
  7.         return heada;  
  8.   
  9.     LinkList *head_merge = NULL;  
  10.   
  11.     //比较第一个节点大小，取小者作为合并后第一个节点  
  12.     if (heada->value <= headb->value) {  
  13.         head_merge = heada;  
  14.         //注意下面两条语句顺序不能换，否则heada将指向空  
  15.         heada = heada->next;  
  16.     }  
  17.     else {  
  18.         head_merge = headb;  
  19.         //注意下面两条语句顺序不能换，否则headb将指向空  
  20.         headb = headb->next;  
  21.         //head_merge->next = NULL;  
  22.     }  
  23.     head_merge->next = NULL;  
  24.   
  25.     LinkList *pmerge = head_merge;  
  26.     while(heada != NULL && headb != NULL) {  
  27.         if (heada->value <= headb->value) {  
  28.             pmerge->next = heada;  
  29.             heada = heada->next;  
  30.             pmerge = pmerge->next;  
  31.               
  32.         }  
  33.         else {  
  34.             pmerge->next = headb;  
  35.             headb = headb->next;  
  36.             pmerge = pmerge->next;  
  37.         }  
  38.         pmerge->next = NULL;  
  39.     }  
  40.     if (heada)  
  41.         pmerge->next = heada;  
  42.     else if (headb)  
  43.         pmerge->next = headb;  
  44.   
  45.     return head_merge;  
  46. }  
  47.   
  48. //合并两个有序的单链表：递归  
  49. //链表原来相等的元素都保留  
  50. LinkList* MergeListRecursively(LinkList *heada, LinkList *headb) {  
  51.     if (NULL == heada)  
  52.         return headb;  
  53.     if (NULL == headb)  
  54.         return heada;  
  55.       
  56.     LinkList *head_merge = NULL;  
  57.     if (heada->value <= headb->value) {  
  58.         head_merge = heada;  
  59.         head_merge->next = MergeListRecursively(heada->next, headb);  
  60.     }  
  61.     else {  
  62.         head_merge = headb;  
  63.         head_merge->next = MergeListRecursively(heada, headb->next);  
  64.     }  
  65.     return head_merge;  
  66. }  

11. 判断一个单链表中是否有环

这里也是用到两个指针。如果一个链表中有环，也就是说用一个指针去遍历，是永远走不到头的。因此，我们可以用两个指针去遍历，一个指针一次走两步，一个指针一次走一步，如果有环，两个指针肯定会在环中相遇。时间复杂度为O（n）。

[cpp] view plain copy
  1. //判断链表中是否有环  
  2. bool HasCircle(LinkList *head) {  
  3.     if (NULL == head)  
  4.         return false;  
  5.     LinkList *first = head;  
  6.     LinkList *second = head;  
  7.     while (first && second->next) {  
  8.         second = second->next->next;  
  9.         first = first->next;  
  10.         if (first == second)  
  11.             return true;  
  12.     }  
  13.     return false;  
  14. }  

12. 判断两个单链表是否相交

如果两个链表相交于某一节点，那么在这个相交节点之后的所有节点都是两个链表所共有的。也就是说，如果两个链表相交，那么最后一个节点肯定是共有的。先遍历第一个链表，记住最后一个节点，然后遍历第二个链表，到最后一个节点时和第一个链表的最后一个节点做比较，如果相同，则相交，否则不相交。时间复杂度为O(len1+len2)，因为只需要一个额外指针保存最后一个节点地址，空间复杂度为O(1)。

[cpp] view plain copy
  1. //判断两个链表是否相交  
  2. bool IsCross(LinkList* heada, LinkList *headb) {  
  3.     if (NULL == heada || NULL == headb)  
  4.         return false;  
  5.     LinkList* taila = heada;  
  6.     LinkList* tailb = headb;  
  7.     while (taila->next)  
  8.         taila = taila->next;  
  9.     while (tailb->next)  
  10.         tailb = tailb->next;  
  11.     return taila == tailb;  
  12. }  

13. 求两个单链表相交的第一个节点

对第一个链表遍历，计算长度len1，同时保存最后一个节点的地址。

对第二个链表遍历，计算长度len2，同时检查最后一个节点是否和第一个链表的最后一个节点相同，若不相同，不相交，结束。
两个链表均从头节点开始，假设len1大于len2，那么将第一个链表先遍历len1-len2个节点，此时两个链表当前节点到第一个相交节点的距离就相等了，然后一起向后遍历，知道两个节点的地址相同。

时间复杂度，O(len1+len2)。

[cpp] view plain copy
  1. //找出两个链表相交的第一个节点  
  2. LinkList* GetFirstCrossNode(LinkList* heada, LinkList* headb) {  
  3.     if (NULL == heada || NULL == headb)  
  4.         return NULL;  
  5.   
  6.     int lengtha = 1;  
  7.     LinkList* taila = heada;  
  8.     while (taila->next) {  
  9.         ++lengtha;  
  10.         taila = taila->next;  
  11.     }  
  12.   
  13.     int lengthb = 1;  
  14.     LinkList* tailb = headb;  
  15.     while (tailb->next) {  
  16.         ++lengthb;  
  17.         tailb = tailb->next;  
  18.     }  
  19.   
  20.     //两个链表没有相交  
  21.     if (taila != tailb)  
  22.         return NULL;  
  23.   
  24.     LinkList* plong = heada; //指向长度大的链表  
  25.     LinkList* pshort = headb;//指向长度小的链表  
  26.     int diff;  
  27.     if (lengthb > lengtha) {  
  28.         diff = lengthb - lengtha;  
  29.         plong = headb;  
  30.         pshort = heada;  
  31.     }  
  32.   
  33.     //长链表先向前走，使得两个链表对齐  
  34.     for (int i = 0; i < diff; ++i)  
  35.         plong = plong->next;  
  36.   
  37.     while (plong && pshort && plong != pshort) {  
  38.         plong = plong->next;  
  39.         pshort = pshort->next;  
  40.     }  
  41.     return plong;  
  42. }  

14. 已知一个单链表中存在环，求进入环中的第一个节点

首先判断是否存在环，若不存在结束。在环中的一个节点处断开（当然函数结束时不能破坏原链表），这样就形成了两个相交的单链表，求进入环中的第一个节点也就转换成了求两个单链表相交的第一个节点。

[cpp] view plain copy
  1. //已知链表存在环，求进入链表的第一个节点  
  2. LinkList* GetFirstCircleNode(LinkList* head) {  
  3.     if (NULL == head)  
  4.         return NULL;  
  5.   
  6.     //判断两个链表是否有环，没环返回空  
  7.     LinkList *first = head;  
  8.     LinkList *second = head;  
  9.     while (first && second->next) {  
  10.         first = first->next;  
  11.         second = second->next->next;  
  12.         if (first == second)  
  13.             break;  
  14.     }  
  15.     if (NULL == first || NULL == second->next)  
  16.         return NULL;  
  17.   
  18.     //将相遇时环中的这个节点作为假设的尾节点，  
  19.     //就将原链表变为两个相交的单链表，第一个公共结点即为所求  
  20.     LinkList* assumed_tail = first;  
  21.     LinkList* head1 = head;  
  22.     LinkList* head2 = assumed_tail->next;  
  23.   
  24.     LinkList *pa = head1;  
  25.     int length1 = 1;  
  26.     while (pa != assumed_tail) {  
  27.         pa = pa->next;  
  28.         ++length1;  
  29.     }  
  30.   
  31.     LinkList* pb = head2;  
  32.     int length2 = 1;  
  33.     while (pb != assumed_tail) {  
  34.         pb = pb->next;  
  35.         ++length2;  
  36.     }  
  37.     pa = head1;  
  38.     pb = head2;  
  39.     if (length1 > length2) {  
  40.         int diff = length1 - length2;  
  41.         while (diff--)  
  42.             pa = pa->next;  
  43.     }  
  44.     else {  
  45.         int diff = length2 - length1;  
  46.         while (diff--)  
  47.             pb = pb->next;  
  48.     }  
  49.     while (pa != pb) {  
  50.         pa = pa->next;  
  51.         pb = pb->next;  
  52.     }  
  53.     return pa;  
  54. }  

15. 删除某指针指向的结点，时间复杂度O(1)

对于删除节点，我们普通的思路就是让该节点的前一个节点指向该节点的下一个节点，这种情况需要遍历找到该节点的前一个节点，时间复杂度为O(n)。对于链表，链表中的每个节点结构都是一样的，所以我们可以把该节点的下一个节点的数据复制到该节点，然后删除下一个节点即可。

要注意最后一个节点的情况，这个时候只能用常见的方法来操作，先找到前一个节点，但总体的平均时间复杂度还是O(1)。参考代码如下：

[cpp] view plain copy
  1. //删除某个指针指向的结点，时间复杂度O(1)  
  2. void DeleteTheNode(LinkList *head, LinkList *to_delete) {  
  3.     if (NULL == to_delete || NULL == head)  
  4.         return;  
  5.   
  6.     //要删除的是最后一个结点  
  7.     if (NULL == to_delete->next) {  
  8.         if (head == to_delete) { //要删除的是链表仅有的一个结点  
  9.             head = NULL;  
  10.             free(to_delete);  
  11.             to_delete = NULL;  //防止垂悬指针  
  12.         }  
  13.         else {             //链表有多个结点，要删除尾结点  
  14.             LinkList* p = head;  
  15.             while (p->next != to_delete)  
  16.                 p = p->next;  
  17.             p->next = NULL;  
  18.             free(to_delete);  
  19.             to_delete = NULL;    //防止垂悬指针  
  20.         }  
  21.     }   
  22.     else { //要删除的不是尾结点  
  23.         LinkList *pnext = to_delete->next;  
  24.         to_delete->value = pnext->value;  
  25.         to_delete->next = pnext->next;  
  26.         free(pnext);  
  27.         pnext = NULL;  
  28.     }  
  29. }  


16. 部分测试代码

[cpp] view plain copy
  1. int main() {  
  2.   
  3.     /*LinkList *head = BuildList(); 
  4.     head = InsertToHead(9, head); 
  5.     head = InsertToTail(100, head); 
  6.     head = DeletebyValue(2, head); 
  7.     printf("length: %d\n", Length(head)); 
  8.     PrintList(head); 
  9.     head = Sort(head); 
  10.     printf("list1: ");PrintList(head);*/  
  11.   
  12.     /*head = ReverseList(head); 
  13.     PrintList(head);*/  
  14.   
  15.     /*LinkList* kth = GetRKthNode(head, 1); 
  16.     if (kth) 
  17.     printf("1th：%d\n", kth->value);*/  
  18.   
  19.     /*LinkList *mid = GetMiddleNode(head); 
  20.     if (mid) 
  21.         printf("mid : %d\n", mid->value);*/  
  22.   
  23.     /*RPrintListRecursively(head); 
  24.     printf("\n"); 
  25.     RPrintList(head);*/  
  26.   
  27.     //LinkList *head = BuildList();  
  28.     //LinkList *headb = BuildList();  
  29.     //printf("list2: ");PrintList(headb);  
  30.     //LinkList *head_merge = MergeList(head, headb);  
  31.     ////LinkList *head_merge = MergeListRecursively(head, headb);  
  32.     //printf("list merge: ");PrintList(head_merge);  
  33.   
  34.     /* 
  35.     //LinkList* head = (LinkList*)malloc(sizeof(LinkList)); 
  36.     //head->next = head; 
  37.     LinkList *head = BuildList(); 
  38.     LinkList *temp = head; 
  39.     while (temp->next) 
  40.         temp = temp->next; 
  41.     temp->next = head; 
  42.     if (HasCircle(head)) { 
  43.         printf("yes\n"); 
  44.     } 
  45.     else 
  46.         printf("no\n");*/  
  47.       
  48.     /*LinkList *head = BuildList(); 
  49.     LinkList *temp = head; 
  50.     while (temp->next) 
  51.         temp = temp->next; 
  52.     LinkList* headb = BuildList(); 
  53.     temp->next = headb->next->next; 
  54.     LinkList* p = GetFirstCrossNode(head, headb); 
  55.     if (p) 
  56.         printf("%d\n", p->value);*/  
  57. }  

完整源码的github地址：https://github.com/liyangddd/algorithms/blob/master/3list_none_head_node.cpp

参考：

http://blog.csdn.net/walkinginthewind/article/details/7393134
阅读全文
0 0
逆袭网络剧7第一集哇趣 逆袭网络剧7第一集哇趣
原创粉丝点击
热门IT博客
网络调查的总结网络调查的总结
软件部门应聘软件部门应聘
vb基本代码
声音特效软件
凯迪网络首页
网络法律法规对游戏
淘宝倒计时怎么弄
网络兼职代笔写手
淘宝背景图蓝色
nginx 用户名密码
网络安全工程师的证书
java button改变text
专业整容效果软件
淘宝秒杀时间校准器
js动态修改表格行
发那科宏程序编程
最新网络热点话题
数据库的物理模型
图片文字修改软件
编程macbook air
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 弹弹堂安卓版 弹弹堂公开号 弹弹堂玩法 弹弹堂计算器 弹弹堂怎么打的准 弹弹堂争霸赛 弹弹堂婚礼多少钱 弹弹堂充值 弹弹堂s手游礼包 2144弹弹堂 弹弹堂65度 弹弹堂魔法幸运星 q版弹弹堂 弹弹堂半神器排名 弹弹堂 点卷 4399弹弹堂开服表 弹弹堂 时间 23弹弹堂变态服 弹弹堂无限点卷版 弹弹堂v6多少钱 mmog弹弹堂 弹弹堂4 弹弹堂24399 弹弹堂坐骑 弹弹堂s 手游 4933弹弹堂 弹弹堂 下载 弹弹堂三 gtv弹弹堂 弹弹堂挂机 弹弹堂修改器 4399弹弹堂waigua 弹弹堂公司 弹弹堂材料攻略解析 2125弹弹堂guanwang 弹弹堂救援行动攻略 弹弹堂新手礼包激活码 360新弹弹堂第七大道 类似弹弹堂的手机网游 弹弹堂宠物名字大全 4399弹弹堂学生会礼包激活码

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