数据结构实验

最新推荐文章于 2023-06-12 17:10:46 发布

花雨纷纷

最新推荐文章于 2023-06-12 17:10:46 发布

阅读量1k

点赞数 1

分类专栏：数据结构文章标签：数据结构

本文链接：https://blog.csdn.net/hanyu0208/article/details/106853944

版权

数据结构专栏收录该内容

1 篇文章 0 订阅

订阅专栏

##长整数加法运算

#include
<stdio.h> 
#include
<stdlib.h> 
#include
<ctype.h>  
typedef
struct DualNode {     
int
data;     
struct
DualNode *prior, *next; 
}DualNode,
*DualList;  
//头节点存放符号位
DualList
InitList(int sign) {     
DualList L;     
L =
(DualList)malloc(sizeof(DualNode));     
L->next
= L->prior = L;     

L->data
= sign;     

return
L; 

} 

//在链表最后插入 

void
InsertNodeAtTail(DualList L, int data)   
{       

DualNode
*s;     
s =(DualList)malloc(sizeof(DualNode));     
s->data= data;     
s->next= L;     
s->prior
= L->prior;     
L->prior->next= s;     
L->prior= s;
}  
// 插在头结点之后，用于计算结果的存储  
void
InsertNodeAtHead(DualList L, int data)
{      
DualNode
*s;     
s ＝(DualList)malloc(sizeof(DualNode));     
s->data= data;     
s->next= L->next;     
s->prior= L;     
L->next->prior= s;     
L->next= s;
 } 
//打印结果   
void
PrintList(DualList L) 
{      
int
FirstTime = 1;     
DualNode
*p = L;     
if(p->data == -1&&p->next->data!=0) 
printf("-");     
p =p->next;     
while(p!= L)     
{   if(FirstTime)         
{             
FirstTime
= 0;             
printf("%d",
p->data);       
}         
else        
{            
printf(",%04d",
p->data);       
}         
p =p->next;    
}     
printf("\n");
}  
//输入数据
DualList
InputData()
{   
int
count=0;     
int
FirstNum = 1, data;     
char
c;     

DualList
L;     
L =(DualList)malloc(sizeof(DualNode));     
L->next
= L->prior = L;     
if((c = getchar()) == '-')         
L ＝InitList(-1);     
else         
L =
InitList(1);     
if
(isdigit(c))     //判断是否为10进制数        
ungetc(c,
stdin);                        // 退格处理                                         

do{         

scanf("%d",
&data);          

while(data>9999)

       data=data/10;

    InsertNodeAtTail(L, data);     

}while((c
= getchar()) != '\n');

//printf("您的输入结果为:\n");     

//PrintList(L);     

return
L; }  

//销毁

void
DelNode(DualList L, DualNode *p) {     

p->prior->next
= p->next;     

p->next->prior
= p->prior;     

free(p);
}  

//加法

void
Add(DualList a, DualList b, DualList c) 

{     

DualList
pa, pb;     

int
carry = 0, tmp;     

pa =
a->prior;     

pb =
b->prior;     

while((pa
!= a) && (pb != b))  

{         

tmp =
pa->data + pb->data + carry;        


if
(tmp >= 10000)        

{             

carry
= 1;             

tmp
-= 10000;      

}

else             carry = 0;         

InsertNodeAtHead(c,
tmp);         

pa =
pa->prior;         

pb =
pb->prior;    

}     

while(pa
!= a)    

{         

 pb = b;  


 tmp = pa->data + carry;         

if
(tmp >= 10000)     

{             

carry
= 1;             

tmp
-= 10000;        

}         

else             

carry
= 0;

InsertNodeAtHead(c,
tmp);         

pa =
pa->prior;

 }

while(pb
!= b)     

{                 

tmp =
pb->data + carry;         

if
(tmp >= 10000)         

{             

carry
= 1;             

tmp
-= 10000;      

}         

else             

carry
= 0;         

InsertNodeAtHead(c,
tmp);         

pb =
pb->prior;    

}     

if
(carry != 0)         

InsertNodeAtHead(c,
1); }  

//减法

void
Sub(DualList a, DualList b, DualList c)

