计算机基础知识文档格式.docx
《计算机基础知识文档格式.docx》由会员分享，可在线阅读，更多相关《计算机基础知识文档格式.docx（184页珍藏版）》请在冰豆网上搜索。
j++）{
num+=arr[j];
if（num<
=t）{
count++;
for（intk=c;
k<
k++）{
num-=arr[k-c];
num+=arr[k];
}
3.结构体定义的使用
1）structnode
intnum;
structnode*next;
};
此时定义node结构体变量时，必须写成structnode*nod；
2）typedefstructnode
}node;
此时定义node结构体变量时，可以写成node*nod；
同时必须注意后面必须加上冒号，这是一个语句。
二、字符串处理
1.字符串的定义：
1）charstr1[]="
HelloWorld"
;
//通过字符数组来定义字符串"
，其实包含两个存储空间：
1.首先是在栈去分配了一段存储空间，用来存储字符串；
2.同时此常量字符串存储在静态数据区。
2）char*str2
="
//通过字符指针来定义字符串"
，其也包含两个存储空间：
1.首先是在栈上为指针分配存储空间，用来存放指针变量；
2.同时常量字符串存储在静态数据区。
3）#definestr3"
//通过宏定义来定义字符串"
，等价于str3="
2.字符串的输入：
1）常规字串输入：
采用scanf（）函数实现输入操作：
必须要取地址，将字符串存入地址中；
其不能识别空格，tab等按键。
2）带空格的字串输入
采用gets（）函数实现输入操作：
可以识别空格和tab等按键；
其变量只要是地址名字即可，不要写成取地址的方式；
由于scanf（）输入字符串时默认空格作为结束符，故要输入带有空格的字符串时，采用以下格式：
scanf（"
%[^\n]"
str）。
3.字符串的输出：
1）常规字串输出
printf（"
%s"
a[i]）;
它的输出是从a中第i号字符开始输出，直到字符串结束符'
\0'
输出结束。
2）固定长度字串输出：
须知字串长度，采用循环输出
3）带空格字串输出：
4.字符串作为参数传递：
1）传递的是地址，数组也是一样，传递的是地址；
2）对于结构体变量而言，要操作结构内部变量，必须根据地址来操作；
3）操作数的位数最大为64位，故要实现结构体的单位操作，必须重新编写操作函数。
5.字符串函数的使用：
字符串函数大全见：
附录1：
字符串函数大全
1）将字符串转换成数值；
实现方式一
doubleatoi（intn,char*str）
intlen=n;
doublenum=0;
//定义变量时，一定要初始化
for（inti=0;
i<
len;
i++）
num+=（str[i]-'
0'
）*pow（10.0,--len）;
//pow（）函数返回的是double型，故num必须定义为double型，或者对pow（）函数进行强制类型转换
returnnum;
实现方式二
num=num*10+str[i]-'
；
问题：
1.为什么要减去'
?
曰：
计算器存储运算时，均采用的是二进制表示，故对于所有的字母和常用符号，必须约定自己的一套编码规则，于是ASCII码应运而生。
而特别是对于数字，ASCII和整型之间相差的数值是48，即一个'
字符。
而对于ASCII和数值其显示结果是没有任何区别的，即对于显示，其采用的二进制数值是一样的，而两者的不同，主要在于应用运算上的不同，此时的值也是不同的。
2.当数值超过double的范围时，即大数怎么处理？
此时只能做简单的显示，如果是要做运算，必须采用字符的形式来重新进行运算法则的编写。
2）将数值转换成字符串
char*itoa（intm,char*a）
inti;
while（m>
0）
a[i++]=m%10+'
m/=10;
returna;
charb[11]="
0123456789"
inti=0;
%d"
&
m）;
a[i++]=b[m%10];
6.字符串数组的操作
在C++中string可以直接当做变量来处理；
可以通过newstring[n]来申请器长度；
3>
对于string字符串的传递可以跟变量的传递一样操作；
4>
具体实现如下：
intstringPrint（intnum,conststringstr[]）
for（inti=0;
num;
cout<
<
str[i]<
endl;
return0;
intmian（void）
string*p;
cin>
>
p=newstring[num];
p[i];
stringPrint（num,p）;
delete[]p;
//对于申请的连续地址空间释放时一定要注意
三、数据结构
1.数组
1）数组定义：
数组定义时，必须指定大小，从而编译器为其分配固定大小的内存空间，内存连续分配；
2）数组初始化：
最好为其初始化，如果没有初始化，其会保存垃圾数据；
3）数组的输入：
数组实现数据输入时，一般采用循环输入；
4）数组的输出：
输出一般也采用循环输出；
5）数组作为参数传递：
数组做参数，无法按值传递。
这是由C/C++函数的实现机制决定的。
传数组给一个函数，数组类型自动转换为指针类型，因而传的实际是地址,因此对其进行操作时，可以对数组值进行修改。
所以为了避免数组值的修改，应该使用const固定。
下面三种函数声明完全等同：
voidfunc（constintarray[10]）
voidfunc（constintarray[]）
voidfunc（constint*array）
2.链表
1）定义：
一种物理存储单元上非连续、非顺序的存储结构。
2）优势：
不定长，可以根据数据存储需要，不断添加和删除；
存储空间不用连续。
3）链表的一般操作：
1）链表的创建：
a.创建一个新节点node
nod=（node*）malloc（sizeof（node））;
nod->
val=val;
next=NULL;
/*判断内存分配是否为空*/
if（nod==NULL）
b.头指针head，用于对单向链表的遍历,该地址指向链表的头部
if（head=NULL）
head=nod;
c.位置指针p，保存指针位置
p->
next=nod;
p=nod;
2）链表的插入：
a.对于单向链表，先从头开始遍历，找到要操作节点的前一个节点
node*listInsert（node*head,intk）
inti=2;
node*p=NULL;
node*nod=NULL;
p=head;
/*输入查询节点数必须大于0*/
if（k<
1）
returnNULL;
/*当输入为1时，查询的是头节点*/
if（k==1）
next=p;
returnhead;
while（p!
=NULL&
k）
p=p->
next;
next=p->
p-next=nod;
3）链表的删除：
node*listDelete（node*head,intk）
node*q=NULL;
head=nod->
free（p）;
/*开始查询要删除的节点的前一个节点*/
q=p->
next=q->
free（q）;
4）链表的打印：
intlistPrint（node*head）
while（head!
=NULL）
%x--%d"
head,head->
val）;
head=head->
5）链表的逆序打印
递归实现
intprintList1（Node*head）
if（head!
=NULL）
if（head->
next!
printList1（head->
next）;
head->
val<
"
--0x"
<
head<
堆栈实现
intprintList2（Node*head）
stack<
Node*>
st;
while（head!
st.push（head）;
head=head->
while（!
st.empty（））
st.top（）->
st.top（）<
st.pop（）;
6）链表的逆序实现
Node*ReverseLink（Node*head）
Node*prev=NULL;
Node*next;
{
next=head->
head->
next=prev;
prev=head;
head=next;
returnprev;
4.要及时释放内存空间，malloc（）和free（）两个函数要配合使用。
3.栈
先进后出,限定只能在表的一端进行插入和删除操作的线性表;
2）线性表分类：
顺序线性表（也就是用数组实现的,在内存中顺序排列,通过改变数组序号来实现压栈和出栈）
a.定义一个结构体,保存栈的基本信息
typedefstructsqStack
intsize;
int*sp;
int*top;
}sqStack;
b.栈初始化，定义栈的大小和指针
intstackInit（sqStacks）
s->
top=（int*）malloc（sizeof（int）*n）;
sp=s->
top;
c.压栈
intpush（sqStack*s,intval）
sp++;
d.出栈
intpop（sqStack*s）
intval=0;
sp--;
val=s->
val;
returnval;
链表（主要是对链表表头进行操作）
a.定义一个结构体,作为栈的节点
intval;
structsqStack*next;
b.栈初始化
sqStack*stackInit（）
sqStack*s;
returns;
sqStack*push（sqStack*s,intval）
sqStack*nod=NULL;
nod=（sqStack*）malloc（sizeof（sqStack））;
next=s;
s=nod;
sqStack*pop（sqStack*s）
nod=s;
s=s->
free（nod）;
栈的实现：
可以采用两种方式，可以分别采用顺序表或者链表实现。
应用：
a.四则运算
b.符号检测
4.队列
先进先出,限定只能在表的一端进行插入和在另一端进行删除操作的线性表;
2）队列的实现：
3）应用：
5.二叉树
1）基本概念：
定义：
每个结点最多有两棵子树，左子树和右子树，次序不可以颠倒
性质：
a.非空二叉树的第n层上至多有2^（n-1）个元素
b.深度为h的二叉树至多有2^h-1个结点
其他概念：
a.满二叉树：
b.完全二叉树：
2）存储结构
顺序存储：
将数据结构存在一块固定的数组中
#defineLENGTH100
typedefchardatatype;
typedefstructnode
{
datatypedata;
intlchild,rchild;
intparent;
}Node;
Nodetree[LENGTH];
intlength;
introot;
链式存储：
typedefstructBinNode
structBinNode*lchild;
structBinNode*rchild;
}BinNode;
typedefBinNode*bintree;
//bintree本身是个指向结点的指针
3）二叉树的遍历
前序遍历：
根节点->
左子树->
右子树
中序遍历：
后序遍历：
右子树->
根节点
4）遍历的实现
二叉树的创建
a.创建二叉树节点
typedefstructBiTree
charchr;
structBiTree*lchild;
structBiTree*rchild;
}BiTree;
b.创建二叉树
BiTree*CreateBiTree（）
BiTree*T=NULL;
%c"
chr）;
if（chr!
='
'
T=（BiTree*）malloc（sizeof（BiTree））;
if（T==NULL）
Memoryisfailed!
\n"
）;
T->
chr=chr;
lchild=CreateBiTree（）;
rchild=CreateBiTree（）;
returnT;
前序遍历
intpreOlderTraverse（BiTree*T）
if（T）
T->
preOlderTraverse（T->
lchild）;
rchild）;
中序遍历
intinOlderTraverse（BiTree*T）
inOlderTraverse（T->
后序遍历
intpostOlderTraverse（BiTree*T）
postOlderTraverse（T->
非递归实现
创建堆栈
a.创建节点
BiTree*Bt;
structsqStack*sp;
b.push（）函数实现
intpush（sqStack**S,BiTree*Bt）
sqStack*Stack=NULL;
Stack=（sqStack*）malloc（sizeof（sqStack））;
if（Stack==NULL）
Stack->
Bt=Bt;
Bt->
lchild=Bt->
lchild;
rchild=Bt->
rchild;
sp=（*S）;
（*S）=Stack;
c.pop（）函数实现
BiTree*pop（sqStack**S）
BiTree*Bt=NULL;
Bt=（*S）->
Bt;
Stack=（*S）;
（*S）=（*S）->
sp;
free（Stack）;
returnBt;
#'
Memroyisfailed!
intpreOlderVisitBiTree（sqStack*S,BiTree*T）
if（!
T）
TheBiTreeisempty!
while（T||S）
while（T）
push（&
S,T）;
T=T->
T=pop（&
S）;
intinOlderVisitBiTree（sqStack*S,BiTree*T）
升级会员 