程序博客网 > 淘宝客怎么做巨打折

15道简单算法题

来源：互联网 发布：淘宝客怎么做巨打折 编辑：程序博客网 时间：2024/06/06 16:45
原文出处： 陈太汉的博客   

最近在公司里基本处于打酱油的状态，工作正在交接中。没事又做起了算法题目。好久没怎么写算法题了，感觉手气还不错，经常能一次就写对（编译通过，得到想要的结果，没怎么测试），可能是因为这些题目之前看过或是写过，或许就是自己进步了一点。这15道大部分来自《剑指Offer》，作者的博客之前看过几次，感觉写得很好，但看这本书时却没有那个感觉了，可能是因为看过博客的原因吧，没有了之前的那种惊喜。自己就试着实现里面的一些算法题目，基本上是简单的思考一下，如果没什么思路，就看看作者是怎么想的，大概看一下他的思路或是代码，就开始自己实现。15道算法题如下：源码下载。

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

2:合并两个单链表;

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

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

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

6:反转单链表;

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

8:二分查找;

9:快速排序;

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

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

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

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

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

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

下面简单说说思路和代码实现。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//链表节点
structNodeL
{
    intvalue;
    NodeL* next;
    NodeL(intvalue_=0,NodeL* next_=NULL):value(value_),next(next_){}
};
//二叉树节点
structNodeT
{
    intvalue;
    NodeT* left;
    NodeT* right;
    NodeT(intvalue_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
};

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//合并排序，将两个已经排序的数组合并成一个数组，其中一个数组能容下两个数组的所有元素
voidMergeArray(inta[],intalen,intb[],intblen)
{
    intlen=alen+blen-1;
    alen--;
    blen--;
    while(alen>=0 && blen>=0)
    {
        if(a[alen]>b[blen])
        {
            a[len--]=a[alen--];
        }else{
            a[len--]=b[blen--];
        }
    }
 
    while(alen>=0)
    {
        a[len--]=a[alen--];
    }
    while(blen>=0)
    {
        a[len--]=b[blen--];
    }
}
 
voidMergeArrayTest()
{
    inta[]={2,4,6,8,10,0,0,0,0,0};
    intb[]={1,3,5,7,9};
    MergeArray(a,5,b,5);
    for(inti=0;i<sizeof(a)/sizeof(a[0]);i++)
    {
        cout<<a[i]<<" ";
    }
}

2:合并两个单链表;

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
//链表节点
structNodeL
{
    intvalue;
    NodeL* next;
    NodeL(intvalue_=0,NodeL* next_=NULL):value(value_),next(next_){}
};
 
//合并两个单链表
NodeL* MergeList(NodeL* head1,NodeL* head2)
{
    if(head1==NULL)
        returnhead2;
    if(head2==NULL)
        returnhead1;
 
    NodeL* head=NULL;
    if(head1->value<head2->value)
    {
        head=head1;
        head1=head1->next;
    }else{
        head=head2;
        head2=head2->next;
    }
    NodeL* tmpNode=head;
    while(head1 && head2)
    {
        if(head1->value<head2->value)
        {
            head->next=head1;
            head1=head1->next;
        }else{
            head->next=head2;
            head2=head2->next;
        }
        head=head->next;
    }
    if(head1)
    {
        head->next=head1;
    }
    if(head2)
    {
        head->next=head2;
    }
    returntmpNode;
}
 
voidMergeListTest()
{
    NodeL* head1=newNodeL(1);
    NodeL* cur=head1;
    for(inti=3;i<10;i+=2)
    {
        NodeL* tmpNode=newNodeL(i);
        cur->next=tmpNode;
        cur=tmpNode;
    }
    NodeL* head2=newNodeL(2);
    cur=head2;
    for(inti=4;i<10;i+=2)
    {
        NodeL* tmpNode=newNodeL(i);
        cur->next=tmpNode;
        cur=tmpNode;
    }
    NodeL* head=MergeList(head1,head2);
    while(head)
    {
        cout<<head->value<<" ";
        head=head->next;
    }
}

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

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

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

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
//给定一个单链表的头指针和一个指定节点的指针，在O(1)时间删除该节点
voidDeleteNode(NodeL* head,NodeL* delNode)
{
    if(!head || !delNode)
    {
        return;
    }
 
    if(delNode->next!=NULL)//删除中间节点
    {
        NodeL* next=delNode->next;
        delNode->next=next->next;
        delNode->value=next->value;
        deletenext;
        next=NULL;
    }elseif (head==delNode)//删除头结点
    {
        deletedelNode;
        delNode=NULL;
        *head=NULL;
    }else//删除尾节点，考虑到delNode不在head所在的链表上的情况
    {
        NodeL* tmpNode=head;
        while(tmpNode && tmpNode->next!=delNode)
        {
            tmpNode=tmpNode->next;
        }
        if(tmpNode!=NULL)
        {
            deletedelNode;
            delNode=NULL;
            tmpNode->next=NULL;
        }
    }
}
 
voidDeleteNodeTest()
{
    intnodeCount=10;
    for(intK=0;K<nodeCount;K++)
    {
        NodeL* head=NULL;
        NodeL* cur=NULL;
        NodeL* delNode=NULL;
        for(inti=0;i<nodeCount;i++)
        {
            NodeL* tmpNode=newNodeL(i);
            if(i==0)
            {
                cur=head=tmpNode;
            }else{
                cur->next=tmpNode;
                cur=tmpNode;
            }
            if(i==K)
            {
                delNode=tmpNode;
            }
        }
        DeleteNode(head,delNode) ;
    }
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//找到链表倒数第K个节点
NodeL* FindKthToTail(NodeL* head,unsigned intk)
{
    if(head==NULL || k==0)
        returnNULL;
    NodeL* tmpNode=head;
    for(inti=0;i<k;i++)
    {
        if(tmpNode!=NULL)
        {
            tmpNode=tmpNode->next;
        }else{
            returnNULL;
        }
    }
    NodeL* kNode=head;
    while(tmpNode!=NULL)
    {
        kNode=kNode->next;
        tmpNode=tmpNode->next;
    }
    returnkNode;
}
 
voidFindKthToTailTest()
{
    intnodeCount=10;
    for(intK=0;K<nodeCount;K++)
    {
        NodeL* head=NULL;
        NodeL* cur=NULL;
        for(inti=0;i<nodeCount;i++)
        {
            NodeL* tmpNode=newNodeL(i);
            if(i==0)
            {
                cur=head=tmpNode;
            }else{
                cur->next=tmpNode;
                cur=tmpNode; 
            }
        }
        NodeL* kNode=FindKthToTail(head,K+3) ;
        if(kNode)
        {
            cout<<"倒数第 "<<K+3<<" 个节点是："<<kNode->value<<endl;
        }else{
            cout<<"倒数第 "<<K+3<<" 个节点不在链表中" <<endl;
        }
    }
}

6:反转单链表;

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//反转单链表
NodeL* ReverseList(NodeL* head)
{
    if(head==NULL)
    {
        returnNULL;
    }
    NodeL* reverseHead=NULL;
    NodeL* curNode=head;
    NodeL* preNode=NULL;
    while(curNode!=NULL)
    {
        NodeL* nextNode=curNode->next;
        if(nextNode==NULL)
            reverseHead=curNode; 
 
        curNode->next=preNode;
        preNode=curNode;
        curNode=nextNode;
    }
    returnreverseHead;
}
 
voidReverseListTest()
{
    for(intK=0;K<=10;K++)
    {
        NodeL* head=NULL;
        NodeL* cur=NULL;
        for(inti=0;i<K;i++)
        {
            NodeL* tmpNode=newNodeL(i);
            if(i==0)
            {
                cur=head=tmpNode;
            }else{
                cur->next=tmpNode;
                cur=tmpNode; 
            }
        }
 
        cur=ReverseList( head);
        while(cur)
        {
            cout<<cur->value<<" ";
            cur=cur->next;
        }
        cout<<endl;
    }
    cout<<endl;
}

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

直接上代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
//通过两个栈实现一个队列
template<typenameT>
classCQueue
{
public:
    voidpush(constT& val)
    {
        while(s2.size()>0)
        {
            s1.push(s2.top());
            s2.pop();
        }
        s1.push(val);
    }
    voidpop()
    {
        while(s1.size()>0)
        {
            s2.push(s1.top());
            s1.pop();
        }
        s2.pop();
    }
 
    T& front()
    {
        while(s1.size()>0)
        {
            s2.push(s1.top());
            s1.pop();
        }
        returns2.top();
    }
    intsize()
    {
        returns1.size()+s2.size();
    }
private:
    stack<T> s1;
    stack<T> s2;
};
 
voidCQueueTest()
{
    CQueue<int> q;
    for(inti=0;i<10;i++)
    {
        q.push(i);
    }
    while(q.size()>0)
    {
        cout<<q.front()<<" ";
        q.pop();
    }
}

8:二分查找;

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
//二分查找
intbinarySearch(inta[],intlen,intval)
{
    intstart=0;
    intend=len-1;
    intindex=-1;
    while(start<=end)
    {
        index=start+(end-start)/2;
        if(a[index]==val)
        {
            returnindex;
        }elseif (a[index]<val)
        {
            start=index+1;
        }else
        {
            end=index-1;
        }
    }
    return-1;
}

9:快速排序;

来自百度百科，说不清楚

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//快速排序
//之前有个面试叫我写快排，想都没想写了个冒泡,思路早忘了，这段代码来自百度百科
voidQsort(inta[],intlow,inthigh)
{
    if(low>=high)
    {
        return;
    }
    intfirst=low;
    intlast=high;
    intkey=a[first];//用字表的第一个记录作为枢轴
    while(first<last)
    {
        while(first<last && a[last]>=key )--last;
        a[first]=a[last];//将比第一个小的移到低端
        while(first<last && a[first]<=key )++first;
        a[last]=a[first];//将比第一个大的移到高端
    }
    a[first]=key;//枢轴记录到位
    Qsort(a,low,first-1);
    Qsort(a,last+1,high);
}
 
voidQsortTest()
{
    inta[]={1,3,5,7,9,2,4,6,8,0};
    intlen=sizeof(a)/sizeof(a[0])-1;
    Qsort(a,0,len);
    for(inti=0;i<=len;i++)
    {
        cout<<a[i]<<" ";
    }
    cout<<endl;
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//获得一个int型的数中二进制中1的个数
intFind1Count(intnum)
{
    if(num==0)
    {
        return0;
    }
    intcount=1;
    while(num= num & (num-1))
    {
        count++;
    }
    returncount;
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
//输入一个数组，实现一个函数，让所有奇数都在偶数前面
voidRecordOddEven(intA[],intlen)
{
    inti=0,j=len-1;
    while(i<j)
    {
        while(i<len && A[i]%2==1)
            i++;
 
        while(j>=0 && A[j]%2==0)
            j--;
 
        if(i<j)
        {
            A[i]^=A[j]^=A[i]^=A[j];
        }
    }
}
 
voidRecordOddEvenTest()
{
    intA[]={1,2,3,4,5,6,7,8,9,0,11};
    intlen=sizeof(A)/sizeof(A[0]);
    RecordOddEven( A , len);
    for(inti=0;i<len;i++)
    {
        cout<<A[i]<<" ";
    }
    cout<<endl;
    for(inti=0;i<len;i++)
    {
        A[i]=2;
    }
    RecordOddEven( A , len);
    for(inti=0;i<len;i++)
    {
        cout<<A[i]<<" ";
    }
    cout<<endl;
    for(inti=0;i<len;i++)
    {
        A[i]=1;
    }
    RecordOddEven( A , len);
    for(inti=0;i<len;i++)
    {
        cout<<A[i]<<" ";
    }
}

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

我这里就是暴力的对比

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//判断一个字符串是否是另一个字符串的子串
intsubstr(constchar* source,constchar* sub)
{
    if(source==NULL || sub==NULL)
    {
        return-1;
    }
    intsouLen=strlen(source);
    intsubLen=strlen(sub);
    if(souLen<subLen)
    {
        return-1;
    }
 
    intcmpCount=souLen-subLen;
    for(inti=0;i<=cmpCount;i++)
    {
        intj=0;
        for(;j<subLen;j++)
        {
            if(source[i+j]!=sub[j])
            {
                break;
            }
        }
        if(j==subLen)
        {
            returni ;
        }
    }
    return-1;
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
//把一个int型数组中的数字拼成一个串，是这个串代表的数组最小
#define MaxLen 10
intCompare(constvoid* str1,constvoid* str2)
{
    charcmp1[MaxLen*2+1];
    charcmp2[MaxLen*2+1];
    strcpy(cmp1,*(char**)str1);
    strcat(cmp1,*(char**)str2);
 
    strcpy(cmp2,*(char**)str2);
    strcat(cmp2,*(char**)str1);
    returnstrcmp(cmp1,cmp2);
} 
voidGetLinkMin(inta[],intlen)
{
    char** str=(char**)newint[len];
    for(inti=0;i<len;i++)
    {
        str[i]=newchar[MaxLen+1];
        sprintf(str[i],"%d",a[i]);
    }
 
    qsort(str,len,sizeof(char*),Compare);
    for(inti=0;i<len;i++)
    {
        cout<<str[i]<<" ";
        delete[] str[i] ;
    }
    delete[] str;
}
voidGetLinkMinTest()
{
    intarr[]={123,132,213,231,321,312};
    GetLinkMin(arr,sizeof(arr)/sizeof(int));
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
structNodeT
{
    intvalue;
    NodeT* left;
    NodeT* right;
    NodeT(intvalue_=0,NodeT* left_=NULL,NodeT* right_=NULL):value(value_),left(left_),right(right_){}
};
 
//输入一颗二叉树，输出它的镜像（每个节点的左右子节点交换位置）
voidTreeClass(NodeT* root)
{
    if( root==NULL || (root->left==NULL && root->right==NULL) )
        return;
    NodeT* tmpNode=root->left;
    root->left=root->right;
    root->right=tmpNode;
    TreeClass(root->left);
    TreeClass(root->right);
}
 
voidPrintTree(NodeT* root)
{
    if(root)
    {
        cout<<root->value<<" ";
        PrintTree(root->left);
        PrintTree(root->right);
    }
}
 
voidTreeClassTest()
{
    NodeT* root=newNodeT(8);
    NodeT* n1=newNodeT(6);
    NodeT* n2=newNodeT(10);
    NodeT* n3=newNodeT(5);
    NodeT* n4=newNodeT(7);
    NodeT* n5=newNodeT(9);
    NodeT* n6=newNodeT(11);
    root->left=n1;
    root->right=n2;
    n1->left=n3;
    n1->right=n4;
    n2->left=n5;
    n2->right=n6;
    PrintTree(root);
    cout<<endl;
    TreeClass( root );
    PrintTree(root);
    cout<<endl;
}

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
//输入两个链表，找到它们第一个公共节点
intGetLinkLength(NodeL* head)
{
    intcount=0;
    while(head)
    {
        head=head->next;
        count++;
    }
    returncount;
}
 
NodeL* FindFirstEqualNode(NodeL* head1,NodeL* head2)
{
    if(head1==NULL || head2==NULL)
        returnNULL;
    intlen1=GetLinkLength(head1);
    intlen2=GetLinkLength(head2);
    NodeL* longNode;
    NodeL* shortNode;
    intleftNodeCount;
    if(len1>len2)
    {
        longNode=head1;
        shortNode=head2;
        leftNodeCount=len1-len2;
    }else{
        longNode=head2;
        shortNode=head1;
        leftNodeCount=len2-len1;
    }
    for(inti=0;i<leftNodeCount;i++)
    {
        longNode=longNode->next;
    }
    while(longNode && shortNode && longNode!=shortNode)
    {
        longNode=longNode->next;
        shortNode=shortNode->next;
    }
    if(longNode)//如果有公共节点，必不为NULL
    {
        returnlongNode;
    }
    returnNULL; 
}
 
voidFindFirstEqualNodeTest()
{
    NodeL* head1=newNodeL(0);
    NodeL* head2=newNodeL(0);
    NodeL* node1=newNodeL(1);
    NodeL* node2=newNodeL(2);
    NodeL* node3=newNodeL(3);
    NodeL* node4=newNodeL(4);
    NodeL* node5=newNodeL(5);
    NodeL* node6=newNodeL(6);
    NodeL* node7=newNodeL(7);
 
    head1->next=node1;
    node1->next=node2;
    node2->next=node3;
    node3->next=node6;//两个链表相交于节点node6
 
    head2->next=node4;
    node4->next=node5;
    node5->next=node6;//两个链表相交于节点node6
    node6->next=node7;
 
    NodeL* node= FindFirstEqualNode(head1,head2);
    if(node)
    {
        cout<<node->value<<endl;
    }else{
        cout<<"没有共同节点"<<endl;
    }
}
0 0
淘宝客怎么做巨打折 淘宝客怎么做巨打折
原创粉丝点击
热门IT博客
ubuntu deepin 源ubuntu deepin 源
空气的比热容比数据空气的比热容比数据
淘宝网评价管理
超级基因优化液txt手机
影视制作用什么软件
新闻传播的大数据时代
python urllib2
silverlight js交互
网络钓鱼常用的手段是
淘宝卖家浏览器插件
软件安全测试机构
事业单位考试题库软件
python golang
知画生孩子视频播放
网络教育华南理工大学
淘宝店地区怎么修改
windows 远程桌面服务
程序员电脑壁纸
软件开发工程师学习班
索尼 小米 电视 知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 怪物射手 射手巨蟹 巨蟹射手 射手摩羯 死亡射手 摩羯射手 射手和摩羯 射手水瓶 泡泡射手 射手白羊 上升射手 巨蟹 射手 狙击射手 白羊射手 射手天蝎 射手 巨蟹 射手网字幕 白羊 射手 射手 摩羯 巨蟹与射手 天蝎 射手 射手双子 奇幻射手 射手狮子 射手与射手 射手假说 狮子射手 狮子 射手 月亮射手 射手处女 射手速配 摩羯和射手 水瓶和射手 天蝎和射手 巨蟹跟射手 射手跟巨蟹 天秤和射手 射手和天蝎 三分射手 射手天平 射手女和射手男

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