CUDA SDK helps developers to use GPU computing power to c developers. You may find help in SDK about code coloring in Visual Studio. But i am sure many of you have been searching for intellisense for cu and cuh as c files. Here is my solution.
Add c and cuh extensions to NCB Default C/C++ Extensions key under
HKEY_CURRENT_USER\Software\Microsoft\VisualStudio\9.0\Languages\Language Services\C/C++ path
cite: http://www.wizardsofeast.com/?p=378
Homepage: http://www.zoumin.org/
]]>
using namespace std;
#define QUEEN_NUM 8
int position[QUEEN_NUM];//姣忎竴琛岀殑鐨囧悗鏀懼湪絎嚑鍒?/span>
int totalNum=0;
void placeQueen(const int row)//鏀懼湪絎嚑琛?/span>
{
if (row>=QUEEN_NUM)
{
for (int i=0;i<QUEEN_NUM;i++)
{
cout<<position[i]<<" ";
}
cout<<endl;
totalNum++;
return;//鏀劇疆瀹屼簡
}
bool canPutHere=true;
for (int i=0;i<QUEEN_NUM;i++)//媯鏌ュ綋鍓嶈鐨勬瘡涓鍒楁槸鍚︿笌鍓嶉潰宸茬粡鏀劇疆鐨勬煇涓涓殗鍚庡啿紿?/span>
{
canPutHere=true;
for (int r=0;r<row;r++)//宸茬粡鏀句簡row-1涓殗鍚?/span>
{
if (position[r]==i//鍦ㄥ悓涓鍒?/span>
||position[r]==i+r-row//鍦ㄥ悓涓瀵硅綰夸笂
||position[r]==i-(r-row))
{
canPutHere=false;
break;
}
}
if (canPutHere)
{
position[row]=i;
placeQueen(row+1);
}
}
}
void main()
{
placeQueen(0);
cout<<"Total Num: "<<totalNum<<endl;
}Homepage: http://www.zoumin.org/
]]>
#include <string>
using namespace std;
//閲嶆瀯浜屽弶鏍?/span>
struct NODE
{
NODE *pLeft;
NODE *pRight;
char value;
};
NODE* Rebuild(string preOrder,string inOrder)
{
if (preOrder.size()==0)
{
return NULL;
}
NODE* pRoot=new NODE;
(pRoot)->value=preOrder[0];
int root_pos=inOrder.find_first_of(preOrder[0]);//鎵炬牴鑺傜偣鐨勪綅緗?/span>
if (root_pos==-1)
{
return NULL;
}
int left_ele_num=root_pos;
int right_ele_num=preOrder.size()-left_ele_num-1;//length鏄瓧絎﹀簭鍒楃殑闀垮害
pRoot->pLeft=Rebuild(preOrder.substr(1,1+left_ele_num),inOrder.substr(0,left_ele_num));
pRoot->pRight=Rebuild(preOrder.substr(root_pos+1,right_ele_num),inOrder.substr(root_pos+1,right_ele_num));
return pRoot;
}
void preOrder(NODE *root)
{
if (!root)
{
return;
}
cout<<root->value<<" ";
preOrder(root->pLeft);
preOrder(root->pRight);
}
void main()
{
string preorder="abdcef";
string inorder="dbaecf";
NODE *root=Rebuild(preorder,inorder);
preOrder(root);
cout<<endl;
}Homepage: http://www.zoumin.org/
]]>
{
double pivot=Array[left];
int i=left;
double tmp;
for (int j=left+1;j<=right;j++)
{
if (Array[j]<=pivot)
{
i++;
tmp=Array[j];
Array[j]=Array[i];
Array[i]=tmp;
}
}
//exchange A[i],pivot
tmp=Array[left];
Array[left]=Array[i];
Array[i]=tmp;
return i;
}
void K_Big(double* Array,int left,int right,int k,double *dest)//
{
if (k<=0)
{
return;
}
if (right-left+1<=k)
{
memcpy(dest,&Array[left],sizeof(double)*(right-left+1));
return;
}
int p=Partition(Array,left,right);
int right_ele_num=right-p;
if (right_ele_num>=k)//鍙栧彸杈圭殑鍓峩涓?/span>
{
K_Big(Array,p+1,right,k,dest);
}
else{
//鍙栧乏杈圭殑k-right_ele_num-1涓紝鍔犱笂涓棿涓涓?鍐嶅姞涓婂彸杈圭殑right_ele_num涓?/span>
right_ele_num++;//鎶婁腑闂寸殑涓涓篃鍔犺繘鏉ヤ簡銆?/span>
memcpy(&dest[k-right_ele_num],&Array[p],right_ele_num*sizeof(double));
K_Big(Array,left,p-1,k-right_ele_num,dest);
}
}
void main()
{
double A[]={8,4,3,2,6,13,5};
int n=7;
//MergeSort(&A[0],0,6);
//QuickSort(A,0,6);
//HeapSort(A,7);
/*for (int i=0;i<n;i++)
{
cout<<A[i]<<" ";
}*/
double B[5];
int k=5;
K_Big(A,0,6,k,B);
for (int i=0;i<k;i++)
{
cout<<B[i]<<endl;
}
cout<<endl;
delete A;
}Homepage: http://www.zoumin.org/
]]>
void AdjustNode(double *Array,int position,int n)//n鏄暟緇勪腑鍏冪礌鐨勪釜鏁幫紝position鏄綋鍓嶈璋冩暣鐨勪綅緗?/span>
{
int left_child=2*(position+1)-1;
int right_child=2*(position+1);
if (left_child>=n)
{
return;
}
double tmp;
if (Array[position]<Array[left_child])
{
tmp=Array[position];
Array[position]=Array[left_child];
Array[left_child]=tmp;
AdjustNode(Array,left_child,n);
}
if (Array[position]<Array[right_child])
{
tmp=Array[position];
Array[position]=Array[right_child];
Array[right_child]=tmp;
AdjustNode(Array,right_child,n);
}
}
void HeapSort(double *Array,int n)
{
for (int i=n/2;i>=0;i--)
{
AdjustNode(Array,i,n);
}
double tmp;
for (int i=0;i<n;i++)
{
tmp=Array[0];//姣忔鍙栨牴鑺傜偣鍏冪礌
Array[0]=Array[n-i-1];//鎶婃渶鍚庝竴涓厓绱犳斁鍒版牴鑺傜偣涓?/span>
Array[n-i-1]=tmp;//鎶婃帓濂藉簭鐨勬暟瀛楁斁鍒板悗闈?/span>
AdjustNode(Array,0,n-i-1);
}
}
{
int left_child=2*(position+1)-1;
int right_child=2*(position+1);
if (left_child>=n)
{
return;
}
double tmp;
if (Array[position]<Array[left_child])
{
tmp=Array[position];
Array[position]=Array[left_child];
Array[left_child]=tmp;
AdjustNode(Array,left_child,n);
}
if (Array[position]<Array[right_child])
{
tmp=Array[position];
Array[position]=Array[right_child];
Array[right_child]=tmp;
AdjustNode(Array,right_child,n);
}
}
void HeapSort(double *Array,int n)
{
for (int i=n/2;i>=0;i--)
{
AdjustNode(Array,i,n);
}
double tmp;
for (int i=0;i<n;i++)
{
tmp=Array[0];//姣忔鍙栨牴鑺傜偣鍏冪礌
Array[0]=Array[n-i-1];//鎶婃渶鍚庝竴涓厓绱犳斁鍒版牴鑺傜偣涓?/span>
Array[n-i-1]=tmp;//鎶婃帓濂藉簭鐨勬暟瀛楁斁鍒板悗闈?/span>
AdjustNode(Array,0,n-i-1);
}
}
]]>
{
double pivot=Array[left];
int i=left;
double tmp;
for (int j=left+1;j<=right;j++)
{
if (Array[j]<=pivot)
{
i++;
tmp=Array[j];
Array[j]=Array[i];
Array[i]=tmp;
}
}
//exchange A[i],pivot
tmp=Array[left];
Array[left]=Array[i];
Array[i]=tmp;
return i;
}
void QuickSort(double *Array,int left,int right)
{
if (left>=right)
{
return;
}
int p=Partition(Array,left,right);
QuickSort(Array,left,p-1);
QuickSort(Array,p+1,right);
}
void main()
{
double A[]={8,4,3,2,6,13,5};
int n=7;
//MergeSort(&A[0],0,6);
QuickSort(A,0,6);
for (int i=0;i<n;i++)
{
cout<<A[i]<<" ";
}
cout<<endl;
delete A;
}Homepage: http://www.zoumin.org/
]]>
#include <iostream>
using namespace std;
void MergeSort(double *Array,int left,int right)
{
if (left>=right)//鍙湁涓涓厓绱狅紝涓嶇敤鎺掑簭
{
return;
}
int middle=(left+right)/2;
MergeSort(Array,left,middle);
MergeSort(Array,middle+1,right);
//褰掑茍
int left_pointer=left;
int right_pointer=middle+1;
double *mergeArray=new double[right-left+1];
int new_array_pointer=0;
while (left_pointer<=middle&&right_pointer<=right)
{
if (Array[left_pointer]<=Array[right_pointer])
{
mergeArray[new_array_pointer++]=Array[left_pointer++];
}
else {
mergeArray[new_array_pointer++]=Array[right_pointer++];
}
}
//鍒ゆ柇涓涓嬫槸閭ｈ竟鐨勬暟緇勫厛璇誨畬浜?/span>
if (left_pointer<=middle)//鍙寵竟鐨勫厛璇誨畬浜?/span>
{
memcpy(&mergeArray[new_array_pointer],&Array[left_pointer],(middle-left_pointer+1)*sizeof(double));
}
else{//宸﹁竟鐨勮瀹屼簡
memcpy(&mergeArray[new_array_pointer],&Array[right_pointer],(right-right_pointer+1)*sizeof(double));
}
memcpy(&Array[left],&mergeArray[0],(right-left+1)*sizeof(double));
delete mergeArray;
}
void main()
{
double A[]={2,4,3,8,6,13,5};
int n=7;
MergeSort(&A[0],0,6);
for (int i=0;i<n;i++)
{
cout<<A[i]<<" ";
}
cout<<endl;
delete A;
}
]]>
]]>