2019-01-10 09:32:08 zhhp1001 阅读数 202
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3982 人正在学习 去看看 王桂林

要补基础了,大概浏览了以下四本书:

数据结构与算法分析 C++语言描述  4th  这本书内容不错...但是这个翻译水平是我见过最烂的...看原版吧这本。

算法导论  数学推导比较多,伪代码实现, 感觉应该在阅读其他书籍入门后再来看

大话数据结构   C语言描述,代码质量不行...  厕所读物 可看可不看

邓俊辉  数据结构 (C++语言版) 比较了上面几本书之后,发现这本是真不错,配合习题集  ,内容丰富,代码规范。

2018-08-08 14:52:46 qq_20304723 阅读数 172
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3982 人正在学习 去看看 王桂林

2018.8.8     《剑指Offer》从零单刷个人笔记整理(66题全)目录传送门​​​​​​​

这道题原版是不要求调整后的元素相对顺序与原序列一致的,那其实就可以用首尾对称调换的方法做。后面C++的代码是按原题做的标准答案。现在要求调整后的元素相对顺序与原序列一致,也不难。

思路一:奇偶两个flag point从头出发,oddpoint停在第一个偶数上,evenpoint继续前进到该偶数后的第一个奇数(这么说好像应该两个point名称对调一下,不要在意啦),接着让这两个flag point之间的子序列做一个冒泡,使得奇数冒到最前(如原子序列为6827,冒泡完后为7682)。接着oddpoint前进1格,evenpoint继续前行直到循环结束即可。

思路二:创建一个新数组,遇到偶数就保存到新数组,同时删除原数组中的偶数。最后将新数组中的所有偶数添加到老数组奇数序列后即可。


原版题目描述

输入一个整数数组,实现一个函数来调整该数组中数字的顺序,使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分

升级版题目描述

保证奇数和奇数,偶数和偶数之间的相对位置不变。


升级版Java实现(思路一):

/**
 * 
 * @author ChopinXBP 
 * 输入一个整数数组,实现一个函数来调整该数组中数字的顺序
 * 使得所有的奇数位于数组的前半部分,所有的偶数位于数组的后半部分,并保证奇数和奇数,偶数和偶数之间的相对位置不变。
 * 
 *
 */

public class reOrderArray_13 {

	static int[] array = {8, 3, 7, 5, 1};
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Solution(array);
		for(int i = 0;i<array.length;i++){
			System.out.print(array[i]);
		}
	}
	
	public static void Solution(int[] array){
		int oddflag = 0;
		int evenflag = 0;
		
		while(evenflag < array.length){
			//奇偶flag前进到第一个偶数开始进入循环
			if((array[oddflag] & 0x01) == 0){				
				while(evenflag < array.length){
					//将下一个奇数与其之前的所有偶数进行一次冒泡
					if((array[evenflag] & 0x01) == 1){
						Swap(array, oddflag, evenflag);
						oddflag++;
					}
					evenflag++;
				}			
			}
			oddflag++;
			evenflag++;
			
		}
		
	}
	
	public static void Swap(int[]array, int i, int j){
		while(j != i){
			int tmp = array[j - 1];
			array[j - 1] = array[j];
			array[j] = tmp;
			j--;
		}
	}
	

}

升级版C++实现示例(思路二):

//第二个思路:再创建一个数组
class Solution{
public:
    void reOrderArray(vector<int> &array) {
 
        vector<int> array_temp;
        vector<int>::iterator ib1, ie1;
        ib1 = array.begin();
 
 
        for (; ib1 != array.end();){            //遇见偶数,就保存到新数组,同时从原数组中删除
            if (*ib1 % 2 == 0) {
                array_temp.push_back(*ib1);
                ib1 = array.erase(ib1);
            }
            else{
                ib1++;
            }
 
        }
        vector<int>::iterator ib2, ie2;
        ib2 = array_temp.begin();
        ie2 = array_temp.end();
 
        for (; ib2 != ie2; ib2++)             //将新数组的数添加到老数组
        {
            array.push_back(*ib2);
        }
    }
};

