亚洲av综合avav中文,亚洲精品无码MV在线观看,亚洲欧洲第一a在线观看

matthew — Sun, 05 Nov 2006 08:58:00 GMT

"回文"是指��和反��d��定w��相同的字�W�串�Q�如�Q?ABCCBA"�Q�这里引入两个指针变量，开始时�Q?br />
分别指向字符串的首末字符�Q�当两个指针所指字�W�相�{�时�Q�两指针分别向前向后�U�M��个字�W�位�|�，

�q��l�比较，直到两指针相遇．则说明该字符串是回文�Q�若比较�q�程中，发现两字�W�不相等�Q�则

可以判断该字�W�串不是回文�Q?br />
代码如下�Q?br />
/*判断字符串是否是回文*/

#include
#define MAX 50
int cycle(char *s)
{
char *h,*t;
for(h=s,t=s+strlen(s)-1;t>h;h++,t--)
{
    if(*h!=*t)
    {
        printf("%c",h);
        break;
    }
}
return t<=h;
}

main()
{
char s[MAX];
while(1)
{
    puts("Please input the string you want to judge(input ^ to quit):");
    scanf("%s",s);
    if(s[0]=='^')
      break;
    if(cycle(s))
    printf("%s is a cycle string.\n",s);
    else
    printf("%s is not a cycle string.\n",s);
}
puts("\nThank you for you using ,bye bye!\n");
}

输出�l�果�Q?br />
Please input the string you want to judge(input ^ to quit):
abcabc
abcabc is not a cycle string.
Please input the string you want to judge(input ^ to quit):
abccba
abccba is a cycle string.
Please input the string you want to judge(input ^ to quit):

matthew 2006-11-05 16:58 发表评论

C语言的�؜合输入数字和字符问题

matthew — Fri, 03 Nov 2006 06:12:00 GMT

　假如你的�E�序同时需要��用getchar()�q�行字符输入和��?scanf()�q�行数字输入�Q�这两个函数的每一个都能很好的完成工作�Q?br />但是它们不能很好地�؜合在一��P��q�是因�ؓgetchar()��d��每个字符�Q�包括空��|��制表�W�和换行�W�；而scanf()在读取数字时候则
会蟩�q�空��|��制表�W�和换行�W�．下面是个例子�Q?br />char1.cpp
/*C语言一个I/O问题�E�序*/
#include
void display(char cr,int lines,int width);
int main(void)
{
int ch;
int rows,cols;
printf("Enter a character and tow integers:\n");
while((ch=getchar())!='\n')
{
scanf("%d %d",&rows,&cols);
display(ch,rows,cols);

     printf("Enter another character and tow integers;\n");
     printf("Enter a newline to quit.\n");
}
printf("Bye.\n");
return 0;
}
void display(char cr,int lines,int width)
{
int row ,col;
for(row =1;row<=lines;row++)
{
    for(col=1;col<=width;col++)
    {
      putchar(cr);
       }
      putchar('\n');

}
}
�l�果输出�Q?br /> Enter a character and tow integers:
d 3 2
dd
dd
dd
Enter another character and tow integers;
Enter a newline to quit.
Bye.
Press any key to continue...

　可以看见紧跟�?后面的那个换行符�Q�scanf()函数��该换行�W�留在了输入队列中．而getchar()�q�不跌��换行�W�，所以在循环�?br />下一周期�Q�在你有��Z��输入其他内容之前�Q�这个换行符由getchar()��d��Q�然后将其赋值给ch�Q�而ch为换行符正是�l�止循环的条�Ӟ��

　要解册��个问题，必须跌��一个输入周期中键入的最后一个数字与下一行开始处键入的字�W�之间的所有换行符或空��|��
改进如下�Q?strong>char2.cpp

/*C语言一个I/O问题�E�序修改版本*/
#include
void display(char cr,int lines,int width);
int main(void)
{
int ch;
int rows,cols;
printf("Enter a character and tow integers:\n");
while((ch=getchar())!='\n')
{
    if( scanf("%d %d",&rows,&cols)!=2)
    break;
     display(ch,rows,cols);
     while(getchar()!='\n')      /*剔除掉scanf()输入后的所有字�W�．*/
     {

printf("1"); /*后面有多��字�W�就输出多少�?*/
continue;

     }
     printf("Enter another character and tow integers;\n");
     printf("Enter a newline to quit.\n");
}
printf("Bye.\n");
return 0;
}
void display(char cr,int lines,int width)
{
int row ,col;
for(row =1;row<=lines;row++)
{
    for(col=1;col<=width;col++)
    {
      putchar(cr);
       }
      putchar('\n');

}
}

输出�l�果�Q?br />Enter a character and tow integers:
d 3 4
dddd
dddd
dddd
Enter another character and tow integers;
Enter a newline to quit.
d 3 4
dddd
dddd
dddd
11Enter another character and tow integers;
Enter a newline to quit.

matthew 2006-11-03 14:12 发表评论

matthew — Thu, 02 Nov 2006 11:13:00 GMT

下面是个关于递归调用��单但是很能说明问题的例子�Q?br />
/*递归例子*/
#include
void up_and_down(int);
int main(void)
{
up_and_down(1);
return 0;
}
void up_and_down(int n)
{
printf("Level %d:n location %p\n",n,&n); /* 1 */
if(n<4)
up_and_down(n+1);
printf("Level %d:n location %p\n",n,&n); /* 2 */
}

输出�l�果
Level 1:n location 0240FF48
Level 2:n location 0240FF28
Level 3:n location 0240FF08
Level 4:n location 0240FEE8
Level 4:n location 0240FEE8
Level 3:n location 0240FF08
Level 2:n location 0240FF28
Level 1:n location 0240FF48

　首先�Q?/span> main() 使用参数 1 调用了函�?/span> up_and_down() �Q�于�?/span> up_and_down() 中�Ş式参�?/span> n 的值是 1, 故打印语�?/span> #1 输出�?/span> Level1 �?br />然后�Q�由�?/span> n 的数值小�?/span> 4 �Q�所�?/span> up_and_down() �Q�第 1 �U�）使用参数 n+1 ��x��?/span> 2 调用�?/span> up_and_down()( �W?/span> 2 �U?/span> ). 使得 n 在第 2
�U�调用中被赋�?/span> 2, 打印语句 #1 输出的是 Level2 。与之类��|��下面的两�ơ调用分别打印出 Level3 �?/span> Level4 �?br />

　当开始执行第 4 �U�调用时�Q?/span> n 的值是 4 �Q�因�?/span> if 语句的条件不满��。这时候不再��l�调�?/span> up_and_down() 函数。第 4 �U�调用接
着执行打印语句 #2 �Q�即输出 Level4 �Q�因�?/span> n 的值是 4 。现在函数需要执�?/span> return 语句�Q�此时第 4 �U�调用结束，把控制权�q�回�l�该
函数的调用函敎ͼ�也就是第 3 �U�调用函数。第 3 �U�调用函��C��前一个执行过的语句是�?/span> if 语句中进行第 4 �U�调用。因此，它��
�l�执行其后��代码�Q�即执行打印语句 #2 �Q�这��会输出 Level3 �Q�当�W?/span> 3 �U�调用结束后�Q�第 2 �U�调用函数开始��l�执行，卌��?br /> Level2 �Q�依�ơ类推．

　注意�Q�每一�U�的递归都��用它自己的私有的变量 n �Q�可以查看地址的值来证明�Q?br />

递归的基本原理：

�Q�　每一�ơ函数调用都会有一�ơ返回．当程序流执行到某一�U�递归的结��֤��Ӟ��它会转移到前一�U�递归�l�箋执行�Q?/span>

�Q�　递归函数中，位于递归调用前的语句和各�U�被调函数具有相同的��序�Q�如打印语句 #1 位于递归调用语句前，它按照�?br />　　归调用的��序被执行了 4 �ơ．

�Q�　每一�U�的函数调用都有自己的私有变量．

�Q�　递归函数中，位于递归调用语句后的语句的执行顺序和各个被调用函数的��序相反�Q?/span>

�Q�　虽然每一�U�递归有自��q��变量�Q�但是函��C��码�ƈ不会得到复制�Q?/span>

�Q�　递归函数中必��d��含可以终止递归调用的语句．

再看一个具体的递归函数调用的例子：以二�q�制形式输出整数

/*输入一个整敎ͼ�输出二进制�Ş�?/
#include
void to_binary(unsigned long n);

int main(void)
{
unsigned long number;
printf("Enter an integer(q to quit):\n");
while(scanf("%ul",&number)==1)
{
    printf("Binary equivalent :");
    to_binary(number);
    putchar('\n');
    printf("Enter an integer(q to quit):\n");
}
printf("Done.\n");
return 0;

}
void to_binary(unsigned long n)    /*递归函数*/
{
int r;
r=n%2;    /*在递归调用之前计算n%2的数��|��然后在递归调用语句之后�q�行输出�Q�这�?br /> 　　　　　　计算出的�W�一个数值反而是在最后一个输�?/
if(n>=2)
to_binary(n/2);
putchar('0'+r);/*如果r�?�Q�表辑ּ�'0'+r��是字符'0'�Q�如果r�?�Q�则表达式的��gؓ
　　　　　　　　　'1'�Q�注意前提是字符'1'的数值编码比字符'0'的数值编码大1�Q?br /> 　　　　　　　　　ASCII和EBCDIC�q�两�U�编码都满��q�个条�g�Q?/
return;
}

输出�l�果为：

Enter an integer(q to quit):
9
Binary equivalent :1001
Enter an integer(q to quit):
255
Binary equivalent :11111111
Enter an integer(q to quit):

matthew 2006-11-02 19:13 发表评论

matthew — Tue, 31 Oct 2006 10:50:00 GMT

1、徏立目标串s和模式串t
2、采用简单算法求t在s中的位置
3、由模式串t求出next值和nextval�?br />4、采用KMP��法和KMP改进��法求t在s中的位置

代码如下�Q?br />#include
#include
#define MaxSize 100

typedef struct
{
char ch[MaxSize];
int len;
}SqString;

int Index(SqString s,SqString t)/* ��单匹配方�?/
{
int i=0,j=0,k;
while(i {
    if(s.ch[i]==t.ch[j])/*�l�箋匚w��下一个字�W?/
{
   i++;
   j++;
}
else/*子串、主串的指针回溯重新开始下一�ơ匹�?/
{
i=i-j+1;
j=0;
}
}
if(j>=t.len)/*匚w��成功�Q�返回匹配的�W�一个字�W�下�?/
   k=i-t.len;
else/*匚w��不成�?/
   k=-1;
return k;
}

void GetNext(SqString t,int next[])/*由模式串t求出next�?/
{
int j,k;
j=0;k=-1;next[0]=-1;
while(j {
   if(k==-1||t.ch[j]==t.ch[k])
   {
     j++;k++;
     next[j]=k;
   }
   else k=next[k];
}
}

void GetNextval(SqString t,int nextval[])/*由模式串t求出nextval�?/
{
   int j=0,k=-1;
   nextval[0]=-1;
   while(j   {
    if(k==-1||t.ch[j]==t.ch[k])
    {
      j++;k++;
   if(t.ch[j]!=t.ch[k])

    nextval[j]=k;
   else
       nextval[j]=nextval[k];

   }
   else k=nextval[k];

   }
}
int KMPIndex(SqString s,SqString t)/*KMP��法*/
{
   int next[MaxSize];
   int i=0,j=0;
   int v;
   GetNext(t,next);
   while(i   {
     if(j==-1||s.ch[i]==t.ch[j])
     {
     i++;
     j++;
   }
   else j=next[j];
   }
   if(j>=t.len)
   v=i-t.len;
   else
   v=-1;
   return v;
}

int KMPIndex1(SqString s,SqString t)/*改进的KMP��法*/
{
int nextval[MaxSize],next[MaxSize],i=0,j=0,v;
GetNextval(t,next);
GetNextval(t,nextval);
while(i {
if(i==-1||s.ch[i]==t.ch[j])
{
i++;
j++;
}
else j=nextval[j];
}
if(j>=t.len)
v=i-t.len;/*�q�回匚w��模式串的首字�W�下�?/
else
v=-1;
return v;
}

void StrAssign(SqString &str,char cstr[])/*�׃��帔R��cstr创徏串str */
{
   int i;
   for(i=0;cstr[i]!='\0';i++)
    str.ch[i]=cstr[i];
   str.len=i;
}

void DispStr(SqString s)/*输出串s的所有元�?/
{
int i;
if(s.len>0)
{
for(i=0;i printf("%c",s.ch[i]);
printf("\n");
}
}
void main()
{
int j;
int next[MaxSize],nextval[MaxSize];
SqString s,t;
StrAssign(s,"abcabcdabcdeabcdefabcdefg");
StrAssign(t,"abcdeabcdefab");
printf("串s:");DispStr(s);
printf("串t:");DispStr(t);

printf("��单匹配P��法:\n");
printf("t在s中的位置:%d\n",Index(s,t));

GetNext(t,next);
GetNextval(t,nextval);
printf(" j     ");
for(j=0;j {
   printf("%4d",j);
}
printf("\n");
printf("t[j]   ");
for(j=0;j printf("%4c",t.ch[j]);
printf("\n");
printf("next   ");
for(j=0;j printf("%4d",next[j]);
   printf("\n");

   printf("nextval");
   for(j=0;j   printf("%4d",nextval[j]);
   printf("\n");

printf("KMP��法:\n");
printf("t在s中的位置:%d\n",KMPIndex(s,t));

printf("改进的KMP��法:\n");
printf("t在s中的位置:%d\n",KMPIndex1(s,t));

}

�l�果如下�Q?/strong>
串s:abcabcdabcdeabcdefabcdefg
串t:abcdeabcdefab
��单匹配P��法:
t在s中的位置:7
j        0   1   2   3   4   5   6   7   8   9 10 11 12
t[j]      a   b   c   d   e   a   b   c   d   e   f   a   b
next     -1   0   0   0   0   0   1   2   3   4   5   0   1
nextval -1   0   0   0   0 -1   0   0   0   0   5 -1   0
KMP��法:
t在s中的位置:7
改进的KMP��法:
t在s中的位置:7

matthew 2006-10-31 18:50 发表评论

matthew — Sun, 29 Oct 2006 06:57:00 GMT

学生选课�pȝ��

大学里实行学分制。每门课都有一定的�?/span> �?/span> 。每个学生均需要修满规定数量的评��才能毕业。其中有些课�E�可以直接修读，有些评��需要一定的基础知识�Q�必��d��选了其他一些课�E�的基础上才能修诅R��例如，《数据结构》必��d��选修了《高�U�语�a��E�序设计》之后才能选修。我们称《高�U�语�a��E�序设计》是《数据结构》的“先修课”。在我们的大学里�Q�假�?font color="#000000" size="2">每门评��直接先修�?span style="COLOR: red">臛_��只有一门，两门译֏�能存在相同的先修�?/font>。例如：

译֏�

先修译֏�

学分

1

0

1

2

1

1

3

2

3

4

0

3

5

2

4

上例中，1�?span lang="EN-US">2的先修课�Q�即如果要选修2�Q�则1必定被选�?span lang="EN-US">

学生不可能学完大学里开讄��所有课�E�，因此每个学生必须在入学时选定自己要学的课�E�。每个学生可选课�E�的��L��目是�l�定的。现在请你们��组�~�写一个“学生选课�pȝ��”，��L��l�定一�U�课�E�体�p�（总课�E�数�Q�课�E�之间的修读先后制约关系�Q�学生毕业要求修的课�E�数目）�Q�该�pȝ��能帮助学生找�?span style="COLOR: red">一�U?/font>选课�Ҏ��Q��得他能得到的学分最�?/font>�Q��ƈ且必��L��?span style="COLOR: red">先修评��优先的原�?br />

具体实现如下�Q?/span>

1.          ��?b style="mso-bidi-font-weight: normal">评��体系存放��E�体�p�L��?/font> CourseHierarchy.txt �Q?/span>

2.          ��?b style="mso-bidi-font-weight: normal">评��体系文�g CourseHierarchy.txt 转换左孩子右兄弟二叉树表�C?/font>�Q?/span>

3.          在此基础上对二叉树进行先序、中序、后序遍历�?/font>

4.      　�l�出最多学分选课�Ҏ��?/font>

��课�E�体�p�L��件�{换�ؓ二叉�?/span>

思想�Q�从 CourseHierarchy.txt 头部开始扫描，�W�一个先修课�?/span> 0 �Q�即没有先修课）的课�E��ؓ整棵二叉树的根节�?/span> i 。从 CourseHierarchy.txt 头部开始扫描，所�?/span> i 的后�l�课�E�作�?/span> i 的左子树�Q�课�E�体�p�M��Q�其他先修课�?/span> 0 的节点，及其后箋评��构成 i 的右子树。第一个先修课�?/span> i 的节点作�?/span> i 的左子树的根节点 �Q�从 CourseHierarchy.txt 头部开始扫描，其他�?/span> i 为先修课的课�E�构�?/span> 的右子树。如此低归构造出评��体系二叉�?/font>�?/span>

步骤 1 �Q�从文�g CourseHierarchy.txt 生成评��链表 Course_Slist �Q�参数表�Q��?/span>

步骤 2 �Q�将指针 CousreSystem_root 指引�?/span> 评��链表递归转换��E�体�p�M��叉树
步骤 3 �Q�先序输��Z��叉树�Q�以验证生成的二叉树是否正确
实现代码
tree_binary.cpp
// tree_binary.cpp : 定义控制台应用程序的入口炏V�?br />//
#pragma once

#include
#include

//#include
//#include
//#include
#include"tree_binaryHF.h"
using namespace std;
int _tmain(int argc, _TCHAR* argv[])
{
char file_name[20]="CourseHierarchy.txt";
LinkList L;//链表的头指针
LinkList T;//树的�?br /> cout<<"\t本程序的作用是从文�g(文�g内容可按需求改�?"<  <<"        中读取信息，攑ֈ�链表中，最后生成二叉树�Q?<  <<"        然后先序中序�Q�后�l�遍历二叉树."< InitList(L);
cout<<"��d��的文件内�?"< OpenFile(L,file_name);
cout<<"生成链表后的�l�果:"< PrintLinkLIst(L);
    CreateBiTree(L,T,0);//生成二叉�?br /> cout<<"先序遍历二叉树的�l�果:";
PreOrder(T);
cout< InOrder(T);
cout<    BackOrder(T);
cout< return 0;
}

tree_binaryHF.h
#include"cao.hpp"
//*************************************//
//打开文�g�Q��ƈ��d��里面的所有内�?br />Status OpenFile(LinkList&L,char file_name[])//�׃��q�里需要把数据插入链表�?br />{
int CNum,CScore,PreScore;
ifstream in_stream;
in_stream.open(file_name);
if(in_stream.fail())//if the file is not opened successfully
{
  cout<<"can't open the file of "<  exit(0);
}
//i
cout<<"CNum"<<"\t"<<"PreScore"<<"\t"<<"CScore"< while(in_stream>>CNum>>PreScore>>CScore)//��d��三个数据(评��~�码,学分,先修�?
{
  cout<  LinkInsert(L,CNum,PreScore,CScore);//insert the node to the linklist L
}
in_stream.close();
return OK;
}
Status InitList(LinkList &L)
{
L= (LinkList)malloc(sizeof(LNode));
if(!L)
  return ERROR;
L->lchild=NULL;
L->rchild=NULL;
L->CNumber=0;
L->CScore=0;
L->PreCourse=0;
return OK;
}
Status LinkInsert(LinkList &L,Status CNum,Status PreCourse,Status CScore)//把新得到的结�Ҏ��入链表，从头�l�点处插�?br />{
LinkList p;
p=(LinkList)malloc(sizeof(LNode));
if(!p)
  return ERROR;
p->CNumber=CNum;
p->CScore=CScore;
p->PreCourse=PreCourse;
p->lchild=NULL;
p->rchild=L->rchild;
L->rchild=p;
return OK;
}
Status PrintLinkLIst(LinkList &L)//打印整个链表�Q�右指针指向后��l�点�Q�左指针�I?br />{
LinkList p;
p=L->rchild;
while(p)
{
  cout<CNumber<<"\t"<PreCourse<<"\t"<<"\t"<CScore<  p=p->rchild;
}
return OK;
}
Status CreateBiTree(LinkList &L,LinkList&T,Status c)
{
LinkList p;
//while(!EmptyLinkList(L))
//{
if(!(p=Serach(L,c)))
  T=NULL;
else
{
  T=p;//生成根节�?br />  delet(L,c);//删除p�l�点
  CreateBiTree(L,T->lchild,T->CNumber);//构造左子树
  CreateBiTree(L,T->rchild,T->PreCourse);//构造右子树
}
//}
return OK;
}
LinkList Serach(LinkList &L,Status c)
{
LinkList head,next;
head=L;
next=head->rchild;
while(next&&(next->PreCourse!=c))
{
  head=next;
  next=next->rchild;
}
if(next==NULL)
  return NULL;//没有扑ֈ�
else//扑ֈ��?br />  return next;
}
void delet(LinkList &L,Status c)
{
LinkList head,next;
head=L;
next=head->rchild;
while(next&&(next->PreCourse!=c))
{
  head=next;
  next=next->rchild;
}
head->rchild=next->rchild;
//free(next);
}
Status EmptyLinkList(LinkList L)
{
if(L->rchild=NULL)
  return OK;
else
  return ERROR;
}
//先序遍历的递归
void PreOrder(LinkList T)
{
if(T)
{
   //讉K��l�点
cout<CNumber<<" ";
PreOrder(T->lchild);   //遍历左子�?br /> PreOrder(T->rchild);   //遍历叛_��?br /> //cout< }
}
//中序遍历的递归
void InOrder(LinkList T)
{
if(T)
{
InOrder(T->lchild);   //遍历左子�?br />   //讉K��l�点
cout<CNumber<<" ";
InOrder(T->rchild);   //遍历叛_��?br /> }
}
//后序遍历的递归
void BackOrder(LinkList T)
{
if(T)
{
BackOrder(T->lchild);   //遍历左子�?br /> BackOrder(T->rchild);   //遍历叛_��?br /> cout<CNumber<<" ";
}
}

cao.hpp
#include
#include
#include
using namespace std;
typedef int Status;
#define OK   1
#define ERROR 0
typedef struct LNode
{
struct LNode *lchild;
struct LNode *rchild;
Status CNumber;
Status CScore;
Status PreCourse;
}LNode,*LinkList;
Status OpenFile(LinkList&L,char file_name[]);
//打开文�g�Q��ƈ且插入节�?br />//*************************//
LinkInsert(LinkList &L,Status CNum,Status CScore,Status PreScore);
//insert the node to the linklist L
//*************************//
Status InitList(LinkList &L);//初始化链�?br />//****************************************//
Status PrintLinkList(LinkList &L);//输出链表
//********************************//
LinkList Serach(LinkList &L,Status c);//查找节点
//*********************************************//
void delet(LinkList&L,Status c);//删除节点
//*************************************//
Status EmptyLinkList(LinkList L);//��查链表是否�ؓ�I�（没用刎ͼ�
//***********************************//
//先序遍历二叉�?br />void PreOrder(LinkList T);
//***********************************//
void InOrder(LinkList T);//中序遍历二叉�?br />//*****************************//
void BackOrder(LinkList T);//后箋遍历二叉�?br />
CourceSource.txt
1 2 2
2 0 1
3 0 4
4 2 1
5 7 1
6 7 6
7 2 2

�q�行�l�果
先序遍历二叉树：3　2　7　6　5　4　1
中序遍历二叉树：3　6　5　7　4　1　2
后序遍历二叉树：5　6　1　4　7　2　3

matthew 2006-10-29 14:57 发表评论

栈和队的应用�Q�魔王语�a�解释

matthew — Sat, 14 Oct 2006 11:18:00 GMT
问题描述�Q?/strong>
    设计�q�实现魔王语�a�的解释器�Q�具体要求如下：大写字母表示��王语言的词汇；��写字母表示人的词汇语言�Q�魔王语�a�中可包含括号�?/font>

    如：我们有魔王语�a�的解释规则：B�Q?gt;tAdA�Q�A->sae�Q�则��王语言 B(ehnxgz)B解释成tsaedsaeezegexenehetsaedsae�?br />
实现代码如下�Q?br />
#include
#include
#define STACK_INIT_SIZE 100 //存储�I�间初始分配�?br />#define STACK_INCREMENT 10 //存储�I�间分配增量
#define OVERFLOW          1
#define OK          1
#define ERROR      0
#define TRUE        1
#define FALSE       0
typedef char      SElemType;
typedef char      QElemType;
typedef int     Status;
typedef struct{
SElemType *base;            //栈基址
SElemType *top;             //栈顶地址
int stacksize;
}SqStack;
typedef struct QNode{
QElemType data;
struct QNode *next;
}QNode,*QueuePtr;
typedef struct{
QueuePtr front;   //队头指针
QueuePtr rear;    //队尾指针
}LinkQueue;
Status InitStack(SqStack &S)
//构造一个空�?br />{
S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(char));
if(!S.base)
  exit (OVERFLOW);//存储单元分配��p�|
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}
Status Push(SqStack &S,SElemType e)
//插入元素e栈顶单元
{
if(S.top-S.base>=S.stacksize)
{//栈满�Q�追加存储空�?br />  S.base=(SElemType *)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(char));
if(!S.base)
  exit (OVERFLOW);//存储单元分配��p�|
S.top=S.base+S.stacksize;
S.stacksize+=STACK_INCREMENT;
}
*(S.top)=e;
S.top++;
return OK;
}
Status Pop(SqStack &S,SElemType& e)
//若栈不�ؓ�I�，则删除S的栈��单元，用e�q�回其�?br />{
if(S.base==S.top)
  return ERROR;
S.top--;
e=*(S.top);
return OK;
}
Status StackEmpty(SqStack S)
{
if(S.base==S.top)
  return 0;
else
  return 1;
}

Status InitQueue(LinkQueue &Q)
//构造一个空队列Q
{
Q.front=Q.rear=(QueuePtr)malloc(sizeof (QNode));
if(!Q.front)
  exit (OVERFLOW);
Q.front->next=NULL;
return OK;
}
Status EnQueue (LinkQueue&Q,QElemType e)
//插入元素e为Q的新的队��օ��?br />{
QueuePtr p;
p=(QueuePtr)malloc(sizeof (QNode));
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}
Status DeQueue (LinkQueue &Q,QElemType &e)
//若队列不�I�，则删除Q的队头元素，用e�q�回其��|��q�返回OK;
//否则�q�回ERROR
{
QueuePtr p;
if(Q.front==Q.rear)
  return ERROR;
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(p==Q.rear)
  Q.rear=Q.front;
free(p);
return OK;
}
Status QueueEmpty(LinkQueue Q)
//若队列Q为空队列,则返回TRUE�Q�否则返回FALSE
{
if(Q.rear==Q.front)
  return FALSE;
else
  return TRUE;
}
void InStack(char fiend[],SqStack &S)
{
int m,i=0;
for(;fiend[i]!='\0';i++);//计算fiend中有多少
for(m=i-1;m>=0;m--)
  Push(S,fiend[m]);
}
void main()
{
char e,c,d;
SqStack S,zhan;
LinkQueue Q;
   InitQueue(Q);
char mowang[]="B(ehnxgz)B";
printf("你想要解释的��王语言为：%s\n",mowang);
    char B[]="tAdA";
InitStack(S);
InitStack(zhan);
InStack(mowang,S);//全部压进栈中
while(StackEmpty(S))//在栈不�ؓ�I�的情况�?br /> {
  Pop(S,e);
  if(e=='B')
  InStack(B,zhan);
  else
if(e=='(')//如果为右括号�Q�则输出括号中所有内�?br />   {
    while(Pop(S,e)&&e!=')')//当�ؓ左括��h��停止
    {
     if(e!=')')
     EnQueue (Q,e);
    }
     DeQueue (Q,c);//��d��队列中第一个元�?br />    while(QueueEmpty(Q))
    {
     DeQueue (Q,d);//取出元素
     Push(zhan,c);
     Push(zhan,d);
    }
    Push(zhan,c);//再次压入�W�一个元�?br />   // Pop(S,e);//��L��左括�?br />   }

}
printf("\n解释的结果�ؓ: ");
    while(StackEmpty(zhan))//在栈不�ؓ�I�的情况�?br /> {

  Pop(zhan,c);
  if(c=='A')