{     

DualList
pa, pb, pc;     

int
borrow = 0,tmp;     

pa =
a->prior;     

pb =
b->prior;       

while((pa
!= a) && (pb != b))               
//判断a>b还是a<b     

{         if (pa->data >= pb->data +
borrow)             

borrow
= 0;         

else             

borrow
= 1;         

pa =
pa->prior;         

pb =
pb->prior;     }       

if
(pa != a || (pa == a && pb == b && borrow == 0))    //判断a>b还是a<b     

{               

c->data
= a->data;     } 

pa =
a->prior;      

pb =
b->prior;      

if(c->data!=b->data){               //a>b情况      

borrow=0;     

while((pa
!= a) && (pb != b))        //将b中与a等大的相减导入c     

{         if (pa->data >= pb->data +
borrow)   //不存在借位         

{             tmp = pa->data - pb->data -
borrow;             

borrow
= 0;         }         

else         {             

tmp =
10000 + pa->data - pb->data - borrow; 
           

borrow
= 1;         }         

InsertNodeAtHead(c,
tmp);         

pa =
pa->prior;         

pb =
pb->prior;     }       

while(pa
!= a)                  //把a中剩余导入c         

{             if (pa->data >= borrow)             

{                 tmp = pa->data -
borrow;                 

borrow
= 0;             }             

else             {                 

tmp =
10000 - pa->data - borrow;                


borrow
= 1;             }             

InsertNodeAtHead(c,
tmp);             

pa =
pa->prior;         }       }      


else{                        //c<b          

c->data=b->data;         

borrow=0;

 while((pa != a) && (pb != b))          //将a中与b等大导入c     

 {        
if (pb->data >= pa->data + borrow)         

 {             tmp = pb->data - pa->data -
borrow;             

 borrow = 0;         }         

 else        
{             

 tmp = 10000 + pb->data - pa->data -
borrow;             

 borrow = 1;         }         

 InsertNodeAtHead(c, tmp);         

 pa = pa->prior;         

 pb = pb->prior;     }        


 while(pb != b)           //导入b中剩余         

 {            
if (pb->data >= borrow)            


 {                 tmp = pb->data -
borrow;                 

 borrow = 0;             }             

 else     
       {                 

 tmp = 10000 - pb->data - borrow;                 

 borrow = 1;             }             

 InsertNodeAtHead(c, tmp);             

 pb = pb->prior;         }     
}       

 pc = c->next;      

 while(pc->next !=c && pc->data
== 0)     //为了防止头因借位变为0的情况     

 {         

 pc = pc->next;         

 DelNode(c, pc->prior); 

 } }   

 DualList AddList(DualList a, DualList b)       

 {     

 DualList c;    


 if (a->data * b->data > 0)     {        


 c = InitList(a->data);         

 Add(a, b, c);     }    


 else    

 {        


 c=InitList(b->data);         

 Sub(a, b, c);    

 }     

 return c; 

 }  

  DualList SubList(DualList a, DualList b)       

 {    

 DualList c;  


 b->data*=-1;

 if (a->data * b->data > 0)    

 {        


 c = InitList(a->data);         

 Add(a, b, c);    

 }     

 else    

 {        


 c=InitList(b->data);         

 Sub(a, b, c);    

 }     

 return c; 

 }   

 int main() {  


 int key;

 while(1)    
{                

 DualList a, b, c;         

 printf("请输入第一个数:\n");         

 a = InputData();         

 printf("输入第二个数:\n");         

 b = InputData();   

 printf("加法1/减法2:\n");

 scanf("%d",&key);

 if(key==1)

 c = AddList(a, b);         

 else

 c=SubList(a,b);

 printf("您的运算结果为:\n");         

 PrintList(c);             

 }    

 return 0;

 }

##迷宫问题
1，利用栈深度优先实现：

#include <stdio.h>

#include<stdlib.h>

#define M 8

#define N 8

#define MaxSize 100

typedef int ElemType;