原版+测试代码:

#include "stdafx.h"

void Reorder(int *pData, unsigned int length, bool (*func)(int));
bool isEven(int n);

// ====================方法一====================
void ReorderOddEven_1(int *pData, unsigned int length)
{
    if(pData == NULL || length == 0)
        return;

    int *pBegin = pData;
    int *pEnd = pData + length - 1;

    while(pBegin < pEnd)
    {
        // 向后移动pBegin,直到它指向偶数
        while(pBegin < pEnd && (*pBegin & 0x1) != 0)
            pBegin ++;

        // 向前移动pEnd,直到它指向奇数
        while(pBegin < pEnd && (*pEnd & 0x1) == 0)
            pEnd --;

        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

// ====================方法二====================
void ReorderOddEven_2(int *pData, unsigned int length)
{
    Reorder(pData, length, isEven);
}

void Reorder(int *pData, unsigned int length, bool (*func)(int))
{
    if(pData == NULL || length == 0)
        return;

    int *pBegin = pData;
    int *pEnd = pData + length - 1;

    while(pBegin < pEnd) 
    {
        // 向后移动pBegin
        while(pBegin < pEnd && !func(*pBegin))
            pBegin ++;

        // 向前移动pEnd
        while(pBegin < pEnd && func(*pEnd))
            pEnd --;

        if(pBegin < pEnd)
        {
            int temp = *pBegin;
            *pBegin = *pEnd;
            *pEnd = temp;
        }
    }
}

bool isEven(int n)
{
    return (n & 1) == 0;
}

// ====================测试代码====================
void PrintArray(int numbers[], int length)
{
    if(length < 0)
        return;

    for(int i = 0; i < length; ++i)
        printf("%d\t", numbers[i]);

    printf("\n");
}

void Test(char* testName, int numbers[], int length)
{
    if(testName != NULL)
        printf("%s begins:\n", testName);

    int* copy = new int[length];
    for(int i = 0; i < length; ++i)
    {
        copy[i] = numbers[i];
    }

    printf("Test for solution 1:\n");
    PrintArray(numbers, length);
    ReorderOddEven_1(numbers, length);
    PrintArray(numbers, length);

    printf("Test for solution 2:\n");
    PrintArray(copy, length);
    ReorderOddEven_2(copy, length);
    PrintArray(copy, length);

    delete[] copy;
}

void Test1()
{
    int numbers[] = {1, 2, 3, 4, 5, 6, 7};
    Test("Test1", numbers, sizeof(numbers)/sizeof(int));
}

void Test2()
{
    int numbers[] = {2, 4, 6, 1, 3, 5, 7};
    Test("Test2", numbers, sizeof(numbers)/sizeof(int));
}

void Test3()
{
    int numbers[] = {1, 3, 5, 7, 2, 4, 6};
    Test("Test3", numbers, sizeof(numbers)/sizeof(int));
}

void Test4()
{
    int numbers[] = {1};
    Test("Test4", numbers, sizeof(numbers)/sizeof(int));
}

void Test5()
{
    int numbers[] = {2};
    Test("Test5", numbers, sizeof(numbers)/sizeof(int));
}

void Test6()
{
    Test("Test6", NULL, 0);
}

int _tmain(int argc, _TCHAR* argv[])
{
    Test1();
    Test2();
    Test3();
    Test4();
    Test5();
    Test6();

    return 0;
}

#Coding一小时,Copying一秒钟。留个言点个赞呗,谢谢你#

2014-06-18 16:50:28 suifeng50 阅读数 3142
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3982 人正在学习 去看看 王桂林

本文参考了李春葆版本的数据结构上机指导,但是原版是c代码,

本文用了c++实现,并且修复了深度优先搜索非递归的一个bug。

graph.cpp文件:

#include "graph.h"
#include <queue>
#include <stack>
int visited[MAXV ];
MGraph ::MGraph(int A[100][10], int nn , int ee)
{
                e= ee ;
                n= nn ;
                 for (int i=0;i<n;i++)
                {
                                 for (int j=0;j<n;j++)
                                                edges[i][j]= A [i][j];
                }
}

void MGraph ::DispMat( MGraph g )
{
                 int i,j;
                 for (i=0;i<g .n;i++)
                {
                                 for (j=0;j<g .n;j++)
                                                cout<< g .edges[i][j]<<"       " ;
                                cout<<endl;
                }

}


ALGragh ::ALGragh(int a[ MAXV][10], int n , int e)
{
                 ALGragh ::n=n ;
                 ALGragh ::e=e ;
                 for (int i=0;i< n;i++)
                {
                                adjlist[i].firstarc= NULL ;
                }
                 for (int i=0;i< n;i++)
                                 for (int j= n-1;j>=0;j--)
                                {
                                                 if (a [i][j]!=0)
                                                {     //作用域里面,必须动态分配。直接写ArcNode p(adjlist[i].firstarc,j,a[i][j])会被析构
                                                                 ArcNode *p=new ArcNode (adjlist[i].firstarc,j, a [i][j]);
                                                                adjlist[i].firstarc=p;
                                                }
                                }
}

void ALGragh ::DispAdj( ALGragh * G )
{
                 ArcNode *p;
                 for (int i=0;i< G->n;i++)
                {
                                p= G ->adjlist[i].firstarc; //p指向第一条边
                                 if (p!=NULL )
                                                cout <<i<<":  " ;
                                 while (p!=NULL )
                                {
                                                cout<<(p->adjvex)<< "  " ;//输出终点
                                                p=p->nextarc;     //指向下一条边
                                }
                                cout<<endl;
                }
}


void ALGragh ::DFS( int v, int flag) //深度优先搜索 递归
{
                 if (flag )
                {
                                memset(visited,0, sizeof (visited));
                                 flag =0;
                }

                 if (v >=n || v<0)
                {
                                cout<< "error point!" ;
                                 return ;
                }
                visited[ v ]=1;
                cout<< v <<"  " ;
                 ArcNode *p=adjlist[v ].firstarc;
                 while (p!=NULL )
                {
                                 if (!visited[p->adjvex])
                                                DFS(p->adjvex, flag );
                                p=p->nextarc;
                }
}

void ALGragh ::DFS1( int v//深度优先搜索 非递归
{
                memset(visited,0, sizeof (visited));
                 if (v >=n || v<0)
                {
                                cout<< "error point!" ;
                                 return ;
                }
                 stack <ArcNode *> s;
                visited[ v ]=1;
                cout<< v <<"  " ;
                 ArcNode *q;
                s.push(adjlist[ v ].firstarc);
                 while (!s.empty())
                {
                                q=s.top(); //s.pop();
                                 while (q!=NULL )
                                {
                                                 if (!visited[q->adjvex])
                                                {
                                                                visited[q->adjvex]=1;
                                                                cout<<q->adjvex<< "  " ;      
                                                                s.push(adjlist[q->adjvex].firstarc); //定点进栈
                                                                 break ;
                                                }
                                                 else
                                                {
                                                                q=q->nextarc;        //与当前结点相连的边都访问了(即往该结点走不下去了)     该节点出栈
                                                                 if (q==NULL )
                                                                                s.pop();
                                                }
                                }
                }
}


void ALGragh ::BFS( int v//广度优先搜索
{
                memset(visited,0, sizeof (visited));
                 if (v >=n || v<0)
                {
                                cout<< "error point!" ;
                                 return ;
                }
                 queue <int > q;
                 ArcNode *p;
                q.push( v );
                visited[ v ]=1;
                cout<< v <<"  " ;
                 while (!q.empty())
                {
                                 v =q.front(); q.pop();
                                p=adjlist[ v ].firstarc;
                                 while (p!=NULL )
                                {
                                                 if (!visited[p->adjvex])
                                                {
                                                                visited[p->adjvex]=1;
                                                                cout<<p->adjvex<< "  " ;
                                                                q.push(p->adjvex);
                                                }
                                                p=p->nextarc;
                                }              
                }
}

main.cpp文件:

#include "graph.h"
int main()
{
                 ////////-------图的遍历算法----//////////
                 /*int A[100][6]={
                                {0,5,0,7,0,0},
                                {0,0,4,0,0,0},
                                {8,0,0,0,0,9},
                                {0,0,5,0,0,6},
                                {0,0,0,5,0,0},
                                {3,0,0,0,1,0}
                };*/
                 int A[100][10]={
                                0,1,1,1,0,0,0,0,0,0,
                                1,0,0,1,0,1,1,1,1,0,
                                0,1,0,1,1,1,0,0,0,0,
                                0,0,0,0,0,1,0,0,0,0,
                                0,1,1,1,0,1,0,0,0,0,
                                0,1,0,0,0,0,0,0,0,0,
                                0,1,1,1,0,0,0,1,1,0,
                                0,0,1,1,1,1,1,0,1,0,
                                0,0,1,1,0,0,0,0,0,0,
                                0,0,1,0,0,0,0,0,1,0
                };
                MGraph g(A,10,10);                                                              //图的邻接矩阵类型
                ALGragh G(A,10,10);                                                            //图的临界表类型
                g.DispMat(g);
                G.DispAdj(&G);
                G.DFS(0,1); cout<<endl;
                G.DFS1(0); cout<<endl;

graph.h文件:

#include "C++global.h"//图的数据结构
typedef int InfoType;
#define MAXV 100   //最大顶点个数

//------------------------------------//
//-----------用邻接矩阵存储-------------//
class VertexType     //顶点类型
{
private :
                 int no;      //顶点编号
                 InfoType info; //顶点的其他信息;
};
class MGraph     //图的定义
{
public :    
                 void DispMat(MGraph g);
                MGraph(){n=0;e=0;memset(edges,0, sizeof (edges));}
                MGraph( int A[100][10],int n, int e);
private :
                 int edges[MAXV ][ MAXV]; //邻接矩阵
                 int n,e;               //顶点数,弧数
                 VertexType vexs[MAXV ]; //图的邻接矩阵类型。
};


//------------------------------------//
//------------------------------------//
//------------用临界表存储-------------//
class VNode ;
class ArcNode             //弧结点结构类
{
                 friend class   ALGragh;
                 //friend class VNode;
public :
                ArcNode(){}
                ArcNode( ArcNode *next , int adj, int i)
                {              adjvex= adj ;            nextarc= next;        info= i ;    }
                
private :
                 int adjvex;         
                 ArcNode *nextarc;    //指向下一条弧的指针
                 InfoType info;       //弧先关信息,这里存放权值
};

class VNode {               //头结点类
                 //friend class ArcNode;
                 friend class   ALGragh;
private :
                 int data;              //顶点信息
                 ArcNode *firstarc;     //指向第一条弧
};

typedef VNode AdjList[ MAXV ]; //AdjList是临界表类型

class   ALGragh {     //图的临界表类型
public :
                ALGragh();
                ALGragh( int a[MAXV ][10], int n, int e );
                 void DispAdj(ALGragh *G);
                 void DFS(int v, int flag);
                 void DFS1(int v); //深度优先 非递归
                 void BFS(int v);
private :
                 AdjList adjlist;     //邻接表
                 int n,e;
};


输出:


2013-09-30 22:34:36 Daisy327 阅读数 692
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3982 人正在学习 去看看 王桂林

Essential C++第三章主要介绍的是泛型编程风格。

在讲“如何设计泛型算法”时,给出了一个filter的template例子。为了更好的理解和运用泛型算法以及template。将P89(中文版)页给出的sub_vec函数写成template版本。

其原版non-template函数如下:

vector<int> sub_vec( const vector<int> &vec, int val )
{
	vector<int> local_vec( vec );
	sort ( local_vec.begin(), local_vec.end() );
	
	vector<int>::iterator iter = 
		find_if (	local_vec.begin(),
					local_vec.end(),
					bind2nd( greater<int>(), val ));
	
	local_vec.erase ( iter, local_vec.end() );
	return local_vec;
}
将其改为template格式后,函数返回一个iterator指针,指针指向find_if找到的第一个大于指定值的元素,函数为:

//sub_vec的泛型算法
template <	typename InputIterator,	typename OutputIterator,	typename ElemType>
OutputIterator
sub_vec ( InputIterator first, InputIterator last, OutputIterator at, const ElemType &val )
{
	OutputIterator at_begin = at;
	while ( first < last )
		*at++ = *first++;
	OutputIterator at_end = at;
	sort ( at_begin, at_end );
	OutputIterator iter = find_if ( at_begin, at_end, bind2nd ( greater<ElemType>(), val ));
	return iter;
}
这样改写是因为,之前的non-template版本与书中改写的filter()函数最大的不一样就是,需要另外开辟空间保证在不改变原数据的顺序的情况下在副本进行排序。而为了增加函数的弹性和扩大函数可用的范围,就不能按照non-template版本那样,通过语句
vector<int> local_vec( vec );

来建立一个本地的向量。根据Essential C++书中所说,还是采用iterator指针来解决这一问题。虽然这样做可以使函数脱离vector等容器,但走到最后erase一步时,库中没有提供删除的泛型算法,现在还没有想到解决办法,希望知道怎么做的人能留言O(∩_∩)O~。

为了跟书中的filter()函数功能相同,最后加上比较操作,用户可以通过输入比较操作来控制最后留下的数是大于value还是小于value。实现代码如下:

//sub_vec的泛型算法改编的filter()算法
template <	typename InputIterator,	typename OutputIterator,	
					typename ElemType,	typename Comp>
OutputIterator
filter ( InputIterator first, InputIterator last, OutputIterator at, 
				const ElemType &val, Comp pred )
{
	OutputIterator at_begin = at;
	while ( first < last )
		*at++ = *first++;
	OutputIterator at_end = at;
	sort ( at_begin, at_end, pred );
	OutputIterator iter = find_if ( at_begin, at_end, bind2nd ( not2( pred ), val ));
	return iter;
}

下面贴出测试该函数的main函数代码:
int main()
{
	const int element_size = 10;
	int number[ element_size ] = {32, 54, 22, -23, 78, 99, 0, 698, 10, 2};
	vector<int> big_vec ( number, number+element_size );
	int value = 10;
	vector<int> sub_vector( element_size );
	cout << "filtering integer array for values less than " << value << endl;
	vector<int>::iterator iter = filter ( big_vec.begin (), big_vec.end(),  sub_vector.begin() , value, less<int>() );
	if( iter != sub_vector.end() )
		sub_vector.erase( iter , sub_vector.end() );
	for ( int ix = 0; ix < sub_vector.size(); ++ix )
		cout << "element is : " << sub_vector[ix] << endl;

	return 0;
}
需要注意的是,定义的容器一定要定义容量(vector<int> sub_vector(element_size);),否则在编译时会发生错误,初步认为filter()函数中*at++ = *first++;这句话中自加到最后会指向不明地址,编译器无法通过,所以需要定义容器容量。还需注意的是,返回的指针iter,由于需要erase操作,最好先检测是否指针指到容器最后一个指针。

2012-04-01 02:51:23 zhouzhipen 阅读数 3790
  • 数据结构与算法C/C++实现)视频教程

    C/C++实现数据结构与算法视频培训课程全面介绍计算机行业,基本的数据结构与算法,既有理论的深度也有实战的技法。课程全程讲师手敲代码,一步步代你走进数据结构与算法。 本课程涉及的数据结构与算法有,栈,队列,单向链表,双向循环链表,树,二叉树,搜索二叉树,平衡搜索二叉树,冒泡,选择,直插,希尔,,归并等,课程还涉及深度优先算法与广度优先算法等等。

    3982 人正在学习 去看看 王桂林

CSDN论坛升级的时候经常出现的那个无名游戏(原版游戏),我把它移植成C++版的了。

对原来的游戏算法做了少量的修改,也不知道难度有没有提高,反正还是很简单就给围住了。

为了方便修改算法,本游戏中使用了嵌入式脚本,游戏算法全部使用脚本完成。

关于脚本介绍请点这里




目录下的"game.c"是脚本文件,如果有哪位大仙的AI算法精通,可以试着改改。

核心AI算法:

var function ComputerTryMove()
	{
		int x=this->computerPos.x;
		int y=this->computerPos.y;

 		if(x<=0 || y<=0 || x>=this->mapSize || y>=this->mapSize)//检查是否已经到达边界
  			return -1;



//计算八个方向可移动距离
		int d[8]=0;
		int& px=this->mapData[x];
		while(px[--y]==NULL_ID )
			d[0]++;
		if(px[y]==BORDER_ID)
			d[0]=MAX_LENGTH-d[0];

		int& px=this->mapData;
		y=this->computerPos.y;
		while(px[--x][--y]==NULL_ID)
			d[1]++;
		if(px[x][y]==BORDER_ID)
			d[1]=MAX_LENGTH-d[1];

		x=this->computerPos.x;
		y=this->computerPos.y;
		while(px[--x][y]==NULL_ID)
			d[2]++;
		if(px[x][y]==BORDER_ID)
			d[2]=MAX_LENGTH-d[2];

		x=this->computerPos.x;
		while(px[--x][++y]==NULL_ID)
			d[3]++;
		if(px[x][y]==BORDER_ID)
			d[3]=MAX_LENGTH-d[3];

		x=this->computerPos.x;
		y=this->computerPos.y;
		while(px[x][++y]==NULL_ID)
			d[4]++;
		if(px[x][y]==BORDER_ID)
			d[4]=MAX_LENGTH-d[4];

		y=this->computerPos.y;
		while(px[++x][++y]==NULL_ID)
			d[5]++;
		if(px[x][y]==BORDER_ID)
			d[5]=MAX_LENGTH-d[5];

		x=this->computerPos.x;
		y=this->computerPos.y;
		while(px[++x][y]==NULL_ID)
			d[6]++;
		if(px[x][y]==BORDER_ID)
			d[6]=MAX_LENGTH-d[6];

		x=this->computerPos.x;
		while(px[++x][--y]==NULL_ID)
			d[7]++;
		if(px[x][y]==BORDER_ID)
			d[7]=MAX_LENGTH-d[7];


//找出可移动的最长距离或离边界最短距离
		int max=-1;
		for(int i=0;i<8;i++)
		{
			if(d[i]>d[max])
				max=i;
			else if(d[i]==d[max])
			{
				if(Rand(0,1)==1)
					max=i;
			}
		}
		
		if(d[max]==0)
			return 1;

		int& x=this->computerPos.x;
		int& y=this->computerPos.y;


//向找出的最优方向移动
		px[x][y]=NULL_ID;
		switchto(max)
		{
		case 0:
			y--;
		case 1:
			x--;
			y--;
		case 2:
			x--;
		case 3:
			x--;
			y++;
		case 4:
			y++;
		case 5:
			x++;
			y++;
		case 6:
			x++;
		case 7:
			x++;
			y--;
		}

		if(px[x][y]==BORDER_ID)//是否已经到达边界?
		{
			px[x][y]=CPU_ID;
			return -1;
		}
		px[x][y]=CPU_ID;
		return 0;
	}



你赢了之后会放烟花



源码下载
压缩包中有源码(全部工程源码)和编译好的游戏文件。
注意(一定要意):编译工具是VS2008的,上次一个计算器的源码就有很多人用VC6打不开。

下载地址




C/C++电子书列表

阅读数 2606

没有更多推荐了,返回首页