printf("sae");
        else
     printf("%c",c);
  }
  printf("\n");
}

matthew 2006-10-14 19:18 发表评论

matthew — Wed, 04 Oct 2006 08:18:00 GMT

要求�Q?br />1 输入�q�徏立多��式
2 输出多项式，输出形式外�ؓ整数序列�Q�c1,e1;c2,e2;.......cn,en;其中n为多��式的项敎ͼ�ci和ei分别为第i��的�p�L��和指敎ͼ�序列按指数降序排�?br />3 多项式a和b相加�Q�徏立多��式a+b
4 多项式a和b相减�Q�徏立多��式a-b
代码如下�Q?br />#include
#include
#define MAX 20 //多项式最多项�?br />typedef struct //定义存放多项式的数组�c�d��
{
float coef;   //�p�L��
int exp;      //指数
}PolyArray[MAX];
typedef struct pnode //定义单链表结点类�?br />{
float coef;         //�p�L��
int exp;            //指数
struct pnode *next;
}PolyNode;

void DispPoly(PolyNode *L) //输出多项�?br />{
PolyNode *p=L->next;
while (p!=NULL)
{
printf("%g,%d;",p->coef,p->exp);
p=p->next;
}
printf("\n");
}
void CreateListR(PolyNode * &L,PolyArray a,int n)    //��插入法��
{
PolyNode *s,*r;int i;
L=(PolyNode *)malloc(sizeof(PolyNode));          //创徏头结�?br /> L->next=NULL;
// L->exp=n;
// printf("%d\n",L->exp);
r=L;                                            //r始终指向�l�端�l�点�Q�开始时指向头结�?br />  for(i=0;i  {
    s=(PolyNode *)malloc(sizeof(PolyNode));   //创徏新结�?br />    s->coef=a[i].coef;
    s->exp=a[i].exp;
    r->next=s;                               //��?s插入*r之后
    r=s;
  }
  r->next=NULL;                               //��终端结点next域置为NULL
}
void Sort(PolyNode * &head)                         //按exp域的值递减排序
{
PolyNode *p=head->next,*q,*r;
if(p!=NULL)                                      //当原单链表不为空�?br /> {
   r=p->next;                                     //r保存*p�l�点后��l�点的指�?br />   p->next=NULL;                                  //构造只含一个数据结点的有序�?br />   p=r;
   while(p!=NULL)
   {
     r=p->next;                                   //r保存*p�l�点后��l�点的指�?br /> q=head;
while(q->next!=NULL && q->next->exp>p->exp)
   q=q->next;                               //在有序表中找插入*p的前��q��?q
p->next=q->next;                             //��?p插入�?q之后
q->next=p;
p=r;
   }
}
}
void Add(PolyNode *ha,PolyNode *hb,PolyNode *&hc)//求两个有序表的�ƈ
{
PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;
float c;
hc=(PolyNode *)malloc(sizeof(PolyNode));           //创徏头结�?br /> tc=hc;
while(pa!=NULL && pb!=NULL)
{
    if(pa->exp>pb->exp)
{
   s=(PolyNode *)malloc(sizeof(PolyNode));        //复制�l�点
   s->exp=pa->exp;s->coef=pa->coef;
   tc->next=s;tc=s;
   pa=pa->next;
}
else if(pa->expexp)
{
s=(PolyNode *)malloc(sizeof(PolyNode));           //复制�l�点
s->exp=pb->exp;s->coef=pb->coef;
tc->next=s;tc=s;
pb=pb->next;
}
else                                             //pa->exp=pb->exp�?br /> {
c=pa->coef+pb->coef;
if(c!=0)                                          //�p�L��之和不�ؓ0时创建新�l�点
{
   s=(PolyNode *)malloc(sizeof(PolyNode));
   s->exp=pa->exp;s->coef=c;
   tc->next=s;tc=s;
}
pa=pa->next;
pb=pb->next;
}

}
if(pb!=NULL)                                     //复制余下�l�点
   pa=pb;
