简单的文本编辑器 数据结构课程设计
2024-05-18 19:20
1. 简单的文本编辑器 数据结构课程设计
我给个思路吧： 1.把要统计的文章第次读入一行到数组中，以便统计。 2.对这个数组从头到尾循环，每次读入一个字符来分析，判断它是汉字还是字母、符号、数字。 3.写一个函数来统计串出现的次数，用strstr()函数。 4.删除某一子串时，可以把去掉串后的文本重新写入磁盘。
2. 数据结构课程设计
稍微修改下就应该能用了..
#include
typedef struct node
{
int tag;
union{struct node *sublist;
char data;
}dd;
struct node *link;
}NODE;
NODE *creat_GL(char **s)
{
NODE *h;
char ch;
ch=*(*s);
(*s)++;
if(ch!='\0')
{
h=(NODE*)malloc(sizeof(NODE));
if(ch=='(')
{
h->tag=1;
h->dd.sublist=creat_GL(s);
}
else
{
h->tag=0;
h->dd.data=ch;
}
}
else
h=NULL;
ch=*(*s);
(*s)++;
if(h!=NULL)
if(ch==',')
h->link =creat_GL(s);
else
h->link=NULL;
return(h);
}
void prn_GL(NODE *p)
{
if(p!=NULL)
{
if(p->tag==1)
{
printf("(");
if(p->dd.sublist ==NULL)
printf(" ");
else
prn_GL(p->dd.sublist );
}
else
printf("%c",p->dd.data);
if(p->tag==1)
printf(")");
if(p->link!=NULL)
{
printf(",");
prn_GL(p->link);
}
}
}
NODE *copy_GL(NODE *p)
{
NODE *q;
if(p==NULL) return(NULL);
q=(NODE *)malloc(sizeof(NODE));
q->tag=p->tag;
if(p->tag)
q->dd.sublist =copy_GL(p->dd.sublist );
else
q->dd.data =p->dd.data;
q->link=copy_GL(p->link);
return(q);
}
int depth(NODE *p)
{
int h,maxdh;
NODE *q;
if(p->tag==0) return(0);
else
if(p->tag==1&&p->dd.sublist==NULL) return 1;
else
{
maxdh=0;
while(p!=NULL)
{
if(p->tag==0) h=0;
else
{q=p->dd.sublist;
h=depth(q);
}
if(h>maxdh)
maxdh=h;
p=p->link;
}
return(maxdh+1);
}
}
int count(NODE *p)
{
int m,n;
if(p==NULL) return(0);
else
{
if(p->tag==0) n=1;
else
n=count(p->dd.sublist);
if(p->link!=NULL)
m=count(p->link);
else m=0;
return(n+m);
}
}
main()
{
NODE *hd,*hc;
char s[100],*p;
p=gets(s);
p=s;
hd=creat_GL(&p);
hc=copy_GL(hd);
printf("\ncopy after:");
prn_GL(hc);
printf("\ndepth=%d ",depth(hc));
printf("\ncount=%d",count(hc));
getch();
}
3. 数据结构课程设计报告
1、一元稀疏多项式相加
详细设计
4.1 程序头的设计:
#include
#include
typedef struct pnode
{int coef;/*系数 */
int exp;/*指数 */
struct pnode *next;/*下一个指针*/
}pnode;
4.2 用头插法生成一个多项式，系数和指数输入0时退出输入
pnode * creat()
{int m,n; pnode *head,*rear,*s;
/*head为头指针，rear和s为临时指针*/
head=(pnode *)malloc(sizeof(pnode));
rear=head;
/*指向头*/
printf("input coef:");/*输入系数*/
scanf("%d",&n);
printf("input exp:");/*输入指数*/
scanf("%d",&m);
while(n!=0)/*输入0就退出*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=n;
s->exp=m;
s->next=NULL;
rear->next=s;/*头插法*/
rear=s;
printf("input coef:");/*输入系数*/
scanf("%d",&n);
printf("input exp:");/*输入指数*/
scanf("%d",&m);
}
head=head->next;/*第一个头没有用到*/
return head;
}
4.3 显示一个多项式
void display(pnode *head)
{pnode *p;int one_time=1; p=head;
while(p!=NULL)/*不为空的话*/
{
if(one_time==1)
{if(p->exp==0)/*如果指数为0的话，直接输出系数*/
printf("%d",p->coef); /*如果系数是正的话前面就要加+号*/
else if(p->coef==1||p->coef==-1)
printf("x^%d",p->exp);/*如果系数是1的话就直接输出+x*/
/*如果系数是-1的话就直接输出-x号*/
else if(p->coef>0)/*如果系数是大于0的话就输出+系数x^指数的形式*/
printf("%dx^%d",p->coef,p->exp);
else if(p->coef<0)/*如果系数是小于0的话就输出系数x^指数的形式*/
printf("%dx^%d",p->coef,p->exp);
one_time=0;
}
else{
if(p->exp==0)/*如果指数为0的话，直接输出系数*/
{if(p->coef>0)
printf("+%d",p->coef); /*如果系数是正的话前面就要加+号*/
}
else if(p->coef==1)
printf("+x^%d",p->exp);
else if(p->coef==-1)
printf("x^%d",p->exp);/*如果系数是1的话就直接输出+x号*/
else if(p->coef>0)/*如果系数是大于0的话就输出+系数x^指数的形式*/
printf("+%dx^%d",p->coef,p->exp);
else if(p->coef<0)/*如果系数是小于0的话就输出系数x^指数的形式*/
printf("%dx^%d",p->coef,p->exp);
}
p=p->next;/*指向下一个指针*/
}
printf("\n");
4.4 两个多项式的加法运算
pnode * add(pnode *heada,pnode *headb)
{pnode *headc,*p,*q,*s,*r;
/*headc为头指针，r,s为临时指针，p指向第1个多项式并向右移动，q指向第2个多项式并并向右移动*/
int x;
/*x为系数的求和*/
p=heada;
/*指向第一个多项式的头*/
q=headb;
/*指向第二个多项式的头*/
headc=(pnode *)malloc(sizeof(pnode));
r=headc;
/*开辟空间*/
while(p!=NULL&&q!=NULL)
/*2个多项式的某一项都不为空时*/
{if(p->exp==q->exp)/*指数相等的话*/
{x=p->coef+q->coef;/*系数就应该相加*/
if(x!=0)/*相加的和不为0的话*/
{s=(pnode *)malloc(sizeof(pnode));/*用头插法建立一个新的节点*/
s->coef=x;
s->exp=p->exp;
r->next=s;
r=s;
}
q=q->next;p=p->next;
/*2个多项式都向右移*/
}
else if(p->expexp)/*p的系数小于q的系数的话，就应该复制q接点到多项式中*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=q->coef;
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;/*q向右移动*/
}
else/*p的系数大于q的系数的话，就应该复制p接点到多项式中*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;/*p向右移动*/
}
}
当第2个多项式空，第1个数不为空时，将第一个数剩下的全用新节点产生
while(p!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;
}
当第1个多项式空，第1个数不为空时，将第2个数剩下的全用新节点产生
while(q!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=q->coef;
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;
}
r->next=NULL;
/*最后指向空*/
headc=headc->next;/*第一个头没有用到*/
return headc;/*返回头接点*/
4.5 两个多项式的减法运算，和加法类似，不同的地方已经注释
pnode * sub(pnode *heada,pnode *headb)
{pnode *headc,*p,*q,*s,*r;
int x;
p=heada;q=headb;
headc=(pnode *)malloc(sizeof(pnode));
r=headc;
while(p!=NULL&&q!=NULL)
{if(p->exp==q->exp)
{x=p->coef-q->coef;/*系数相减*/
if(x!=0)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=x;
s->exp=p->exp;
r->next=s;
r=s;
}
q=q->next;p=p->next;
}
else if(p->expexp)/*p的系数小于q的系数的话*/
{s=(pnode *)malloc(sizeof(pnode));
s->coef=-q->coef;/*建立的接点的系数为原来的相反数*/
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;
}
else
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;
}
}
while(p!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=p->coef;
s->exp=p->exp;
r->next=s;
r=s;
p=p->next;
}
while(q!=NULL)
{s=(pnode *)malloc(sizeof(pnode));
s->coef=-q->coef;/*建立的接点的系数为原来的相反数*/
s->exp=q->exp;
r->next=s;
r=s;
q=q->next;
}
r->next=NULL;
headc=headc->next;
return headc;
4.6 界面设计:
printf("\n ****************************************\n");
printf("\n ************** 03 Computer *************\n");
printf("\n ******** Class:two **** Num:34 *********\n");
printf("\n *********** Name: xie pan **********\n");
printf("\n ****************************************\n");
printf("\n --------------1: add -------------\n");
printf("\n --------------2: sub -------------\n");
printf("\n --------------3: exit ------------\n");
printf("\n ****************************************\n");
4.7 连接程序:
case 1:add_main();break;/*加法*/
case 2:sub_main();break;/*减法*/
case 3:break;/*退出*/
4. 数据结构课程设计简单仓库管理
#include
#include"iostream"
int flag1=0;
#include"string.h"
#include"stdlib.h"
#include"windows.h"
using namespace std;
typedef struct{
//仓库管理结点类型
char NO[10];//商品编号
char name[30];//商品名称
char count[5];//商品数量
}DataType;
typedef struct node{
//结点类型定义
DataType data;//结点数据域
struct node *next;//结点指针域
}ListNode;
typedef ListNode *LinkList;
LinkList head;
ListNode *p;
LinkList CreateList(void);
void InsertNode(LinkList head,ListNode *p);
ListNode *ListFind(LinkList head);
void DelNode(LinkList head);
void PrintList(LinkList head);
/*************尾插法建立带头结点的仓库管理链表算法**********/
LinkList CreateList(void)
{
LinkList head=(ListNode *)malloc(sizeof(ListNode));//申请头结点
ListNode *p,*rear;
char flag='y'; //int flag=0; //结束标志
rear=head;//尾指针初始指向头结点
while(flag=='y')
{
p=(ListNode *)malloc(sizeof(ListNode));//申请结点
printf(" 商品编号(10) 商品名称(30) 商品数量(5) \n");
printf("---------------------\n");
printf("\n添加商品编号:\n");
cin>>p->data.NO;
printf("\n添加商品名称:\n");
cin>>p->data.name;
printf("\n添加商品数量:\n");
cin>>p->data.count;
rear->next=p; //新结点连接到尾结点之后
rear=p; //尾指针指向新结点
printf("\n继续添加记录?(y/n):");
cin>>flag;
}
rear->next=NULL;//终端结点指针置空
return head;//返回链表头指针
}
/*********在仓库管理链表head中插入结点*********/
void InsertNode(LinkList head,ListNode *p)
{
ListNode *p1,*p2;
p1=head;
p2=p1->next;
while(p2!=NULL&&strcmp(p2->data.NO,p->data.NO)<0){
p1=p2;//p1指向刚访问过的结点
p2=p2->next;//p2指向表的下一个结点
}
p1->next=p;//插入p所指向的结点
p->next=p2;//连接表中剩余的结点
}
/*********有序仓库管理链表的查找**********/
ListNode *ListFind(LinkList head)
{
ListNode *p;
char num[10];
char name[9];
char pp;
printf("===================\n");
printf("a.按商品编号查询\n");
printf("b.按商品名称查询\n");
printf("===================\n");
printf(" 请选择: ");
p=head->next;
cin>>pp;
getchar();
if(pp=='a'||pp=='A')
{ printf("请输入要查找的商品编号:");
cin>>num;
while(p&&strcmp(p->data.NO,num)next;
if((p==NULL)||strcmp(p->data.NO,num)>0) p=NULL;
}
else
if(pp=='b'||pp=='B')
{
printf("请输入要查找的商品名称:");
cin>>name;
while(p&&strcmp(p->data.name,name)!=0) p=p->next;
}
return p;
//没有查到要查找的
}
/***********仓库管理链表上的结点删除**********/
void DelNode(LinkList head)
{
char jx;
ListNode *p,*q;
p=ListFind(head);//调用查找函数
if(p==NULL)
{
printf("没有查到要删除的商品信息!\n");
return;
}
if(p!=NULL)
printf("真的要删除该商品吗?(y/n):");
cin>>jx;
if(jx=='y'||jx=='Y')
{
q=head;
while((q!=NULL)&&(q->next!=p))
q->next=p->next; //删除结点
q=q->next;
free(p); //释放被删结点空间
printf("删除成功!\n");
}
}
/**********仓库管理链表的输出函数**********/
void PrintList(LinkList head)
{
ListNode *p;
p=head->next;
printf(" 商品编号 商品名称 商品数量\n");
printf("---------------------------------------------------------------------\n");
while(p!=NULL)
{
printf("%15s%20s%23s\n",p->data.NO,p->data.name,p->data.count);
printf("----------------------------------------------------------------------\n");
p=p->next;
//后移一个结点
}
}
void main()
{
int choice,j=1;
while(j)
{
printf("\n\n\n\n\n");
printf("\t\t\t仓库管理系统\n");
printf("\n\t\t\t***********************");
printf("\n\t\t\t* 1---仓库管理链表建立*");
printf("\n\t\t\t* 2---仓库管理链表插入*");
printf("\n\t\t\t* 3---仓库管理链表查询*");
printf("\n\t\t\t* 4---仓库管理链表删除*");
printf("\n\t\t\t* 5---仓库管理链表输出*");
printf("\n\t\t\t* 0---退出仓库管理系统*");
printf("\n\t\t\t***********************");
printf("\n\t\t\t请选择菜单号(0--5):");
cin>>choice;
getchar();
switch(choice)
{
case 1:
{
printf("**************\n");
printf("*仓库管理链表建立*\n");
printf("**************\n");
head=CreateList();
flag1=1;
system("cls"); break;
}
case 2:{
if(flag1!=1) {printf("请先建立表!"); Sleep(1500);}
printf("**************\n");
printf("*仓库管理链表插入*\n");
printf("**************\n");
printf("商品编号(10)商品名称(30) 商品数量\n");
printf("**************\n");
p=(ListNode*)malloc(sizeof(ListNode));//申请新结点
printf("\n添加商品编号:\n");
cin>>p->data.NO;
printf("\n添加商品名称:\n");
cin>>p->data.name;
printf("\n添加商品数量:\n");
cin>>p->data.count;
InsertNode(head,p);
system("cls"); break;
}
case 3:
{
if(flag1!=1) {printf("请先建立表!"); Sleep(1500);}
else{
printf("**************\n");
printf("*仓库管理链表查询*\n");
printf("**************\n");
p=ListFind(head);
if(p!=NULL)
{
printf(" 商品编号 商品名称 商品数量\n");
printf("---------------------------------------\n");
printf("%5s%10s%10s\n",p->data.NO,p->data.name,p->data.count);
printf("---------------------------------------\n");
}
else printf("没有查到要查询的商品信息!\n");
} break;
}
case 4:
{
if(flag1!=1) {printf("请先建立表!"); Sleep(1500);}
else
{
printf("**************\n");
printf("*仓库管理链表删除*\n");
printf("**************\n");
DelNode(head);//删除结点
} break;
}
case 5:
{ if(flag1!=1) {printf("请先建立表!"); Sleep(1500);}
else
{
printf("***************\n");
printf("*仓库管理链表输出*\n");
printf("***************\n");
PrintList(head);
}break;
}
case 0:
j=0;system("cls"); break;
default: printf("\t\t\n 输入有错，请重新输入!\n");
Sleep(1500); system("cls"); break;
}
}
}
5. 数据结构课程设计.急~
源代码含有四个文件，datastruct.h是数据结构的定义；ListOper.h是线性表操作函数的声明；ListOper.cpp是线性表操作函数的定义；main.cpp是主单元含有主函数和字符串分析函数。
datastruct.h
typedef struct list
{
int c; //多项式的项数
int e; //多项式的指数
struct list *next; //下一结点
};
typedef struct list *LinkList;
typedef struct list Node;
下面是线性表的操作相关函数声明，对应文件ListOper.h:
//File: ListOper.h
#ifndef DATASTRUCT
#define DATASTRUCT
#include "datastruct.h"
#endif
//some functions declaretioin
bool CreateList(LinkList &L);
Node *CreateNode(int e, int c);
void FreeList(LinkList &L);
void SortList(LinkList &L);
void DeleteNextNode(Node *d);
void SweepNextNode(Node *s);
void OutPutList(LinkList &L);
相关函数的实现，对应文件ListOper.cpp:
//File: ListOper.cpp
#include
#include
#ifndef DATASTRUCT
#define DATASTRUCT
#include "datastruct.h"
#endif
#include "ListOper.h"
using namespace std;
bool CreateList(LinkList &L)
{
//TODO: 创建线性链表
Node *head;
head=(Node *)malloc(sizeof(Node));
if(head==NULL)
{
cout << "内存分配错误" << endl;
return false;
}
head->next=NULL;
head->c=0;
head->e=0;
L=head;
return true;
}
Node *CreateNode(int e, int c)
{
//TODO: 创建结点
Node * pos;
pos=(Node *)malloc(sizeof(Node));
if(pos==NULL)
{
cout << "内存分配错误" << endl;
exit(1);
}
pos->e=e;
pos->c=c;
pos->next=NULL;
return pos;
}
void FreeList(LinkList &L)
{
//TODO: 释放整个线性表所占用的内存空间
Node *pos;
Node *next;
pos=L;
while(pos!=NULL)
{
next=pos->next;
free(pos);
pos=next;
}
}
void SortList(LinkList &L)
{
bool flag=true; //是否需要排序标志
Node *head=L->next;
Node *pos;
Node *last;
Node *temp;
if(head->next==NULL)
{
return;
}
while(flag)
{
flag=true;
last=head;
pos=last->next;
if(last==NULL||last->next==NULL)
{
break;
}
while(last!=NULL && last->next!=NULL)
{
flag=false;
pos=last->next;
if(last->ee) //哈哈哈哈哈，HTML代码
{
SweepNextNode(last);
flag=true;
}
if(last->e==pos->e)
{
last->c+=pos->c;
DeleteNextNode(last);
flag=true;
/*last=last->next;
pos=last->next;*/
}
last=last->next;
}
}
}
void DeleteNextNode(Node *d)
{
Node *temp;
temp=d->next;
d->next=temp->next;
free(temp);
}
void SweepNextNode(Node *s)
//一点偷懒的办法，只交换值，不修改指针
{
int c,e;
c=s->c;e=s->e;
s->c=s->next->c;s->e=s->next->e;
s->next->c=c;s->next->e=e;
}
void OutPutList(LinkList &L)
{
Node *pos;
pos=L->next;
cout << "输出表达式：";
while(pos!=NULL)
{
if(pos->c>0)
{
cout << "+";
}
if(pos->c!=1)
{
cout c;
}
if(pos->e!=0)
{
cout << "x^";
cout e;
}
pos=pos->next;
}
cout << endl;
}
主单元文件main.cpp:
#include
#include
#include
#include "ListOper.h"
using namespace std;
LinkList AnayString(char aString[], int aLength);
int main(int argc, char *argv[]) //-------------------------------
{
LinkList L;
char InStr[1024];
int len;
cout << "一元稀疏多项式计算器" << endl;
cout << "Copyright@1999-2004, Gashero Liu." << endl;
cout << "作者：刘晓明" << endl << endl;
cout << "请输入一个1024个字符以内的稀疏多项式：";
cin >> InStr;
len=strlen(InStr);
L=AnayString(InStr,len);
SortList(L);
OutPutList(L);
FreeList(L);
system("PAUSE");
return 0;
}
LinkList AnayString(char aString[], int aLength) //---------------
//TODO: 字符串分析函数
{
LinkList L=NULL;
Node *pos=NULL;
Node *last;
Node *head;
CreateList(L);
head=L;
last=head;
int c=0;
int e=0;
char temp[1];
char tp;
bool plus=true;
char status='n'; //状态指示符,我省略了系数为负的情况
/*
n: 非运算状态
c: 正在计算系数
e: 正在计算指数
p: 指数为0
f: 完成了一个项目的输入
*/
for(int i=0;i<aLength;i++)
{
temp[0]=aString[i];
tp=temp[0];
switch(status)
{
case 'n':
{
c=0;e=0;
status='c';
if(tp=='-')
{
plus=false;
continue;
}
if(isdigit(tp))
{
c=atoi(temp);
continue;
}
if(tp=='x')//多项式以x开头
{
c=1;
status='e';
continue;
}
}
case 'c':
{
if(isdigit(aString[i]))
{
if(plus)
{
c=c*10+atoi(temp);
}
else
{
c=c*10-atoi(temp);
}
continue;
}
if(tp=='x')
{
if(c==0)
{
c=1;
}
status='e';
e=0;
continue;
}
//此处考虑了常数项出现在其他位置的可能
if(tp=='+')
{
plus=true;
status='p';
continue;
}
if(tp=='-')
{
plus=false;
status='p';
continue;
}
/*if(temp[0]=='^')
{
status='e';
e=0;
continue;
}*/ //此种情况不可能出现
continue;
} //正在解析系数
case 'e':
{
if(tp=='^')
{
continue;
}
if(isdigit(tp))
{
e=e*10+atoi(temp);
continue;
}
if(tp=='+')
{
plus=true;
status='f';
continue;
}
if(tp=='-')
{
plus=false;
status='f';
continue;
}
} //正在解析系数
case 'p':
{
e=0;
status='f';
continue;
}
case 'f':
{
pos=CreateNode(e,c);
last->next=pos;
last=pos;
c=0;e=0;
status='c';
i--;
continue;
}
}
}
pos=CreateNode(e,c);
last->next=pos;
return L;
}
6. 我的数据结构课程设计！！！
10.哈夫曼编\译码器我有啊
# define max 50
> struct a
> {
> int weight;
> int parent,lchild,rchild;
> };
> struct b
> {
> char cd[max];
> int start;
> };
> main()
> {
> struct a ht[2*max];
> struct b hcd[max],d;
> int i,j,k,n,c,s1,s2,m1,m2,f;
> printf("shu ru n:
");
> scanf("%d",&n);
> for(i=1;i<=n;i++)
> {
> printf("shu ru quan zhi :");
> scanf("%d",&ht[i].weight);
> ht[i].parent=0;
> }
> for(;i<=2*n-1;i++)
> ht[i].parent=ht[i].lchild=ht[i].rchild=0;
> for(i=n+1;i<=2*n-1;i++)
> {
> m1=m2=30000;
> s1=s2=0;
> for(k=1;k<=i-1;k++)
> {
> if(ht[k].parent==0 && ht[k].weight<m1)
> {
> m2=m1;
> s2=s1;
> m1=ht[k].weight;
> s1=k;
> }
> else if(ht[k].parent==0 && ht[k].weight<m2)
> {
> m2=ht[k].weight;
> s2=k;
> }
> }
> ht[s1].parent=ht[s2].parent=i;
> ht[i].lchild=s1;
> ht[i].rchild=s2;
> ht[i].weight=ht[s1].weight+ht[s2].weight;
> }
> for(i=1;i<=n;i++)
> {
> d.start=n-1;
> c=i;
> f=ht[i].parent;
> while(f)
> {
> if(ht[f].lchild==c)d.cd[--d.start]='0';
> else d.cd[--d.start]='1';
> c=f;
> f=ht[f].parent;
> }
> hcd[i]=d;
> }
> printf("shu chu ha fu bian ma
");
> for(i=1;i<=n;i++)
> {
> printf("%d ",ht[i].weight);
> for(k=hcd[i].start;k<n-1;k++)
> printf("%c",hcd[i].cd[k]);
> printf("
");
> }
> }
>
>
7. 求助：数据结构课程设计
#include
#include
#include /*文本每行以字符串形式存储，行与行之间以链表存储*/
typedef struct line
{
char *data;
struct line *next;
}LINE; /*创建一链表，同时向里面输入文本数据*/
void Create(LINE * &head)
{
printf ("请输入一页文章，以Ctrl+E(^E)为结尾(每行最多输入80字符!):\n");
LINE *p=new LINE; /*首先为链表 建立一个附加表头结点*/
head=p; /*将p付给 表头指针*/
char tmp[100];
while(1)
{
gets(tmp); /*输入字符串！*/
if(strlen(tmp)>80)
{
printf("每行最多输入80字符");
break;
}
if(tmp[0]==5)break; /*如果发现输入 ^E，则退出输入*/
p=p->next=new LINE;
p->data=new char[strlen(tmp)+1]; /*为结点分配空间 */
strcpy(p->data,tmp);
if(tmp[strlen(tmp)-1]==5) /*除去最后一个控制符 ^E */
{
p->data[strlen(tmp)-1]='\0';
break;
}
}
p->next=NULL; /*最后的一个指针为空 */
head=head->next;
}
/*统计字母数*/
int CountLetter(LINE * &head)
{
LINE *p=head;
int count=0;
do
{
int Len=strlen(p->data); /*计算当前 data 里的数据元素的个数*/
for(int i=0;i<Len;i++)
if((p->data[i]>='a'&&p->data[i]data[i]>='A'&&p->data[i]<='Z')) /*计算字母数*/
count++;
}
while((p=p->next)!=NULL); /*遍历 链表*/
return count; /*返回文章的字母总数*/
}
/*统计数字数*/
int CountNumber(LINE * &head)
{
LINE *p=head;
int count=0;
do
{
int Len=strlen(p->data); /*计算当前 data 里的数据元素的个数*/
for(int i=0;i<Len;i++)
if(p->data[i]>=48 && p->data[i]<=57)count++;
/*计算数字数，ASCII码*/
}
while((p=p->next)!=NULL); /*遍历 链表*/
return count;
}
/*统计空格数*/
int CountSpace(LINE * &head)
{
LINE *p=head;
int count=0;
do
{
int Len=strlen(p->data); /*计算当前 data 里的数据元素的个数*/
for(int i=0;i<Len;i++)
if(p->data[i]==32)count++; /*计算空格数，空格ASCII码为32*/
}
while((p=p->next)!=NULL); /*遍历 链表*/
return count;
}
/*统计文章的总字数*/
int CountAll(LINE * &head)
{
LINE *p=head; /*保存链表的首地址*/
int count=0;
do /*计算总字符数*/
{
count+=strlen(p->data);
}
while((p=p->next)!=NULL); /*遍历 链表*/
return count;
}
/*统计str在文章中出现的次数*/
int FindString(LINE * &head,char *str)
{
LINE *p=head;
int count=0;
int h=0;
int len1=0; /*保存当前行的总字符数*/
int len2=strlen(str); /*待统计字符串的长度*/
int i,j,k;
do
{
len1=strlen(p->data); /*当前行的字符数*/
for(i=0;i<len1;i++) /*字符匹配*/
{
if(p->data[i]==str[0])
{
k=0;
for(j=0;j<len2;j++)
if(p->data[i+j]==str[j]) k++;
if(k==len2) {count++;i=i+k-1;}
}
}
}
while((p=p->next)!=NULL); /*遍历 链表*/
return count;
}
/*删除指定的字符串*/
void delstringword(char *s,char *str)
/* *s为输入的字符串，*str为将要删除的字符*/
{
char *p=strstr(s,str); /*从字符串s中寻找str第一次出现的位置*/
char tmp[80];
int len=strlen(s);
int i=len-strlen(p);
int j=i+strlen(str);
int count=0;
for(int m=0;m<i;m++)tmp[count++]=s[m];
for(int n=j;n<len;n++)tmp[count++]=s[n];
tmp[count]='\0';
strcpy(s,tmp); /*返回新的字符串*/
}
void DelString(LINE * &head,char *str)
{
LINE *p=head;
do
{
if(strstr(p->data,str)!=NULL)delstringword(p->data,str);
}
while((p=p->next)!=NULL); /*遍历 链表*/
}
/*向屏幕输出文章*/
void OutPut(LINE * &head)
{
LINE *p=head;
do
{
printf("%s\n",p->data);
}
while((p=p->next)!=NULL); /*遍历 链表*/
}
void main()
{
LINE *head;
Create(head);
printf("输入的文章为:\n");
OutPut(head);
printf("\n");
printf("全部字母数：%d \n",CountLetter(head));
printf("数字个数：%d \n",CountNumber(head));
printf("空格个数: %d \n",CountSpace(head));
printf("文章总字数: %d \n",CountAll(head));
char str1[20],str2[20];
printf("\n");
printf("请输入要统计的字符串:");
scanf("%s",str1);
printf("%s出现的次数为:%d \n",str1,FindString(head,str1));
printf("\n");
printf("请输入要删除的某一字符串：");
scanf("%s",str2);
DelString(head,str2);
printf("删除%s后的文章为:\n",str2);
OutPut(head);
}
8. 求 数据结构课程设计
用C++写一个类, list, stack, tree或者其他都可以，网上很多数据结构的代码了，随便照抄都行。http://code.ddvip.com/ 如果嫌规模小了，就多写几个这样的类，把它做成一个库，考试过关没什么问题了。 如果你自己写出了这些，你的水平就提高很多了。 我以前就这么做，代码写的比较完善，分数还可以，90多。
最新文章
热门文章
推荐阅读