数据结构实验1

1.1 单链表插入删除

//建立一个存储A,B... 26个大写英文字母的线性链表，插入或删除字母使其位于适当位置 
#define OK 1
#define NULL 0
#define OVERFLOW -2
#include<malloc.h> 
#include<process.h>  //exit()
#include<stdio.h>
typedef char ElemType;
typedef int Status;
typedef struct LNode {
	ElemType data;
	struct LNode *next;
}LNode,*LinkList; 
 
LinkList CreateList(LinkList L)
{ //建立一个存储A,B... 26个大写英文字母的线性链表L
	LinkList p,r;
	char i;
	L=(LinkList)malloc(sizeof(LNode));
	if(!L) //存储分配失败
     exit(OVERFLOW);
	r=L;
	for(i='A';i<='Z';i++)
	{//存储初始数据元素为大写字母A到Z 
		p=(LNode*)malloc(sizeof(LNode));
		p->data=i;
		r->next=p;
		r=p;
	}
	r->next=NULL;
	return L;
}
LinkList ListInsert(LinkList L,ElemType e) 
{ //将元素e插入到单链表的适当位置上，以保持该表的有序性 
    int j=0;
    LinkList p=L->next,s;
	while(p&&j<26)
	{
		if(e>p->data) // 寻找适当的插入位置 
		{
		    p=p->next;
		}
		else break;
		j++;	     
	}
    s=(LinkList)malloc(sizeof(LNode)); // 生成新结点
    s->data=e; 
    s->next=p->next; //插入L中 
    p->next=s;
    return L;
}
LinkList ListDelete(LinkList L,ElemType e) 
{ //在单链线性表L中，删除元素e
	int j=0;
	LinkList p=L->next,q=L,r;
    while(p&&j<26)
	{
		if(e!=p->data) //找到第一个与e相同的元素 
		{
			q=p;
		    p=p->next;
		}
		else break;
		j++;	     
	}
	r=p;
    q->next=p->next;
    free(r); //释放结点 
    return L;
}
void visit(ElemType c)
{
	printf("%c ",c);
}
Status ListTraverse(LinkList L,void(*vi)(ElemType))
{ //遍历链表中元素 
   LinkList p=L->next;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("\n");
   return OK;
}
int main()
{
	LinkList L,L1,L2,L3;
	ElemType e1,e2;
	L1=CreateList(L);
	printf("初始单链表数据为：\n") ;
	ListTraverse(L1,visit);
	printf("\n"); 
	printf("请输入要插入的大写英文字母：");
	scanf("%c",&e1);
	printf("插入字母%c后单链表为：\n",e1);
	if(e1<'A'||e1>'Z')
	{
	 	printf("输入错误");
	}
	else{
		L2=ListInsert(L1,e1);
		ListTraverse(L2,visit);
	}
	printf("\n"); 
	printf("请输入要删除的大写英文字母：");
	fflush(stdin); 
	scanf("%c",&e2);
	printf("删除字母%c后单链表为：\n",e2);
	if(e2<'A'||e2>'Z')
	{
	 	printf("输入错误");
	}
	else{
		L3=ListDelete(L2,e2);
		ListTraverse(L3,visit);
	}
	return OK;
}

1.2 约瑟夫环

//约瑟夫环(循环链表) 
#define NULL 0
#define OVERFLOW -2 
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
typedef struct LNode{
	int num; //每个人的编号 
	int data; //密码 
	struct LNode *next;
}LinkList;
LinkList *create(int n)
{ //建立单向循环链表 
	printf("请输入人数n:");
	scanf("%d",&n);
    printf("请分别输入这%d个人的密码:\n",n);
    int i=1;
    LinkList *L,*p,*q;
    L=NULL;
    p=(LinkList*)malloc(sizeof(LinkList));
    if(!p) //存储分配失败
     exit(OVERFLOW);
    p->num=1;
    scanf("%d",&p->data);
    L=p;
    for(i=2;i<=n;i++)
    {
    	q=(LinkList*)malloc(sizeof(LinkList));
    	if(!p) 
     		exit(OVERFLOW);
    	q->num=i;
    	scanf("%d",&q->data);
    	p->next=q;
    	p=q;
	}
	p->next=L; //指针域指向头结点
    return L;
}
void func(LinkList *L,int m)
{
	printf("请输入m的初值:");
	scanf("%d",&m);
	printf("依次出列的人的编号为：");
	int i,j;
	LinkList *p,*q,*s;
	p=L;
	while(p->next!=p) //直到只剩下最后一个结点 
	{
		for(j=1;j<m;j++)
		{
			q=p;
			p=p->next;
		}
		printf("%d",p->num); //输出出列的人的编号  
		m=p->data; //出列的人的密码作为新的m值 
		s=p;
		q->next=p->next; //删除出列的人的结点
		p=p->next;
		free(s);  //释放该结点 
	}
	printf("%d",p->num); //输出最后一个结点的人的编号 
	printf("\n");
}
int main()
{
	LinkList *L;
	int m,n;
	L=create(n);
	func(L,m);
	return 0;
}

2.1 二进制转十进制

//进制转换--二进制转为十进制 (栈) 
#define OK 1 
#define OVERFLOW -2 
#define ERROR 0
#define NULL 0
#define TRUE 1
#define FALSE 0
#define STACK_INIT_SIZE 20
#define STACKINCREMENT 10
#include<malloc.h> 
#include<process.h> // exit()
#include<stdio.h>
typedef int SElemType;
typedef int Status;
typedef struct {
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;
Status InitStack(SqStack &S)
{ //构造一个空栈 
	S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!S.base) exit(OVERFLOW); //存储分配失败 
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
	return OK;
}
Status Push(SqStack &S,SElemType e)
{ //插入元素e为新的栈顶元素 
	if(S.top-S.base>=S.stacksize)
	{ //栈满，追加存储空间 
		S.base=(SElemType *)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!S.base) exit(OVERFLOW); //追加存储空间失败 
		S.top=S.base+S.stacksize;
		S.stacksize+=STACKINCREMENT;
	}
	*S.top=e;
	S.top++; //栈顶指针后移 
	return OK;
}
Status Pop(SqStack &S,SElemType &e)
{ //删除栈顶元素，用e返回其值 
	if(S.top==S.base) //栈空，返回ERROR 
 		return ERROR;
	S.top--;  
	e=*S.top;
	return OK;
}
Status DestroyStack(SqStack &S)
{ //销毁栈S，S不再存在
	free(S.base);
	S.base=NULL;
	S.top=NULL;
	S.stacksize=0;
	return OK;
}
Status StackEmpty(SqStack S)
{ //若栈S为空栈，则返回TRUE，否则返回FALSE
	if(S.t