return0;
}
*6string类的编写
#include
usingnamespacestd;
classString
{
public:
String（constchar*str=NULL）;//普通构造函数
String（constString&other）;//拷贝构造函数
~String（void）;//析构函数
String&operator=（constString&other）;//赋值函数
String&operate+（constString&s1,constString&s2）;//加法函数
private:
char*m_data;
};
//普通构造函数
String:
:
String（constchar*str）
{
if（str==NULL）
{
m_data=newchar[1];
*m_data='\0';
}
else
{
intlenth=strlen（str）;
m_data=newchar[lenth+1];
strcpy（m_data,str）;
}
}
//拷贝构造函数
String:
:
String（constString&other）
{
intlenth=strlen（other.m_data）;
m_data=newchar[lenth+1];
strcpy（m_data,other.m_data）;
}
//析构函数
String:
:
~String（）
{
delete[]m_data;
}
//赋值函数
String&String:
:
operator=（constString&other）
{
//检查自赋值
if（this=&other）
{
return*this;
}
//释放原有资源
delete[]m_data;
//分配新的内存资源，并赋值
intlen=strlen（otehr.m_data）;
m_data=newchar[len+1];
strcpy（m_data,other.m_data）;
//返回本对象的引用
return*this;
}
//加法函数
String&operator+（constString&s1,constString&s2）
{
Stringtemp;
deletetemp.data;//temp.data是仅含‘\0’的字符串
temp.data=newchar[strlen（s1.data）+strlen（s2.data）+1];
strcpy（temp.data,s1.data）;//data为char*型的数据成员。
strcat（temp.data,s2.data）;
returntemp;
}
//便于理解上述代码，写出main函数
intmain（void）
{
Stringstr_a=newString（）;//调用构造函数
Stringstr_b=newString（“abc”）;
Stringstr_c=str_b;//调用拷贝构造函数
str_c=str_a;/赋值
Stringsrt_d;
str_d=str_c+str_b;
}
7.写出在母串中查找子串出现次数的代码。
思路：
从第一个字符开始查找，然后逐个比较两个字符串是否相同，直到子字符串结束都相同则表明找到一次，num+1,然后第二个字符开始。
。
重复
intcount（char*str,char*substr）
{
char*str1;
char*str2;
intnum=0;
while（*str!
='\0'）
{
str1=str;
str2=substr;
while（*str2==*str1&&（*str2!
='\0'）&&（*str1!
='\0'））
{
str2++;
str1++;
}
if（*str2=='\0'）
num++;
str++;
}
returnnum;
}
*8.写函数完成内存的拷贝
一个内存拷贝函数的实现体
void*memcpy（void*pvTo,constvoid*pvFrom,size_tsize）
{
assert（（pvTo!
=NULL）&&（pvFrom!
=NULL））;
byte*pbTo=（byte*）pvTo;//防止地址被改变
byte*pbFrom=（byte*）pvFrom;
while（size-->0）
*pbTo++=*pbForm++;
returnpvTo;
}
*9.将一个数字字符串转换为数字."1234"-->1234
＃include
usingnamespacestd;
intf（char*s）
{
intk=0;
while（*s!
=‘\0’）
{
k=10*k+（*s++）-'0';//k每乘以1次10，则位数左移一位（如个位变成10位）
}
returnk;
}
intmain（）
{
intdigit=f（"4567"）;
cout<cin.get（）;
}
10.求1000！
的末尾有几个0
（用素数相乘的方法来做，如72=2*2*2*3*3）;求出1->1000里,能被5整除的数的个数n1,能被25整除的数的个数n2,能被125整除的数的个数n3,能被625整除的数的个数
n4.1000!
末尾的零的个数=n1+n2+n3+n4;
#include
#defineNUM1000
intfind5（intnum）
{
intret=0;
while（num%5==0）
{
num/=5;
ret++;
}
returnret;
}
intmain（）
{
intresult=0;
inti;
for（i=5;i<=NUM;i+=5）
{
result+=find5（i）;
}
printf（"thetotalzeronumberis%d\n",result）;
return0;
}
11.写一个函数找出一个整数数组中，第二大的数。
constintMINNUMBER=-32767;
intfind_sec_max（intdata[],intcount）
{
intmaxnumber=data[0];
intsec_max=MINNUMBER;
for（inti=1;i{
if（data[i]>maxnumber）
{
sec_max=maxnumber;
maxnumber=data[i];
}
else
{
if（data[i]>sec_max）
sec_max=data[i];
}
returnsec_max;
}
12.用递归算法判断数组a[N]是否为一个递增数组。
递归的方法，记录当前最大的，并且判断当前的是否比这个还大，大则继续，否则返回false结束：
boolfun（inta[],intn）
{
if（n==1）
{
returntrue;
}
if（n==2）
{
returna[n-1]>=a[n-2];
}
returnfun（a,n-1）&&（a[n-1]>=a[n-2]）;//递归的同时要保证上一次的条件成立
}
13.选择排序
算法思想简单描述：
在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。
选择排序是不稳定的。
算法复杂度O（n2）--[n的平方]【外层循环n-1趟，内层（第i+1趟）循环n-i-1次】【对比冒泡排序：
外层循环n-1趟，内层（第i趟）循环n-i-1次】
voidselect_sort（int*x,intn）
{
inti,j,min,t;
for（i=0;i共n-1次*/
{
min=i;/*假设当前下标为i的数最小（从0开始，逐步加1），比较后再调整*/
for（j=i+1;j{
if（*（x+j）<*（x+min））
{
min=j;/*如果后面的数比前面的小，则记下它的下标*/
}
}
if（min!
=i）/*如果min在循环中改变了，就需要交换数据*/
{
t=*（x+i）;
*（x+i）=*（x+min）;
*（x+min）=t;
}
}
}
14直接插入排序
算法思想简单描述：
在要排序的一组数中，假设前面（n-1）[n>=2]个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。
如此反复循环，直到全部排好顺序。
直接插入排序是稳定的。
算法时间复杂度O（n2）--[n的平方]【直接插入，冒泡，选择排序的时间复杂度一样】
voidinsert_sort（int*x,intn）
{
inti,j,t;
for（i=1;i1~n共n-1次
{
/*暂存下标为i的数。
注意：
下标从1开始，原因就是开始时,第一个数即下标为0的数，前面没有任何数，单单一个，认为它是排好顺序的，方便下面的for循环下标的书写。
*/
t=*（x+i）;
for（j=i-1;j>=0&&t<*（x+j）;j--）/*注意：
j=i-1，j--，这里就是在下标为i的数后面有序列中找插入位置。
【这里的后面指的是右边】*/
{
*（x+j+1）=*（x+j）;/*如果满足条件就往后挪。
最坏的情况就是t比下标为0的数都小，它要放在最前面，j==-1，退出循环*/
}
*（x+j）=t;/*找到下标为i的数的放置位置【改变参考点】*/
}
}
看到这里
15冒泡排序
16.文件中有一组整数，要求排序后输出到另一个文件中。
#include
#include
usingnamespacestd;
voidOrder（vector&data）//bubblesort
{
intcount=data.size（）;
inttag=false;//设置是否需要继续冒泡的标志位
for（inti=0;i{
for（intj=0;j{
if（data[j]>data[j+1]）
tag=true;
inttemp=data[j];
data[j]=data[j+1];
data[j+1]=temp;
}
}
if（!
tag）
{
break;
}
}
intmain（void）
{
vectordata;
ifstreamin（"c:
\\data.txt"）;
if（!
in）
{
cout<<"fileerror!
";
exit
（1）;
}
inttemp;
while（!
in.eof（））
{
cin>>temp;
data.push_back（temp）;
}
in.close（）;//关闭输入文件流
Order（data）;
ofstreamout（"c:
\\result.txt"）;
if（!
out）
{
cout<<"fileerror!
";
exit
（1）;
}
for（i=0;i{
out<out.close（）;//关闭输出文件流
}
}
17.输入一个字符串，将其逆序后输出。
（使用C++，不建议用伪码）
#include
usingnamespacestd;
voidmain（）
{
chara[50];
memset（a,0,sizeof（a））;
inti=0,j;
chart;
cin.getline（a,50,'\n'）;
for（i=0,j=strlen（a）-1;i{
t=a[i];
a[i]=a[j];
a[j]=t;
}
cout<}
18.链表题
1）编程实现一个单链表的建立。
#include
#include
#include
#include
usingnamespacestd;
typedefstructstudent
{
intdata;
structstudent*next;
}node;
node*Create（void）
{
node*head=NULL;
node*p=NULL;
node*s=NULL;
intx,cycle=1;
head=（node*）malloc（sizeof（node））;
p=head;
printf（"pleaseintputthedata:
"）;
scanf（"%d",&x）;
p->data=x;
p->next=NULL;
while（cycle）
{
printf（"pleaseintputthedata:
"）;
scanf（"%d",&x）;
if（x!
=0）
{
s=（node*）malloc（sizeof（node））;
s->data=x;
printf（"\n%d",s->data）;
p->next=s;
p=s;
}
else
{
cycle=0;
}
}
p->next=NULL;
printf（"\nyyy%d",head->data）;
returnhead;
}
intmain（void）
{
Create（）;
return0;
}
2）实现单链表的测长[双链表的测长也是一样]
intCaculateLenth（structstudent*head）
{
structstudent*p=NULL;
p=head;
intn=0;
while（p!
=NULL）
{
n++;
p=p->next;
}
returnn;
}
3）编程实现单链表的打印[双链表也是一样的]
voidShow（structstudent*head）
{
structstudent*p=NULL;
p=head;
intn=0;
while（p!
=NULL）
{
cout<data<p=p->next;
}
}
4）编程实现单链表删除节点
解题思路：
先遍历比较值，找到要删除节点后再判断是否为头节点，还是后面的节点【删除中间的节点和删除末尾的节点是一个样的】。
node*Delete（structstudent*head,intnum）
{
structstudent*p1=NULL;
structstudent*p2=NULL;
p1=head;
while（num!
=p1->data&&p1->next!
=NULL）
{
p2=p1;
p1=p1->next;
}
if（num==p1->data）
{
if（p1==head）//删除的是头节点
{
head=p1->next;
free（head）;
}
else//删除的是头结点后面的节点
{
p2->next=p1->next;
free（p1）;
}
}
else
{
cout<<"thenumhasn'tbeenfound"<}
returnhead;
}
5）编程实现单链表的插入
解析：
如果插入在节点以前，则p0的next指向p1,投节点指向p0,如下图所示
如果插入尾节点，如下图所示。
解题思路：
先遍历对比关键值，找到后再判断在第一个节点前插入还是中间插入还是最后面插入。
node*Insert（node*head,intnum）
{
node*p0,*p1,*p2;
p1=head;
p0=（node*）malloc（sizeof（node））;
p0->data=num;
while（p0->data>p1->data&&p
升级会员 