while(pa!=NULL)
{
    s=(PolyNode *)malloc(sizeof(PolyNode));           //复制�l�点
s->exp=pa->exp;s->coef=pa->coef;
tc->next=s;tc=s;
pa=pa->next;
}
tc->next=NULL;
}

void Subs(PolyNode *ha,PolyNode *hb,PolyNode *&hc)   //求两个有序表的差
{
PolyNode *pa=ha->next,*pb=hb->next,*s,*tc;
float c;
hc=(PolyNode *)malloc(sizeof(PolyNode));           //创徏头结�?br /> tc=hc;
while(pa!=NULL && pb!=NULL)
{
    if(pa->exp>pb->exp)
{
   s=(PolyNode *)malloc(sizeof(PolyNode));        //复制�l�点
   s->exp=pa->exp;s->coef=pa->coef;
   tc->next=s;tc=s;
   pa=pa->next;
}
else if(pa->expexp)
{
s=(PolyNode *)malloc(sizeof(PolyNode));           //复制�l�点
s->exp=pb->exp;s->coef=-pb->coef;                 //如果前个多项式中的指数小于后个多��式指数加上负号
tc->next=s;tc=s;
pb=pb->next;
}
else                                             //pa->exp=pb->exp�?br /> {
c=pa->coef-pb->coef;
if(c!=0)                                          //�p�L��之差不�ؓ0时创建新�l�点
{
   s=(PolyNode *)malloc(sizeof(PolyNode));
   s->exp=pa->exp;s->coef=c;
   tc->next=s;tc=s;
}
pa=pa->next;
pb=pb->next;
}

}
if(pb!=NULL)                                     //复制余下�l�点
   pa=pb;
