数据结构作业自用

最新推荐文章于 2024-05-21 22:55:36 发布

NO0mad

最新推荐文章于 2024-05-21 22:55:36 发布

阅读量194

点赞数

文章标签：数据结构

本文链接：https://blog.csdn.net/m0_56695695/article/details/121090398

版权

第一次作业

数组处理

#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;
}

NO0mad

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构作业自用

第一次作业数组处理#include<stdio.h>#define MAX 100int 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..
复制链接

扫一扫