int mg[M+2][N+2]={

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

//方块类型

typedef struct

{int i;

int j;

int di;

} Box;

typedef struct

{Box data[MaxSize];

int top;

}StType;

void InitStack(StType *&s)

{s=(StType *)malloc(sizeof(StType));

 s->top=-1;

}

void DestroyStack(StType *&s)

{

free(s);

}

bool StackEmpty(StType *s)

{return (s->top==-1);

}

bool Push(StType * &s,Box e)

{ if(s->top==MaxSize-1)

return false;

s->top++;

s->data[s->top]=e;

return true;

}

bool Pop(StType *&s,Box &e)

{if(s->top==-1)

return false;

e=s->data[s->top];

s->top--;

return true;

}

bool GetTop(StType *s,Box &e)

{if (s->top==-1)

return false;

e=s->data[s->top];

return true;

}

bool mgpath(int xi,int yi,int xe,int ye)

{Box path[MaxSize],e;

int i,j,di,i1,j1,k;

bool find;

StType *st;

InitStack(st);

e.i=xi;e.j=yi;e.di=-1;

Push(st,e);

mg[xi][yi]=-1;

while(!StackEmpty(st))

{GetTop(st,e);

i=e.i;j=e.j;di=e.di;

if(i==xe&&j==ye)

{printf("迷宫路径如下");

k=0;

while(!StackEmpty(st))

{Pop(st,e);

path[k++]=e;

}

while(k>=1)

{k--;

printf("\t(%d,%d)",path[k].i,path[k].j);

if((k+2)%5==0)

printf("\n");

}

printf("\n");

DestroyStack(st);

return true;

}

find=false;

while(di<4&&!find)

{di++;

  switch(di)

{case 0:i1=i-1;j1=j; break;

 case 1:i1=i;j1=j+1; break;

 case 2:i1=i+1;j1=j; break;

 case 3:i1=i;j1=j-1; break;}

  if(mg[i1][j1]==0)

  find=true;

}

if(find)

{st->data[st->top].di=di;

e.i=i1;e.j=j1;e.di=-1;

Push(st,e);

mg[i1][j1]=-1;

}

else

{Pop(st,e);

mg[e.i][e.j]=0;

}

}

DestroyStack(st);

return false;

}

int main()

{if(!mgpath(1,1,M,N))

printf("迷宫无解");

return 1;

}

截图：
在这里插入图片描述

2、利用列队广度优先搜索：


#include <stdio.h>

#include<stdlib.h>

#define M 8

#define N 8

#define MaxSize 100

typedef int ElemType;

int mg[M+2][N+2]={

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

typedef struct

{int i,j;

int pre;

}Box;

typedef struct

{Box data[MaxSize];

int front,rear;

}QuType;

//队列初始化

void InitQueue(QuType *&q)

{q=(QuType *)malloc(sizeof(QuType));

q->front=q->rear=-1;

}

//销毁队列

void DestroyQueue(QuType *&q)

{free(q);

}

//判断队列是否为空

bool QueueEmpty(QuType *q)

{return (q->front==q->rear);

}

//入队列

bool enQueue(QuType *&q,Box e)

{if(q->rear==MaxSize-1)

return false;

q->rear++;

q->data[q->rear]=e;

return true;

}

//出队列

bool deQueue(QuType *&q,Box &e)

{if(q->front==q->rear)

return false;

q->front++;

e=q->data[q->front];

return true;

}

void print(QuType *qu,int front)

{int k=front,j,ns=0;

printf("\n");

do

{j=k;

k=qu->data[k].pre;

qu->data[j].pre=-1;

}while(k!=0);

printf("迷宫路径如下");

k=0;

while(k<MaxSize)

{    if(qu->data[k].pre==-1)

      {ns++;

       printf("\t(%d,%d)",qu->data[k].i,qu->data[k].j);

   if(ns%5==0) printf("\n");

       }

       k++;

}

printf("\n");

}

bool mgpath(int xi,int yi,int xe, int ye)

{Box e;

int i,j,di,i1,j1;

QuType *qu;

InitQueue(qu);

e.i=xi;e.j=yi;e.pre=-1;

enQueue(qu,e);

mg[xi][yi]=-1;

while(!QueueEmpty(qu))

{deQueue(qu,e);

i=e.i;j=e.j;

     if(i==xe&&j==ye)

     {print(qu,qu->front);

      DestroyQueue(qu);

       return true;

      }

 for(di=0;di<4;di++)

 {

 switch(di)

 {

 case 0:i1=i-1;j1=j;break;

 case 1:i1=i;j1=j+1;break;

 case 2:i1=i+1;j1=j;break;

 case 3:i1=i;j1=j-1;break;

 }

 if(mg[i1][j1]==0)

 {e.i=i1;e.j=j1;

 e.pre=qu->front;

 enQueue(qu,e);

 mg[i1][j1]=-1;

 }

 }

  }

DestroyQueue(qu);

return false;

}



int main()

{if(!mgpath(1,1,M,N))

printf("迷宫无解");

return 1;

}

在这里插入图片描述

##二叉树的应用

1）根据输入的数据建立一个二叉树。

2）输出二叉树（输出的结果应为树型结构）。

3）输出其前序、中序和后序遍历的结果。

4）输出树的深度，最大元，最小元。

#include<stdio.h>

 #include<stdlib.h>

 #include<malloc.h>

 #define MaxSize 1000   

typedef
struct Node

    {

          char
data;

              int layer;

          struct
Node *LChild;

          struct
Node *RChild;

    } BiTNode,*BiTree;

struct
Queue

{

       BiTree *data;

       int front,rear,size;

}q;

void
push(BiTree bt)

{

       q.data[q.rear++]=bt;

       if(q.rear>=q.size)

       {printf("no space");

       exit(-1);

       }

}

BiTree
pop()

{

       if(q.front>=q.rear)

       {printf("error");

       exit(-1);

       }

       else{

       return q.data[q.front++];

       }

}

bool
empty()

{

       if(q.front>=q.rear)

              return 1;

       else return 0;

}

int
Max(int x,int y)

{return
(x>y)?x:y;

}



void
CreateBiTree(BiTree &bt) //先序创建二叉树 

    {

          char
ch;

          ch
= getchar();

              if (ch == '#') bt = NULL;

          else

          {

                 bt
= (BiTree)malloc(sizeof(BiTNode));

                 bt->data
= ch;

                 CreateBiTree((bt)->LChild);

                 CreateBiTree((bt)->RChild);

          }

    }



  int CountDeepth(BiTree bt)

  {

        
if(!bt)

               
return 0;

        
else 

               
return Max(CountDeepth(bt->LChild),CountDeepth(bt->RChild))+1;

  }

 char GetMax(BiTree T)

{

    static int max=0;

    if(T!=NULL){

        if(max<T->data) max=T->data;

              GetMax(T->LChild);

              GetMax(T->RChild);

    }

    return max;

}

char
GetMin(BiTree T)

{

    static int min=99999999;

    if(T!=NULL){

        if(T->data<min) min=T->data;

              GetMin(T->LChild);

              GetMin(T->RChild);

    }

    return min;

}

void
PrintTree(BiTree T,int deepth)

{

       int pre=0,flag=1;

       q.data=(BiTree*)malloc(MaxSize*sizeof(BiTree));

       q.front=q.rear=0;

       q.size=MaxSize;

       T->layer=0;

       push(T);

       while(1)

       {

              BiTree node=pop();

              if(node->layer>=deepth)

                     break; 

              if(pre!=node->layer||flag)

              {

                     printf("\n");

                     for(int
i=1;i<(1<<(deepth-node->layer));i++)

                         printf(" ");

                     printf("%c",node->data);

                     pre=node->layer;

                     flag=0;

              }

              else

              {

                     for(int
i=1;i<(1<<(deepth-node->layer+1));i++)

                             printf(" ");

                     printf("%c",node->data);

              }

              if(node->LChild)

              {

                     node->LChild->layer=node->layer+1;

                     push(node->LChild);

              }

              else

              {

                     BiTree
node_null=(BiTree)malloc(sizeof(BiTNode));

                     node_null->layer=node->layer+1;

                     node_null->LChild=node_null->RChild=NULL;

                     node_null->data=' ';

                     push(node_null);

              }

              if(node->RChild)

              {

                     node->RChild->layer=node->layer+1;

                     push(node->RChild);

              }     

              else

              {

                     BiTree
node_null=(BiTree)malloc(sizeof(BiTNode));

                     node_null->layer=node->layer+1;

                     node_null->LChild=node_null->RChild=NULL;

                     node_null->data=' ';

                     push(node_null);

              }

       }     

}

    

 void PreOrder(BiTree root)//先序遍历 

    {

       if (root != NULL)

          {

                 printf("%c",
root->data);

                 PreOrder(root->LChild);

                 PreOrder(root->RChild);

          }

    }

    

    void InOrder(BiTree root)//中序遍历 

    {

          if
(root != NULL)

          {

                 InOrder(root->LChild);

                 printf("%c",
root->data);

                 InOrder(root->RChild);

          }

    }

    

    void PostOrder(BiTree root)//后序遍历 

    {

          if
(root != NULL)

          {

                 PostOrder(root->LChild);

                 PostOrder(root->RChild);

                 printf("%c",
root->data);

          }

    }

    

    int main()

    {

              int deepth;

              char min,max;

              BiTree bt=NULL;

          CreateBiTree(bt);

              deepth=CountDeepth(bt);

              max=GetMax(bt);

              min=GetMin(bt);

              PrintTree(bt,deepth);

              printf("\n深度:%d\n",deepth);

              printf("\n最大元:%d\n",max);

              printf("\n最小元:%d\n",min);

              printf("先序遍历：");

          PreOrder(bt);

          printf("\n");

              printf("中序遍历：");

          InOrder(bt);

          printf("\n");

              printf("后序遍历：");

          PostOrder(bt);

          printf("\n");

              return 0;

          

    }

在这里插入图片描述

花雨纷纷

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
数据结构实验

##长整数加法运算#include<stdio.h> #include<stdlib.h> #include<ctype.h> typedefstruct DualNode { intdata; structDualNode *prior, *next; }DualNode,*DualList; //头节点存放符号位DualListInitList(int sign) { DualLis
复制链接

扫一扫