while(pa!=NULL)
{
    s=(PolyNode *)malloc(sizeof(PolyNode));           //复制�l�点
s->exp=pa->exp;s->coef=pa->coef;
tc->next=s;tc=s;
pa=pa->next;
}
tc->next=NULL;
}
void main()
{
   PolyNode *ha,*hb,*hc;
   //PolyArray a={{1.2,0},{2.5,1},{3.2,3},{-2.5,5}};
   //PolyArray b={{-1.2,0},{2.5,1},{3.2,3},{2.5,5},{5.4,10}};
   int m=4,n=5;
   PolyArray a,b;
   for(int i=0;i   {
     printf("误��入A多项式中�W?d��的�p�L��和指�?,i);
scanf("%f%d",&a[i].coef,&a[i].exp);
   }

    for(int j=0;j   {
     printf("误��入B多项式中�W?d��的�p�L��和指�?,j);
scanf("%f%d",&b[j].coef,&b[j].exp);
   }

   CreateListR(ha,a,4);
   CreateListR(hb,b,5);
   printf("原来A:\n");DispPoly(ha);
   printf("原来B:\n");DispPoly(hb);

   Sort(ha);
   Sort(hb);
   printf("排序后A:\n");DispPoly(ha);
   printf("排序后B:\n");DispPoly(hb);

   Add(ha,hb,hc);
   printf("相加�?\n");DispPoly(hc);
   Subs(ha,hb,hc);
   printf("相减�?\n");DispPoly(hc);
}

matthew 2006-10-04 16:18 发表评论

数据�l�构之抽象数据类型－复数四则�q�算

matthew — Mon, 25 Sep 2006 10:52:00 GMT

[ 复数 ADT 的描�q?/span> ]
　 ADT complex{
　　　数据对象�Q?/span> D={ c1,c2 　 c1,c2 �?/span> FloatSet }
　　　数据关系�Q?/span> R={ 　 c1 　 c2 　　 }
　　　基本操作�Q�创��Z��个复数　　　　 creat(a);
　　　　　　　　输出一个复数　　　　 outputc(a);
　　　　　　　　求两个复数相加之和　 add(a,b);
　　　　　　　　求两个复数相减之差　 sub(a,b);
　　　　　　　　求两个复数相乘之�U�　 chengji(a,b);
　　　　　　　　 �{�等 ;
} ADT complex;
实现复数 ADT 可以使用面向�q�程的程序设计方法，也可以用面向对象�E�序设计�Ҏ��?br />[复数ADT实现的面向过�E?/span>C语言源程�?/span>]-complex.h
#include
#include
typedef struct Complex
{
float real;
float image;
}Complex;

void CreatComplex(Complex& c,float a,float b);

void AddComplex(Complex& sum,Complex c1,Complex c2 );

void Subtract_C(Complex& Sub,Complex c1,Complex c2 );

void Multiple_C(Complex& product,Complex c1,Complex c2 );

void Print_C(Complex c);

void CreatComplex(Complex& c,float a,float b)
{
c.real = a;
c.image = b;
}

void AddComplex(Complex& sum,Complex c1,Complex c2)
{
sum.real = c1.real + c2.real ;
sum.image = c1.image + c2.image ;
}

void Subtract_C(Complex& Sub,Complex c1,Complex c2 )
{
Sub.real = c1.real -c2.real ;
Sub.image = c1.image - c2.image ;
}

void Multiple_C(Complex& product,Complex c1,Complex c2 )
{
product.real = c1.real * c2.real - c1.image * c2.image ;

product.image = c1.real * c2.image + c1.image * c2.real ;
}

void Print_C(Complex c)
{
if (c.image == 0.0)
  printf("%5.2f\n",c.real );
else
  printf("%5.2f+%5.2fi\n",c.real ,c.image );
if(c.real==0.0)
  printf("%5.2fi\n",c.image);
}
complex.cpp代码�Q?br />#include "complex.h"
#include
void main()
{
float a,b,c,d;
Complex  c1,c2,sum,Sub,Prod;

scanf("%f%f%f%f",&a,&b,&c,&d);

CreatComplex(c1,a,b);

Print_C(c1);

CreatComplex(c2,c,d);
Print_C(c2);

AddComplex(sum,c1,c2);
Print_C(sum);

Subtract_C(Sub,c1,c2);
Print_C(Sub);

Multiple_C(Prod,c1,c2);
Print_C(Prod);
}

matthew 2006-09-25 18:52 发表评论