目录
第一次作业
数组处理
第二次作业
快速排序
第三次作业
结构体到单链表
单链表操作
第四次作业
n!及斐波那契数列递归与非递归
双向链表操作
回文判断--栈实现
进制转换优化版--栈实现
链栈操作
第五次作业
队列-循环顺序表
队列-链表实现
约瑟夫环-数组
约瑟夫环-循环链表
约瑟夫环-栈
约瑟夫环-队列循环表
迷宫-链队实现
迷宫-链栈实现
第一次作业
数组处理
#include<stdio.h>
#define MAX 100
int insert(int a[],int n,int i,int x)
{
int j;
if(n+1>MAX)
printf("无插入空间\n"); //数组只能存MAX个数
else if(i<1||i>n+1)
printf("插入位置非法\n"); //插入位置的范围为1..n+1
else
{
for(j=n-1;j>i-2;j--)
a[j+1]=a[j]; //将数组中i位置及其后面的数,依次向后移动一格
a[i-1]=x; //在i位置插入x
n++;
}
return n; //返回当前数组大小
}
int del(int a[],int n,int i)
{
int j;
if(i<1||i>n)
printf("删除位置非法\n");
else
{
for(j=i-1;j<n-1;j++)
a[j] = a[j+1];
n--;
}
return n;
}
int search(int a[],int n,int x)
{
int i;
for(i=0;i<n;i++)
{
if(a[i]==x)
return i+1;
}
return -1;
}
void printArray(int a[],int n)
{
int i;
for(i=0;;i++)
{
if(i==n-1)
{
printf("%d\n",a[i]);
break;
}
printf("%d ",a[i]);
}
}
int main()
{
int n,i,a[MAX];
int index,x;
printf("输入数组中的元素个数\n");
scanf("%d",&n);
for(i=0;i<n;i++)
scanf("%d",&a[i]);
printf("请输入要插入的位置和插入的数\n");
scanf("%d %d",&index,&x);
n = insert(a,n,index,x);
printArray(a,n);
printf("请输入要删除元素的位置\n");
scanf("%d",&index);
n = del(a,n,index);
printArray(a,n);
printf("请输入要查询的元素\n");
scanf("%d",&x);
i = search(a,n,x);
if(i!=-1)
printf("%d的位置:%d\n",x,i);
else
printf("未找到%d\n",x);
return 0;
}
第二次作业
快速排序
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<sys/time.h>
//排序函数
int qsort(int arr[],int low,int high)
{
if(high < low ) return 0;
int l = low,r = high,t = arr[l];
while(l < r)
{
while(t < arr[r] && l < r)
r--;
if(l < r)
arr[l++] = arr[r];
while(t > arr[l] && l < r)
l++;
if(l < r)
arr[r--] = arr[l];
}
arr[l] = t;
qsort(arr,low,l-1);
qsort(arr,l+1,high);
}
int main()
{ //*定义时间函数*//
struct timeval start,end;
//*读取文件*//
int n,i;
FILE *fp;
char filename[200];
printf("请输入文件路径:");
scanf("%s",filename);
if((fp=fopen(filename,"r"))==NULL)
{
printf("文件无法打开!");
return 0;
}
printf("请输入文件数据个数:");
scanf("%d",&n);
int *a;
a=(int *)malloc(n*sizeof(int));
for(i=0;i<n;i++)
{
fscanf(fp,"%d ",&a[i]);
}
//*开始排序*//
gettimeofday(&start,NULL);
qsort(a,0,n-1);
gettimeofday(&end,NULL);
printf("排序完成用时:%lf s",(end.tv_sec-start.tv_sec)+(double)(end.tv_usec-start.tv_usec)/1000000.0);
FILE *fp1;
int longth=strlen(filename)-4;
filename[longth++]='s';
filename[longth++]='o';
filename[longth++]='r';
filename[longth++]='t';
filename[longth++]='.';
filename[longth++]='t';
filename[longth++]='x';
filename[longth]='t';
if((fp1=fopen(filename,"w"))==NULL) {
printf("打开文件失败!");
return 0;}
for(i=0;i<n;i++)
fprintf(fp1,"%d ",a[i]);
fclose(fp);
fclose(fp1);
return 0;
}
第三次作业
结构体到单链表
#include<stdio.h>
/*
01 构建链表
02 初始化链表 注意头节点 直接赋值
03 输出链表
*/
struct stu{
int num;
float score;
struct stu *next;
};
/*后插*/
void binsert(struct stu *head,struct stu *a)
{
head->next=a;
head->next->next=NULL;
head=head->next;
}
/*前插*/
void finsert(struct stu *head,struct stu *a)
{
a->next=head->next;
head->next=a;
}
int main(){
struct stu a,b,c,*head,*p;
int choice;
head=new struct stu;//初始化头节点
head->next=NULL;
p=head;
a.num=1;
a.score=89;
b.num=2;
b.score=98;
c.num=3;
c.score=99;
printf("1.前插\n2.后插\n请选择你要执行的操作:");
scanf("%d",&choice);
printf("\n");
if(choice==2) {
binsert(head,&a);
binsert(head,&b);
binsert(head,&c);
}
else if(choice==1){
finsert(head,&a);
finsert(head,&b);
finsert(head,&c);
}
else{
printf("输入错误!");
return 0;
}
head=p->next;//跳过头节点
do{
printf("student number: %d score:%f\n",head->num, head->score);
head = head->next; //head->next = head
}while(head);
return 1;
}
单链表操作
/*
Project: single linkeed list (数据结构 单链表)
Date: 2021-10-7 09:26:57
Author: Frank Wang
InitList(LinkList &L) 参数:单链表L 功能:初始化 时间复杂度 O(1)
ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度 时间复杂度O(n)
ListInsert(LinkList &L,int i,ElemType e)
ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素 时间复杂度O(n)[加入了查找]
若已知p指针指向的删除 最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点
于e的元素,返回指针 时间复杂度O(n)
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
using namespace std;
#define Status int
#define ElemType int
//单链表结点数据结构
typedef struct LNode
{
ElemType data;//数据域
struct LNode *next;//指针域
}LNode,*LinkList;
//**************************基本操作函数***************************//
//初始化函数
Status InitList(LinkList &L)
{
L = new LNode;//生成头结点 这样删除等操作就不必分第一个结点和其他了
L->next = NULL;
return 1;
}
//获取单链表长度 头结点无数据,不算
int ListLength(LinkList L)
{
LinkList p=L;int sum=0;
while(p)
{
sum++;
p=p->next;
}
return sum-1;//去除头结点
}
//后插法
bool ListbInsert(LinkList &L,int i,ElemType e)
{
LNode* s;LinkList p=L;int j=0;
while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
{
p=p->next;
++j;
}
if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
{
printf("插入位置无效!!!\n");
return false;
}
s=new LNode;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
//前插法
bool ListfInsert(LinkList &L,int i,ElemType e)
{
LNode* s;LinkList p=L;int j=0;
while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
{
p=p->next;
++j;
}
LinkList n=p->next;
if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
{
printf("插入位置无效!!!\n");
return false;
}
s=new LNode;
s->data=e;
p->next=s;
s->next=n;
return true;
}
//删除函数 删除位置i的结点 即删除i-1之后的结点
bool ListDelete(LinkList &L,int i)
{
LNode* s;LinkList p=L;int j=0;
LinkList q;
while(p&&(j<i-1))//j指到i-1位置
{
p=p->next;
++j;
}
if(!(p->next)||j>i-1)//i<1或者i>ListLength(L)时,删除位置无效
{
printf("删除位置无效!!!\n");
return false;
}
q=p->next;
p->next=q->next;
free(q);//释放空间
return true;
}
//查找函数 按值查找 查找第一个等于e的结点 成功返回该结点指针,否则返回NULL
LNode *LocateElem(LinkList L,ElemType e)
{
LNode *p=L;
while(p&&(p->data!=e))
{
p=p->next;
}
return p;
}
//**************************功能实现函数**************************//
//遍历输出函数
void PrintList(LinkList L)
{
LinkList p=L->next;//跳过头结点
if(ListLength(L))
{
printf("当前单链表所有元素:");
while(p)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
else
{
printf("当前单链表已空!\n");
}
}
//插入功能函数 调用ListInsert插入
void Insert(LinkList &L)
{
int place;ElemType e;bool flag;
int c;
printf("请选择插入方式:\n1.前插\n2.后插\n");
scanf("%d",&c);
if(c==1)
{
printf("请输入要插入的位置(从1开始)及元素:\n");
scanf("%d%d",&place,&e);
flag=ListfInsert(L,place,e);
if(flag)
{
printf("插入成功!!!\n");
PrintList(L);
}
else printf("输入错误!\n");
}
else if(c==2)
{
printf("请输入要插入的位置(从1开始)及元素:\n");
scanf("%d%d",&place,&e);
flag=ListbInsert(L,place,e);
if(flag)
{
printf("插入成功!!!\n");
PrintList(L);
}
}
else printf("输入错误!\n");
}
//删除功能函数 调用ListDelete删除
void Delete(LinkList L)
{
int place;bool flag;
printf("请输入要删除的位置(从1开始):\n");
scanf("%d",&place);
flag=ListDelete(L,place);
if(flag)
{
printf("删除成功!!!\n");
PrintList(L);
}
}
//查找功能函数 调用LocateElem查找
void Search(LinkList L)
{
ElemType e;LNode *q;
printf("请输入要查找的值:\n");
scanf("%d",&e);
q=LocateElem(L,e);
if(q)
{
printf("找到该元素!\n");
}
else
printf("未找到该元素!\n");
}
//排序函数
void Sort(LinkList L)
{
LNode *n;
int m=ListLength(L);
n=L->next;
int t;
while(m)
{
while(n->next!=NULL)//冒泡排序只交换值不断开链接
{
if((n->data)>(n->next->data))
{
t=n->data;n->data=n->next->data;n->next->data=t;
}
n=n->next;
}
n=L->next;
m--;
}
printf("排序完成!\n");
return;
}
//菜单
void menu()
{
printf("********1.插入 2.删除*********\n");
printf("********3.查找 4.输出*********\n");
printf("********5.排序 6.退出*********\n");
}
//主函数
int main()
{
LinkList L;int choice;
InitList(L);
while(1)
{
menu();
printf("请输入菜单序号:\n");
scanf("%d",&choice);
if(choice==6) break;
switch(choice)
{
case 1:Insert(L);break;
case 2:Delete(L);break;
case 3:Search(L);break;
case 4:PrintList(L);break;
case 5:Sort(L);break;
default:printf("输入错误!!!\n");
}
}
return 0;
}
第四次作业
n!及斐波那契数列递归与非递归
#include<stdio.h>
#include<sys/time.h>
/*n的阶乘递归*/
//用时:0.000000 s
int func1(int n)
{
if(n)
return n*(func1(n-1));
else
return 1;
}
/*n的阶乘非递归*/
//用时:0.000000 s
int func2(int n)
{
int sum=1;
for(int i=n;i>=1;i--)
sum*=i;
return sum;
}
/*斐波那契数列递归*/
//用时: 8859.5685 s
int func3(int n)
{
if(n==1) return 0;
else if(n==1||n==2) return 1;
else return func3(n-2)+func3(n-1);
}
/*斐波那契数列非递归*/
//用时:0.016113 s
int func4(int n)
{
int i,j=0,k=1,count=0;
for(i=0;i<n/2-1;i++)
{
printf("\n%d:%d\n%d:%d ",count+1,j,count+2,k);
j=j+k;k=j+k;
count+=2;
}
j=j+k;k=j+k;
if(n%2==1) printf("\n%d:%d ",count+1,j);
else printf("\n%d:%d\n%d:%d ",count+1,j,count+2,k);
}
int main()
{
struct timeval start,end;
int choice,i,n;
printf("\n1.n的阶乘递归\n2.n的阶乘非递归\n3.斐波那契数列递归\n4.斐波那契数列非递归\n");
printf("\n请选择要执行的程序:");
scanf("%d",&choice);
printf("\n请输入n的值:") ;
scanf("%d",&n);
gettimeofday(&start,NULL);
switch(choice)
{
case 1:
printf("%d ",func1(n));break;
case 2:
printf("%d",func2(n));break;
case 3:
for(i=1;i<=n;i++)
printf("%d ",func3(i));
break;
case 4:
func4(n);break;
}
gettimeofday(&end,NULL);
printf("\n用时:%lf s",(end.tv_sec-start.tv_sec)+(double)(end.tv_usec-start.tv_usec)/1000000.0);
}
双向链表操作
/*
Project: single linkeed list (数据结构 单链表)
Date: 2021-10-7 09:26:57
Author: Frank Wang
InitList(LinkList &L) 参数:单链表L 功能:初始化 时间复杂度 O(1)
ListLength(LinkList L) 参数:单链表L 功能:获得单链表长度 时间复杂度O(n)
ListInsert(LinkList &L,int i,ElemType e)
ListDelete(LinkList &L,int i) 参数:单链表L,位置i 功能:删除位置i元素 时间复杂度O(n)[加入了查找]
若已知p指针指向的删除 最好是O(1),因为可以与后继结点交换数据域,然后删除后继结点。
最坏是O(n),即从头查找p之前的结点,然后删除p所指结点
于e的元素,返回指针 时间复杂度O(n)
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
using namespace std;
#define Status int
#define ElemType int
//单链表结点数据结构
typedef struct LNode
{
struct LNode *prior;//前指针
ElemType data;//数据域
struct LNode *next;//后指针
}LNode,*LinkList;
//**************************基本操作函数***************************//
//初始化函数
Status InitList(LinkList &L)
{
L = new LNode;//生成头结点 这样删除等操作就不必分第一个结点和其他了
L->next = NULL;
L->prior = NULL;
return 1;
}
//获取单链表长度 头结点无数据,不算
int ListLength(LinkList L)
{
LinkList p=L;int sum=0;
while(p)
{
sum++;
p=p->next;
}
return sum-1;//去除头结点
}
//后插法
bool ListbInsert(LinkList &L,int i,ElemType e)
{
LNode* s;LinkList p=L;int j=0;
while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
{
p=p->next;
++j;
}
if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
{
printf("插入位置无效!!!\n");
return false;
}
s=new LNode;
s->data=e;
s->next=p->next;
p->next=s;
s->prior=p;
if(s->next!=NULL)
s->next->prior=s;
return true;
}
//前插法
bool ListfInsert(LinkList &L,int i,ElemType e)
{
LNode* s;LinkList p=L;int j=0;
while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
{
p=p->next;
++j;
}
LinkList n=p->next;
if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
{
printf("插入位置无效!!!\n");
return false;
}
s=new LNode;
s->data=e;
s->next=n;
s->prior=p;
p->next=s;
if(s->next!=NULL)
n->prior=s;
return true;
}
//删除函数 删除位置i的结点 即删除i-1之后的结点
bool ListDelete(LinkList &L,int i)
{
LNode* s;LinkList p=L;int j=0;
LinkList q;
while(p&&(j<i-1))//j指到i-1位置
{
p=p->next;
++j;
}
if(!(p->next)||j>i-1)//i<1或者i>ListLength(L)时,删除位置无效
{
printf("删除位置无效!!!\n");
return false;
}
q=p->next;
p->next=q->next;
free(q);//释放空间
return true;
}
//查找函数 按值查找 查找第一个等于e的结点 成功返回该结点指针,否则返回NULL
LNode *LocateElem(LinkList L,ElemType e)
{
LNode *p=L;
while(p&&(p->data!=e))
{
p=p->next;
}
return p;
}
//**************************功能实现函数**************************//
//遍历输出函数
//正序输出
void PrintPList(LinkList L)
{
LinkList p=L->next;//跳过头结点
if(ListLength(L))
{
printf("当前单链表所有元素:");
while(p)
{
printf("%d ",p->data);
p=p->next;
}
printf("\n");
}
else
{
printf("当前单链表已空!\n");
}
}
//逆序输出
void printRList(LinkList L)
{
LinkList p;
p=L;
while(p->next)
p=p->next;
if(ListLength(L))
{
printf("当前单链表所有元素:");
while(p->prior)
{
printf("%d ",p->data);
p=p->prior;
}
printf("\n");
}
else
{
printf("当前单链表已空!\n");
}
}
//插入功能函数 调用ListInsert插入
void Insert(LinkList &L)
{
int place;ElemType e;bool flag;
int c;
printf("请选择插入方式:\n1.前插\n2.后插\n");
scanf("%d",&c);
if(c==1)
{
printf("请输入要插入的位置(从1开始)及元素:\n");
scanf("%d%d",&place,&e);
flag=ListfInsert(L,place,e);
if(flag)
{
printf("插入成功!!!\n");
PrintPList(L);
}
else printf("输入错误!\n");
}
else if(c==2)
{
printf("请输入要插入的位置(从1开始)及元素:\n");
scanf("%d%d",&place,&e);
flag=ListbInsert(L,place,e);
if(flag)
{
printf("插入成功!!!\n");
PrintPList(L);
}
}
else printf("输入错误!\n");
}
//删除功能函数 调用ListDelete删除
void Delete(LinkList L)
{
int place;bool flag;
printf("请输入要删除的位置(从1开始):\n");
scanf("%d",&place);
flag=ListDelete(L,place);
if(flag)
{
printf("删除成功!!!\n");
PrintPList(L);
}
}
//查找功能函数 调用LocateElem查找
void Search(LinkList L)
{
ElemType e;LNode *q;
printf("请输入要查找的值:\n");
scanf("%d",&e);
q=LocateElem(L,e);
if(q)
{
printf("找到该元素!\n");
}
else
printf("未找到该元素!\n");
}
//排序函数
void Sort(LinkList L)
{
LNode *n;
int m=ListLength(L);
n=L->next;
int t;
while(m)
{
while(n->next!=NULL)
{
if((n->data)>(n->next->data))
{
t=n->data;n->data=n->next->data;n->next->data=t;
}
n=n->next;
}
n=L->next;
m--;
}
printf("排序完成!\n");
return;
}
//头节点变尾节点
void Ftl(LinkList L)
{
LinkList p=L,q=L->next,y=L;
while(p->next!=NULL)//指针移动到尾节点
p=p->next;
if(p=y)
{
printf("当前链表只有头节点!\n");
return ;
}
q->prior=y->prior;
y->next=p->next;
p->next=y;
y->prior=p;
printf("移动成功!\n");
}
//菜单
void menu()
{
printf("********1.插入 2.删除************\n");
printf("********3.查找 4.正序输出********\n");
printf("********5.逆序输出 6.排序************\n");
printf("********7.头节点变尾节点 8.退出**\n");
}
//主函数
int main()
{
LinkList L;int choice;
InitList(L);
while(1)
{
menu();
printf("请输入菜单序号:\n");
scanf("%d",&choice);
if(choice==8) break;
switch(choice)
{
case 1:Insert(L);break;
case 2:Delete(L);break;
case 3:Search(L);break;
case 4:PrintPList(L);break;
case 5:printRList(L);break;
case 6:Sort(L);break;
case 7:Ftl(L);break;
default:printf("输入错误!!!\n");
}
}
return 0;
}
回文判断--栈实现
#include<stdio.h>
#include<string.h>
#include<malloc.h>
typedef struct StackNode{
char c;
struct StackNode *next;
}StackNode,*LinkStack;
/*初始化*/
int re_stack(LinkStack &S)
{
S=NULL;
return 1;
}
/*进栈 */
int in_stack(LinkStack &S,char e)
{
LinkStack p;
p=new StackNode;/*建立新节点*/
p->c=e;
p->next=S;
S=p;
return 1;
}
/*出栈*/
int out_stack(LinkStack &S,char *e)
{
LinkStack p;
p=S;
* e=S->c;
S=S->next;
free(p);//释放空间
return 1;
}
/*主函数*/
int main(){
char c[100],a[100],e;
int i,longth;
LinkStack top;
re_stack(top);
printf("请输入字符串:");
scanf("%s",c);
longth=strlen(c);
for(i=0;i<longth;i++)//将输入字符入栈
in_stack(top,c[i]);
i=0;
while(top!=NULL){//将字符全部出栈
out_stack(top,&e);
a[i]=e;
i++;
}
if(strcmp(c,a)) printf("非回文结构!\n");//若出栈与入栈相同则为回文结构
else printf("是回文结构!\n");
return 0;
}
进制转换优化版--栈实现
#include<stdio.h>
#include<malloc.h>
#include<string.h>
#include<math.h>
#define Max 1000
typedef struct StackNode{
int data;
struct StackNode *next;
}StackNode,*LinkStack;
//*链栈的初始化*//
int re_stack(LinkStack &S)
{
S=NULL;
return 1;
}
//*链栈的栈空判断*//
int if_empty(LinkStack &S)
{
if(S==NULL) return 1;
else return 0;
}
//*链栈的入栈*//
int in_stack(LinkStack &S,int e)
{
LinkStack p;
p=new StackNode;// 分配空间
p->data=e;
p->next=S;
S=p;
return 1;
}
//*链栈的出栈*//
int out_stack(LinkStack &S)
{
LinkStack p;
int e;
if(if_empty(S))
{
printf("当前栈空!!\n");
return 0;
}
p=S;
e=S->data;
S=S->next;
free(p);
return e;
}
/*字符到数字的转换*/
int char_int(char c)
{
int n;
if(c<=57) n=(int)c-48;//c字符在'0'~'9'范围时转换成数字0~9
else n=(int)c-55;//c字符在'A'~...范围时转换为10~...
return n;
}
/*数字到字符的转换*/
char int_char(int n)
{
char c;
if(n<9) c=(char)(n+48);//n小于9时转换成字符
else c=(char)(n+55);//n大于10时转化为字母
return c;
}
/*任意进制转10进制*/
int in10(char c[],int f)
{
int sum=0,i=0,j;
while(c[i]!='\0')
{
j=char_int(c[i]);
if(j>=f)
{
printf("输入错误!\n");
return 0;
}
sum=sum*f+j;
i++;
}
return sum;
}
/*十进制转任意进制*/
int out10(LinkStack &S,int sum,int h)
{
while(sum)
{
in_stack(S,sum%h);//入栈转换为目标进制
sum=sum/h;
}
}
/*输出*/
int printstack(LinkStack &S,char c[],int f,int h)
{
printf("%s(%d)的%d进制数为:",c,f,h);
while(S!=NULL)
printf("%c",int_char(out_stack(S)));
printf("(%d)\n",h);
}
/*主函数*/
int main()
{
LinkStack top;
re_stack(top);//初始化
char str[Max];
int sum,f,h;//f为输入数值的进制,h为要转换的进制
while(1)
{
printf("请输入任意进制数:");
scanf("%s",str);
printf("========================\n1.退出\n2.二进制\n3.三进制\n4.四进制\n....\nn.n进制\n");
printf("请选择已输入数的进制:");
scanf("%d",&f);
if(f==1) return 0;
else if(f<1)
{
printf("输入错误!\n");
continue;
}
sum=in10(str,f);//获取十进制数
printf("========================\n1.退出\n2.二进制\n3.三进制\n4.四进制\n....\nn.n进制\n");
printf("请选择要转换的进制:");
scanf("%d",&h);
if(h==1) return 0;
else if(h<1)
{
printf("输入错误!\n");
continue;
}
out10(top,sum,h);
printf("========================\n");
printstack(top,str,f,h);//输出结果
}
return 1;
}
链栈操作
#include<stdio.h>
#include<malloc.h>
typedef struct StackNode
{
int data;
struct StackNode *next;
}StackNode,*LinkStack;
//*链栈的初始化*//
int re_stack(LinkStack &S)
{
S=NULL;
return 1;
}
//*链栈的清空*//
int clear_stack(LinkStack &S)
{
while(S!=NULL)
{
LinkStack p;
p=S;
S=S->next;
free(p);
}
return 1;
}
//*链栈的销毁*//
int destory_stack(LinkStack &S)
{
clear_stack(S);
free(S);
return 1;
}
//*链栈的栈空判断*//
int if_empty(LinkStack &S)
{
if(S==NULL) return 1;
else return 0;
}
//*链栈的入栈*//
int in_stack(LinkStack &S,int e)
{
LinkStack p;
p=new StackNode;
p->data=e;
p->next=S;
S=p;
return 1;
}
//*链栈的出栈*//
int out_stack(LinkStack &S,int *e)
{
LinkStack p;
if(if_empty(S))
{
printf("当前栈空!!\n");
return 0;
}
p=S;
* e=S->data;
S=S->next;
free(p);
return 1;
}
//*得到栈顶元素*//
int gettop(LinkStack &S,int *e)
{
if(if_empty(S))
{
printf("当前栈空!!\n");
return 0;
}
* e=S->data;
return 1;
}
//*栈的遍历*//
int print_stack(LinkStack &S)
{
if(if_empty(S))
{
printf("当前栈空!!\n");
return 0;
}
LinkStack p=S;
printf("当前栈中元素:");
while(p->next!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
printf("%d\n",p->data);
return 1;
}
int main()
{
LinkStack top;
int chioce,e;
while(1)
{
printf("1.初始化\n2.销毁\n3.清空\n4.判断栈空\n5.入栈\n6.出栈\n7.获取栈顶元素\n8.输出栈\n9.退出\n==========================\n");
printf("请输入要执行的操作:");
scanf("%d",&chioce);
if(chioce==9) return 0;
switch(chioce)
{
case 1:if(re_stack(top)) printf("初始化成功!\n");break;
case 2:if(destory_stack(top)) printf("销毁成功!\n");break;
case 3:if(clear_stack(top)) printf("清空成功!\n");break;
case 4:if(if_empty(top)) printf("当前栈空!\n");else printf("当前栈非空!\n");break;
case 5:printf("输入数据:");scanf("%d",&e);if(in_stack(top,e)) printf("入栈成功!\n");break;
case 6:if(out_stack(top,&e)) printf("出栈元素为:%d\n",e);break;
case 7:if(gettop(top,&e)) printf("栈顶元素为:%d\n",e);break;
case 8:print_stack(top);break;
}
}
return 1;
}
第五次作业
队列-循环顺序表
#include <stdio.h>
#include <stdlib.h>
#define size 100
/*定义结构体*/
typedef struct Q{
int *data;
int fornt;
int rear;
}LinkQueue;
/*初始化*/
int re_creat(LinkQueue &Q)
{
Q.data=new int[size];
if(!Q.data) {
printf("初始化失败!\n");
exit(0);
}
Q.fornt=Q.rear=0;
return 1;
}
/*判断是否为空*/
int EmptyQ(LinkQueue &Q)
{
return Q.fornt==Q.rear;
}
/*判断是否满*/
int MaxQ(LinkQueue &Q)
{
return (Q.rear+1)%size==Q.fornt;
}
/*获取长度*/
int GetLongth(LinkQueue &Q)
{
return (Q.rear-Q.fornt+size)%size;
}
/*进队*/
int InQ(LinkQueue &Q,int e)
{
if(MaxQ(Q))
{
printf("当前队满!\n");
return 0;
}
Q.data[Q.rear]=e;
Q.rear=(Q.rear+1)%size;
return 1;
}
/*出队*/
int OutQ(LinkQueue &Q,int &e)
{
if(EmptyQ(Q))
{
printf("当前队空!\n");
return 0;
}
e = Q.data[Q.fornt];
Q.fornt=(Q.fornt+1)%size;
return 1;
}
/*获取队头元素*/
int GetHead(LinkQueue &Q,int &e)
{
if(EmptyQ(Q))
{
printf("当前队空!\n");
return 0;
}
e = Q.fornt;
return 1;
}
/*清空*/
int DestoryQ(LinkQueue &Q)
{
free(Q.data);
Q.fornt=Q.rear=0;
return 1;
}
/*遍历*/
int PrintfQ(LinkQueue &Q)
{
if(EmptyQ(Q))
{
printf("当前队空!\n");
return 0;
}
int i=Q.fornt;
printf("队列元素有:");
while(1)
{
if(((i+1-Q.fornt+size)%size)%GetLongth(Q)==0) break;
printf("%d ",Q.data[i]);
i=(i+1)%size;
}
if(!MaxQ(Q))
printf("%d ",Q.data[i]);
printf("\n");
return 1;
}
int main()
{
LinkQueue Q;
re_creat(Q);
int choice;
int data,i,n;
while(1)
{
printf("=============================\n");
printf("******1.入队 2.出队******\n");
printf("******3.队头 4.队尾******\n");
printf("******5.队长 6.遍历******\n");
printf("******7.清空 8.退出******\n");
printf("=============================\n");
printf("请输入要执行操作:");
scanf("%d",&choice);
if(choice==8)
return 0;
switch(choice)
{
case 1:
printf("请输入元素个数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("请输入第%d个元素:",i+1);
scanf("%d",&data);
InQ(Q,data);
};
break;
case 2:
printf("请输入元素个数:");
scanf("%d",&n);
printf("出队元素有:") ;
for(i=0;i<n;i++)
{
OutQ(Q,data);
printf("%d ",data);
};
break;
case 3:
GetHead(Q,data);
printf("队头元素为:%d\n",data);
break;
case 4:break;
case 5:
int longth;
longth = GetLongth(Q);
printf("队长度为:%d",longth);
break;
case 6:
PrintfQ(Q);
break;
case 7:
DestoryQ(Q);
break;
}
}
printf("\n");
return 1;
}
队列-链表实现
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
// 队列的节点
struct Node
{
int data;
struct Node* next;
};
// 队首队尾指针
struct Queue
{
struct Node* front;
struct Node* rear;
int size;
};
// 链队初始化
void QueueInit(struct Queue* queue)
{
queue->front = NULL;
queue->rear = NULL;
queue->size = 0;
}
// 判断是否为空
int QueueEmpty(struct Queue* queue)
{
return (queue->size == 0);
}
// 入队
void QueuePush(struct Queue* queue, const int data)
{
struct Node* node;
node = (struct Node*)malloc(sizeof(struct Node));
assert(node != NULL);
node->data = data;
node->next = NULL;
if(QueueEmpty(queue))
{
queue->front = node;
queue->rear = node;
}
else
{
queue->rear->next = node;
queue->rear = node;
}
++queue->size;
}
//出队
int QueuePop(struct Queue* queue, int* data)
{
if (QueueEmpty(queue))
{
return 0;
}
struct Node* tmp = queue->front;
*data = queue->front->data;
queue->front = queue->front->next;
free(tmp);
--queue->size;
return 1;
}
//获取队头元素
void GetHead(struct Queue* queue)
{
if(!QueueEmpty(queue))
{
printf("当前队列为空!\n");
return ;
}
printf("队头元素为:%d \n",queue->front->data);
return ;
}
// 获取队尾元素
//获取队列长度
int GetLongth(struct Queue* queue)
{
return queue->size;
}
//链队的销毁
void QueueDestroy(struct Queue* queue)
{
struct Node* tmp;
while(queue->front)
{
tmp = queue->front;
queue->front = queue->front->next;
free(tmp);
}
}
//链队输出//
void printfQueue(struct Queue Q)
{
struct Queue q;
q=Q;
printf("队列元素有:") ;
while(q.front!=NULL)
{
printf("%d ",q.front->data);
q.front=q.front->next;
}
printf("\n");
}
//主函数
int main(void)
{
struct Queue queue;
QueueInit(&queue);
int choice;
int data,i,n;
while(1)
{
printf("=============================\n");
printf("******1.入队 2.出队******\n");
printf("******3.队头 4.队尾******\n");
printf("******5.队长 6.遍历******\n");
printf("******7.销毁 8.退出******\n");
printf("=============================\n");
printf("请输入要执行操作:");
scanf("%d",&choice);
if(choice==8)
return 0;
switch(choice)
{
case 1:
printf("请输入元素个数:");
scanf("%d",&n);
for(i=0;i<n;i++)
{
printf("请输入第%d个元素:",i+1);
scanf("%d",&data);
QueuePush(&queue,data);
};
break;
case 2:
printf("请输入元素个数:");
scanf("%d",&n);
printf("出队元素有:") ;
for(i=0;i<n;i++)
{
QueuePop(&queue,&data);
printf("%d ",data);
};
break;
case 3:
GetHead(&queue);
break;
case 4:break;
case 5:
int longth;
longth = GetLongth(&queue);
printf("队长度为:%d",longth);
break;
case 6:
printfQueue(queue);
break;
case 7:
QueueDestroy(&queue);
break;
}
}
printf("\n");
return 0;
}
约瑟夫环-数组
/*
有n个人围城一圈,按顺序编号,从第一个人开始报数,从1报到m,凡报到m的人退出圈子,
然后接着报数,问最后留下来的是原来的第几号的那位?
*/
//数组
//用长度为n的数组存储人的编号,退出的人编号置为0,当n-1个人都退出后,剩下的那个编号不为0的人就是要找的人。
#include <stdio.h>
#include <malloc.h>
void left_num(int* a,int n,int m) {
int out = 0,count = 0,i = 0; //out为出去的人数,count为报数,i为目前报到第几个人
int *p = a;
int num = 0;
for(num = 0;num < n;num++) {
*(a+num) = num+1;
} //为n个人编号1-n
while (out < n-1) {
if (*(p+i) != 0) {
count ++; //不等于0才报数+!
}
if (count == m) {
count = 0;
*(p+i) = 0;
out++; //报道m那么,出列人数out+1,且内容置0,报数置0
printf("%d\n",i+1);
}
i++;
if (i == n) {
i = 0; //到队尾重头开始
}
if(out==15)
break;
}
//输出剩下的人
for (num = 0; num < n; num++) {
if (*(a+num) != 0) {
printf("left num:%d\n",*(a+num));
}
}
}
int main()
{
int m,n;
int a[50] = {0};
printf("Please input total num:");
scanf("%d",&n);
printf("Please input out num:");
scanf("%d",&m);
printf("leave sequence:\n");
left_num(a,n,m);
return 0;
}
约瑟夫环-循环链表
/*
有n个人围城一圈,按顺序编号,从第一个人开始报数,从1报到m,凡报到m的人退出圈子,
然后接着报数,问最后留下来的是原来的第几号的那位?
*/
//循环链表实现
//构造一个循环链表,链表节点的数据域存放人的编号,遍历整个链表,每次报到m的人退出,并释放该节点,直到链表只剩一个节点。
#include <stdio.h>
#include <malloc.h>
/*构建结构体*/
typedef struct Node{
int Num;
struct Node *next;
}JoseNode, *PNode, *HNode;
/**********初始化循环单链表*********/
int JoseInit(HNode h)
{
if (!h)
{
printf("初始化链表错误!\n");
return 0;
}
(h)->next = (h);//循环单链表
return 1;
}
/*************单链表插入操作**********/
int JoseInsert(JoseNode *h, int pos, int x)
{
PNode p=h,q;
int i=1;
if (pos == 1)/*尾插法*/
{
p->Num = x;
p->next = p;
return 1;
}
while(i<pos-1)
{
p=p->next;
i++;
}
q=(PNode)malloc(sizeof(JoseNode));
q->Num=x;
q->next=p->next;
p->next=q;
return 1;
}
/*遍历*/
void TraverseList(HNode h, int M)
{
int i = 0;
PNode p = h;
printf("参与的人的编号为:\n");
while (i<M)
{
printf("%d\t", p->Num);
p = p->next;
i++;
}
printf("\n");
}
/**************出局函数****************/
int JoseDelete(HNode h, int M, int k)
{ int i;
PNode p=h,q;
while(M>15)
{
for(i=1;i<k-1;i++)
{
p=p->next;
}
q=p->next;
p->next=q->next;
printf("出局的人为:%d号\n",q->Num);
free(q);
p=p->next;
M--;
}
return 1;
}
//遍历幸存者
void PrintfSurvivor(HNode h)
{
HNode p=h;
printf("幸存者有:");
printf("%d ",p->Num);
p=p->next;
while(p!=h)
{
printf("%d ",p->Num);
p=p->next;
}
}
/***************************************/
int main()
{
int i;//计数器
int N;//参与的人数
int k;//报数密码
printf("请输入参与人数:");
scanf("%d",&N);
printf("请输入出局密码:");
scanf("%d",&k);
/**************得到头结点****************/
HNode h = ((HNode)malloc(sizeof(JoseNode)));
/***************初始化单链表************/
JoseInit(h);
/******将编号插入到循环单链表中******/
for (i = 1; i <=N; i++)
{
JoseInsert(h, i, i);
}
/**************遍历单链表***************/
TraverseList(h,N);
/***************出局函数************/
if(k > 1)
{
JoseDelete(h, N, k);
PrintfSurvivor(h);
}
else
{
for(i = 1; i < N-15; i++)
printf("出局的人为:%d号\n",i);
PrintfSurvivor(h);
}
printf("\n");
printf("\n");
return 0;
}
约瑟夫环-栈
#include<stdio.h>
#include<stdlib.h>
typedef struct StackNode
{
int data;
struct StackNode *next;
}StackNode,*LinkStack;
//*链栈的初始化*//
int re_stack(LinkStack &S)
{
S=NULL;
return 1;
}
/*链栈的栈空判断*/
int if_empty(LinkStack &S)
{
if(S==NULL) return 1;
else return 0;
}
//*链栈的入栈*//
int in_stack(LinkStack &S,int e)
{
LinkStack p;
p=new StackNode;
p->data=e;
p->next=S;
S=p;
return 1;
}
//*链栈的出栈*//
int out_stack(LinkStack &S,int *e)
{
LinkStack p;
if(if_empty(S))
{
printf("当前栈空!!\n");
return 0;
}
p=S;
* e=S->data;
S=S->next;
free(p);
return 1;
}
/*栈的遍历*/
int print_stack(LinkStack &S)
{
if(if_empty(S))
{
printf("当前栈空!!\n");
return 0;
}
LinkStack p=S;
printf("幸存者有:");
while(p->next!=NULL)
{
printf("%d ",p->data);
p=p->next;
}
printf("%d\n",p->data);
return 1;
}
/*出局函数*/
int GoOut(LinkStack &A,LinkStack &B,int i,int j)//A为储存队员的栈,B为空栈,i为队员人数,j为出局密码
{
int num = i,count = 1,data,l=1;
while(num>15)
{
while(A)
{
if(count%j!=0)
{
out_stack(A,&data);
in_stack(B,data);
count++;
}
else
{
out_stack(A,&data);
printf("第%2d次出局的为:%d\n",l,data);
num--;
count++;
l++;
}
}
while(B)
{
out_stack(B,&data);
in_stack(A,data);
}
}
return 1;
}
int main()
{
int i;//计数器
int N;//参与的人数
int k;//报数密码
printf("请输入参与人数:");
scanf("%d",&N);
printf("请输入出局密码:");
scanf("%d",&k);
LinkStack A,B;
re_stack(A);
re_stack(B);
for(i=N;i>=1;i--)
in_stack(A,i);
GoOut(A,B,N,k);
print_stack(A);
}
约瑟夫环-队列循环表
#include <stdio.h>
#include <stdlib.h>
#define size 101 //最大容量为size-1
/*定义结构体*/
typedef struct Q{
int *data;
int fornt;//队头
int rear;//队尾
}LinkQueue;
/*初始化*/
int re_creat(LinkQueue &Q)
{
Q.data=new int[size];
if(!Q.data) {
printf("初始化失败!\n");
exit(0);
}
Q.fornt=Q.rear=0;//队头尾均指向0
return 1;
}
/*判断是否为空*/
int EmptyQ(LinkQueue &Q)
{
return Q.fornt==Q.rear;
}
/*判断是否满*/
int MaxQ(LinkQueue &Q)
{
return (Q.rear+1)%size==Q.fornt;
}
/*获取长度*/
int GetLongth(LinkQueue &Q)
{
return (Q.rear-Q.fornt+size)%size;//加size是为了防止Q.rear<Q.front
}
/*进队*/
int InQ(LinkQueue &Q,int e)
{
if(MaxQ(Q))
{
printf("当前队满!\n");
return 0;
}
Q.data[Q.rear]=e;
Q.rear=(Q.rear+1)%size;//队尾指针+1
return 1;
}
/*出队*/
int OutQ(LinkQueue &Q,int &e)
{
if(EmptyQ(Q))
{
printf("当前队空!\n");
return 0;
}
e = Q.data[Q.fornt];
Q.fornt=(Q.fornt+1)%size;//队头指针+1
return 1;
}
/*遍历*/
int PrintfQ(LinkQueue &Q)
{
if(EmptyQ(Q))
{
printf("当前队空!\n");
return 0;
}
int i=Q.fornt;
printf("幸存者有:");
while(1)
{
if(((i+1-Q.fornt+size)%size)%GetLongth(Q)==0) break;
printf("%d ",Q.data[i]);
i=(i+1)%size;
}
if(!MaxQ(Q))
printf("%d ",Q.data[i]);
printf("\n");
return 1;
}
/*出局函数*/
int GoOut(LinkQueue &Q,int i,int j)//Q为储存队员的队,i为队员人数,j为出局密码
{
int count = 1,data,l=1;
while(GetLongth(Q)>15)
{
if(count%j!=0)
{
OutQ(Q,data);
InQ(Q,data);
count++;
}
else
{
OutQ(Q,data);
printf("第%2d次出局的为:%d\n",l,data);
count++;
l++;
}
}
return 1;
}
/*主函数*/
int main()
{
int i;//计数器
int N;//参与的人数
int k;//报数密码
printf("请输入参与人数:");
scanf("%d",&N);
printf("请输入出局密码:");
scanf("%d",&k);
LinkQueue Q;
re_creat(Q);
for(i=1;i<=N;i++)
InQ(Q,i);
GoOut(Q,N,k);
PrintfQ(Q);
}
迷宫-链队实现
#include<stdio.h>
#include<stdlib.h>
/*定义迷宫及起点、终点*/
int m[10][10]={{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,0,1},
{1,0,1,1,1,0,0,0,0,1},
{1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,1,0,0,1},
{1,0,1,1,1,0,1,1,0,1},
{1,1,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}};
int a[10][10];//该数组用于记录各点运动方向
struct s{
int x,y;
}start,end;
// 队列的节点
struct Node
{
int x,y;
struct Node* next;
};
// 队首队尾指针
struct Queue
{
struct Node* front;
struct Node* rear;
int size;
};
// 链队初始化
void QueueInit(struct Queue* queue)
{
queue->front = NULL;
queue->rear = NULL;
queue->size = 0;
}
// 判断是否为空
int QueueEmpty(struct Queue* queue)
{
return (queue->size == 0);
}
// 入队
void QueuePush(struct Queue* queue, int x,int y)
{
struct Node* node;
node = (struct Node*)malloc(sizeof(struct Node));
node->x = x;
node->y = y;
node->next = NULL;
if(QueueEmpty(queue))
{
queue->front = node;
queue->rear = node;
}
else
{
queue->rear->next = node;
queue->rear = node;
}
++queue->size;
}
//出队
int QueuePop(struct Queue* queue, int *x,int *y)
{
if (QueueEmpty(queue))
{
return 0;
}
struct Node* tmp = queue->front;
*x= queue->front->x;
*y= queue->front->y;
queue->front = queue->front->next;
free(tmp);
--queue->size;
return 1;
}
/*走迷宫函数*/
int GO(struct Queue* Q)
{
int x,y,k,l;
while(!QueueEmpty(Q))
{
QueuePop(Q,&k,&l);
for(int i=0;i<=3;i++)
{
x=k;y=l;//起点归位
switch(i)
{
case 0:x=x+1;break;
case 1:y=y-1;break;
case 2:x=x-1;break;
case 3:y=y+1;break;
}
if(x>=0&&y>=0&&x<=9&&y<=9&&m[y][x]==0)
{
QueuePush(Q,x,y);
a[y][x]=i;
m[y][x]=-2;//记录走过的点
}
if(x==8&&y==8) return 1;//到达终点停止
}
}
return 0;
}
/*重新绘制迷宫*/
int ans()
{
int x=8,y=8;
while(1)
{
m[y][x]=-1;
switch(a[y][x])//从终点开始方向回溯
{
case 0:x=x-1;break;
case 1:y=y+1;break;
case 2:x=x+1;break;
case 3:y=y-1;break;
}
if(x==1&&y==1)
{
m[y][x]=-1;
return 1;
}
}
}
/*输出迷宫*/
int printfM(int m[10][10])
{
for(int i=0;i<10;i++)
{
for(int j=0;j<10;j++)
{
if(m[i][j]==1) printf("■");
else if(m[i][j]==-1) printf("* ");
else printf(" ");
}
printf("\n");
}
return 1;
}
int main()
{
struct Queue Q;
QueueInit(&Q);
printf("解迷宫前:\n");
printfM(m);
QueuePush(&Q,1,1);
GO(&Q);
ans();
printf("解迷宫后:\n");
printfM(m);
return 1;
}
迷宫-链栈实现
#include<stdio.h>
#include<stdlib.h>
/*定义迷宫及起点、终点*/
int m[10][10]={{1,1,1,1,1,1,1,1,1,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,0,1},
{1,0,1,1,1,0,0,0,0,1},
{1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,1,0,0,1},
{1,0,1,1,1,0,1,1,0,1},
{1,1,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}};
struct s{
int x,y;
}start,end;
/*定义栈的节点*/
typedef struct StackNode
{
int x,y;
struct StackNode *next;
}StackNode,*LinkStack;
//*链栈的初始化*//
int re_stack(LinkStack &S)
{
S=NULL;
return 1;
}
//*链栈的栈空判断*//
int if_empty(LinkStack &S)
{
if(S==NULL) return 1;
else return 0;
}
//*链栈的入栈*//
int in_stack(LinkStack &S,int a,int b)
{
LinkStack p;
p=new StackNode;
p->x=a;p->y=b;
p->next=S;
S=p;
return 1;
}
//*链栈的出栈*//
int out_stack(LinkStack &S,int &x,int &y)
{
LinkStack p;
if(if_empty(S))
return 0;
p=S;
x=p->x;y=p->y;
S=S->next;
free(p);
return 1;
}
/*输出迷宫*/
int printfM(int m[10][10])
{
for(int i=0;i<10;i++)
{
for(int j=0;j<10;j++)
{
if(m[i][j]==1) printf("■");
else if(m[i][j]==-1) printf("* ");
else printf(" ");
}
printf("\n");
}
return 1;
}
/*走迷宫函数*/
int GO(LinkStack &S)
{
int x,y,k;//k用于判断是否进了死胡同
m[1][1]=-1;
while(1)
{
k=0;
for(int i=0;i<4;i++)
{
x=start.x;
y=start.y;
switch(i)
{
case 0:x=x-1;break;
case 1:y=y+1;break;
case 2:x=x+1;break;
case 3:y=y-1;break;
}
if(x>=0&&y>=0&&x<=9&&y<=9&&m[y][x]==0)
{
in_stack(S,x,y);
start.x=x;start.y=y;
m[y][x]=-1;//标记走过的路
k=1;
break;
}
}
if(start.x==end.x&&start.y==end.y) break;
else if(!k)//走到死胡同把胡同路堵死,不再走这条路
{
m[start.y][start.x]=-2;
out_stack(S,x,y);
start.x=x;start.y=y;
}
}
}
int main()
{
LinkStack S;
re_stack(S);
printf("解迷宫前:\n") ;
printfM(m);
start.x=1;
start.y=1;
in_stack(S,start.x,start.y);
end.x=8;
end.y=8;
GO(S);
printf("解迷宫后:\n");
printfM(m);
return 1;
}
第六次作业
KMP与BF算法
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define M 255
int i,j,KMPcount1=0,KMPcount2=0,BFcount1=0,BFcount2=0;
int next[M+1];
typedef struct{
char ch[M+1];
int length;
}SString;
/* KMP算法*/
int Index_KMP(SString S,SString T,int pos)
{
i=pos;j=1;
while(i<=S.length&&j<=T.length)
{
if(j==0||S.ch[i]==T.ch[j]) {++i;++j;KMPcount1++;}
else {j= next[j];KMPcount2++;KMPcount1++;}
}
if(j>T.length) return i-T.length;
else return 0;
}
/*BF算法*/
int Index_BF(SString S,SString T,int pos)
{
i=pos;j=1;
while(i<=S.length&&j<=T.length)
{
if(S.ch[i]==T.ch[j]) {++i;++j;BFcount1++;}
else {i=i-j+2;j=1;BFcount2++;BFcount1++;}
}
if (j>T.length) return i-T.length;
else return 0;
}
/*获取next值*/
void get_next(SString T)
{
i=1;next[1]=0;j=0;
while(i<T.length)
{
if(j==0||T.ch[i]==T.ch[j]) next[++i]=++j;
else j=next[j];
}
}
int main()
{
SString S,T;
char s[M],t[M];
printf("请输入主串:");
scanf("%s",&s);
printf("请输入子串:");
scanf("%s",&t);
S.length=strlen(s);
for(i=1;i<=S.length;i++) S.ch[i]=s[i-1];
T.length=strlen(t);
for(j=1;j<=T.length;j++) T.ch[j]=t[j-1];
get_next(T);
if(int n =Index_KMP(S,T,1)) printf("KMP搜索完成,共匹配%d次,共匹配%d趟\n",KMPcount1,KMPcount2+1);
else printf("KMP无搜索结果!\n");
if(int m =Index_BF(S,T,1)) printf("BF搜索完成,共匹配%d次,共匹配%d趟\n",BFcount1,BFcount2+1);
else printf("BF无搜索结果!\n");
return 0;
}
经典KMP算法判断
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define M 255
int i,j;
int next[M+1];
typedef struct{
char ch[M+1];
int length;
}SString;
/* KMP算法*/
int Index_KMP(SString S,SString T,int pos)
{
i=pos;j=1;
while(i<=S.length&&j<=T.length)
{
if(j==0||S.ch[i]==T.ch[j]) {++i;++j;}
else {j= next[j];}
}
if(j>T.length) return i-T.length;
else return -1;
}
/*获取next值*/
void get_next(SString T)
{
i=1;next[1]=0;j=0;
while(i<T.length)
{
if(j==0||T.ch[i]==T.ch[j]) next[++i]=++j;
else j=next[j];
}
}
int main()
{
SString S,T;
char s[M],t[M];
printf("请输入主串:");
scanf("%s",&s);
printf("请输入子串:");
scanf("%s",&t);
S.length=strlen(s);
for(i=1;i<=S.length;i++) S.ch[i]=s[i-1];
T.length=strlen(t);
for(j=1;j<=T.length;j++) T.ch[j]=t[j-1];
get_next(T);
if(int n =Index_KMP(S,T,1)) printf("KMP搜索完成,位置为%d-%d\n",n,n+T.length-1);
else printf("KMP无搜索结果!\n");
return 0;
}
蛇形填数
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
/*方阵复位*/
int Init(int n,int a[][100])
{
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
a[j][i]=0;
return 1;
}
/*蛇形填数1(回形填数) */
int Snake1(int n,int a[][100])
{
int num=1;
a[0][0]=1;//第一位赋值
int i=0,j=0;
while(num<n*n)
{
while(i+1<n&&!a[j][i+1]) a[j][++i]=++num;//向右
while(j+1<n&&!a[j+1][i]) a[++j][i]=++num;//向下
while(i-1>=0&&!a[j][i-1]) a[j][--i]=++num;//向左
while(j-1>=0&&!a[j-1][i]) a[--j][i]=++num;//向上
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
printf("%-5d",a[i][j]);
printf("\n");
}
return 1;
}
/*蛇形填数2(三角回形填数)*/
int Snake2(int n,int a[][100])
{
int num=1;
a[0][0]=1;//第一位赋值
int sum=0;
for(int k=1;k<=n;k++)//求输入数的个数
sum+=k;
int i=0,j=0;
while(num < sum)
{
while(i+1<n&&!a[j][i+1]) a[j][++i]=++num;//向右
while(i-1>=0&&j+1<=n&&!a[j+1][i-1]) a[++j][--i]=++num;//斜向下
while(j-1>=0&&!a[j-1][i]) a[--j][i]=++num;//向上
}
int count = n;
for(i=0;i<n;i++)//输出
{
for(j=0;j<count;j++)
printf("%-5d",a[i][j]);
count--;
printf("\n");
}
return 1;
}
/*蛇形填数3*/
int Snake3(int n,int a[][100])
{
int num=1;
a[0][0]=1;
int i=0,j=0,k=i,l=j+1,count=1;
while(num<n*n)
{
if(count<n)//过对称轴时及之前前
{
j=++l;
i=-1;//归位
count++;
while(i+1<n&&j-1>=0&&!a[j-1][i+1]) a[--j][++i]=++num;//填数
}
else //过对称轴后
{
i=k++;
j=n;//归位
while(i+1<n&&j-1>=0&&!a[j-1][i+1]) a[--j][++i]=++num;//填数
}
}
for(i=0;i<n;i++)//输出
{
for(j=0;j<n;j++)
printf("%-5d",a[i][j]);
printf("\n");
}
return 1;
}
/*主函数*/
int main()
{
int n;
int a[100][100];
printf("请输入n:");
scanf("%d",&n);
printf("蛇形填数1:\n");
Init(n,a);
Snake1(n,a);
printf("\n");
printf("蛇形填数2:\n");
Init(n,a);
Snake2(n,a);
printf("\n");
printf("蛇形填数3:\n");
Init(n,a);
Snake3(n,a);
printf("\n");
while(1)
{
int i,j;
printf("请输入i,j(i代表横纵,代表纵轴):");
scanf("%d %d",&i,&j);
printf("a[%d][%d] = %d\n",j,i,a[j-1][i-1]);
int choice;
printf("1.是\n2.否\n是否继续?:");
scanf("%d",&choice);
if(choice==1) continue;
else break;
}
return 1;
}
字符串匹配1
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define M 255
int i,j;
int next[M+1];
typedef struct{
char ch[M+1];
int length;
}SString;
/* KMP算法*/
int Index_KMP(SString S,SString T,int pos)
{
i=pos;j=1;
while(i<=S.length&&j<=T.length)
{
if(j==0||S.ch[i]==T.ch[j]) {++i;++j;}
else {j= next[j];}
}
if(j>T.length) return i-T.length;
else return -1;
}
/*获取next值*/
void get_next(SString T)
{
i=1;next[1]=0;j=0;
while(i<T.length)
{
if(j==0||T.ch[i]==T.ch[j]) next[++i]=++j;
else j=next[j];
}
}
int main()
{
SString S,T;
char s[M],t[M];
printf("请输入主串:");
scanf("%s",&s);
printf("请输入子串:");
scanf("%s",&t);
S.length=strlen(s);
for(i=1;i<=S.length;i++) S.ch[i]=s[i-1];
T.length=strlen(t);
for(j=1;j<=T.length;j++) T.ch[j]=t[j-1];
get_next(T);
if(int n =Index_KMP(S,T,1)) printf("YES");
else printf("NO\n");
return 0;
}
字符串匹配2
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define M 255
int i,j;
int next[M+1];
typedef struct{
int ch[M+1];
int length;
}SString;
/* KMP算法*/
int Index_KMP(SString S,SString T,int pos)
{
i=pos;j=1;
while(i<=S.length&&j<=T.length)
{
if(j==0||S.ch[i]==T.ch[j]) {++i;++j;}
else {j= next[j];}
}
if(j>T.length) return i-T.length;
else return -1;
}
/*获取next值*/
void get_next(SString T)
{
i=1;next[1]=0;j=0;
while(i<T.length)
{
if(j==0||T.ch[i]==T.ch[j]) next[++i]=++j;
else j=next[j];
}
}
int main()
{
SString S,T;
int s[M],t[M];
int m,n;
printf("请输入总人数:");
scanf("%d",&n);
printf("请输入每个人手中的糖:");
for(i=0;i<n;i++)
scanf("%d",&s[i]);
printf("请输入要寻找的人数:");
scanf("%d",&m);
if(m>n) {printf("输入错误!");return 0;
}
printf("请再输入每个人手中的糖:");
for(i=0;i<m;i++)
scanf("%d",&t[i]);
S.length=n;
for(i=1;i<=S.length;i++) S.ch[i]=s[i-1];
T.length=m;
for(j=1;j<=T.length;j++) T.ch[j]=t[j-1];
get_next(T);
if((n =Index_KMP(S,T,1))>0) printf("确定的两个值为:%d %d",n,n-1+T.length);
else printf("不存在!\n");
return 0;
}