数据结构基本操作

//**************************************一单元******************************新手莫笑0.0  慢慢积累
/*******************************顺序表操作*******************************/
/*#include<stdio.h>
#include<string.h>
#define  MAX 100
typedef struct
{
char elem[MAX];
int last;
} Seqlist;

int Locate(Seqlist L,char e)
{
int i=0;
while(i<=L.last  && L.elem[i]!=e)
i++;
if(i<=L.last)
return i+1;
else
return 0;
}

int InsList(Seqlist *L,int i,char e)
{
int k;
if(i<1||i>L->last+2)
{
printf("ERROR!\n");
return 0;
}
if(L->last+1>=MAX)
{
printf("ERROR!\n");
return 0;
}
for(k=L->last;k>=i-1;k--)
L->elem[k+1]=L->elem[k];
L->elem[i-1]=e;
L->last++;
return 1;
}

int  DelList(Seqlist *L,int i,char *e)
{
int k;
if(i<1 || i>L->last+1)
{
printf("ERROR!\n");
return 0;
}
*e=L->elem[i-1];
for(k=i;k<=L->last;k++)
L->elem[k-1]=L->elem[k];
L->last--;
return 1;
}

void MergeList(Seqlist *LA,Seqlist *LB,Seqlist *LC)
{
int i=0,j=0,k=0;
while(i<=LA->last && j<=LB->last)
if(LA->elem[i]<=LB->elem[j])
{
LC->elem[k++]=LA->elem[i++];
}
else
{
LC->elem[k++]=LB->elem[j++];
}

while(i<=LA->last)
LC->elem[k++]=LA->elem[i++];
while(j<=LB->last)
LC->elem[k++]=LB->elem[j++];
LC->last=LB->last+LA->last+1;
}

void print()
{
}

int main()
{
Seqlist L,LB,LC;
char e;
int i,m;

printf("input string:\n");
gets(L.elem);
L.last=strlen(L.elem);
printf("input e:\n");
scanf("%c",&e);
getchar();

printf("input delete i:\n");
scanf("%d",&i);

if(m=Locate(L,e))
printf("Locate=%d\n",m);

if(InsList(&L,i,e))
puts(L.elem);

if(DelList(&L,i,&e))
puts(L.elem);

getchar();
printf("input LB:\n");
gets(LB.elem);
MergeList(&L,&LB,&LC);
puts(LC.elem);
return 0;
}
*//*******************************************链表***********************************/

/*#include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(Node)
typedef char Elemtype;*/
/*
typedef struct Node
{
char data;
struct Node *next;
}Node,*LinkList;
单链表

LinkList Get(LinkList L,int i)
{
int j=0;
LinkList p;
if(i<=0)  return NULL;
p=L;
while((p->next !=NULL)&&(j<i))
{	p=p->next;j++;}
if(i==j)  return p;
else      return NULL;
}

void CreatFromHead(LinkList L)
{
LinkList s;
char c;
c=getchar();
while(c!='#')
{
s=(LinkList)malloc(LEN);
s->data=c;
s->next=L->next;
L->next=s;
c=getchar();
}
}

void print(LinkList L)
{
LinkList p;
p=L->next;
do
{
printf("%c ",p->data);
p=p->next;
}
while(p!=NULL);
}

LinkList Locate(LinkList L,char  e,int *k)
{
LinkList r;
r=L->next;
while(r!=NULL)
if(r->data!=e)
{r=r->next;(*k)++;}
else
break;
if(r!=NULL)
return r;
else
return NULL;
}

int ListLength(LinkList L)
{
int i=0;
while(L->next!=NULL)
{L=L->next;i++;}
return i;
}

int InsList(LinkList L,int i,char e)
{
LinkList p,s;
int k=0;
if(i<=0)return 0;
p=L;
while(p!=NULL&&k<i-1)
{
p=p->next;
k++;
}
if(p==NULL)
{
printf("error!\n");
return 0;
}
printf("input insert data:\n");
e=getchar();
s=(LinkList)malloc(LEN);
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}

int DelList(LinkList L,int i,char *e)
{
LinkList p,r;
int k=0;
p=L;
while(p->next!=NULL && k<i-1)
{
p=p->next;
k++;
}
if(p->next==NULL)
{
printf("error!\n");
return 0;
}
r=p->next;
p->next=r->next;
*e=r->data;
free(r);
return 1;
}

int main()
{
LinkList L,O;
int i,k=1;
char e;
L=(LinkList)malloc(LEN);
L->next=NULL;

printf("input LinkList Node and  '#'  end  :\n");
CreatFromHead(L);
print(L);

printf("\ninput locate : ");
scanf("%d",&i);
if((O=Get(L,i))!=NULL)
printf("%d=%c\n",i,O->data);
getchar();

printf("\ninput find data :");
e=getchar();
if((O=Locate(L,e,&k))!=NULL)
printf("Node %c= locate%d\n",O->data,k);
printf("ListLength =%d \n",i=ListLength(L));

printf("\ninput insert locate:\n");
scanf("%d",&i);
getchar();
if(InsList(L,i,e))print(L);

printf("\ninput dellet locate:\n");
scanf("%d",&i);
if(DelList(L,i,&e))printf("dellet node data:%c\n",e);
return 0;
}

*/
/*  循环链表
typedef struct Node
{
char data;
struct Node *next;
}Node,*LinkList;

void InitList(LinkList L)
{
L=(LinkList)malloc(LEN);
L->next=L;
}
void CreatFromHead(LinkList L)
{
LinkList s;
char c;
c=getchar();
while(c!='#')
{
s=(LinkList)malloc(LEN);
s->data=c;
s->next=L->next;
L->next=s;
c=getchar();
}
}

LinkList Merge_1(LinkList LA,LinkList LB)
{
LinkList p,q;
p=LA;q=LB;
while(p->next!=LA)p=p->next;
while(q->next!=LB)q=q->next;
q->next=LA;
p->next=LB->next;//只能有一个头结点
free(LB);
return LA;
}
LinkList Merge_2(LinkList LA,LinkList LB)//不理解
{
LinkList p;
p=LA->next;
LA->next=LB->next->next;
free(LB->next);
LB->next=p;
return LB;
}
void print(LinkList L)
{
LinkList p;
p=L->next;
do
{
printf("%c ",p->data);
p=p->next;
}
while(p!=L);
}

int main()
{
LinkList L,LA,LB;
LA=(LinkList)malloc(LEN);
LA->next=LA;
LB=(LinkList)malloc(LEN);
LB->next=LB;
CreatFromHead(LA);
CreatFromHead(LB);
print(Merge_2(LA,LB));
return 0;
}
*/
/*双向链表
typedef struct DNode
{
char data;
struct DNode *prior,*next;
}DNode,*DLinkList;

int DLinkIns(DLinkList L,int i,char e)//r为插入结点前的结点
{
DLinkList s,r;
int k=0;
if(i<=0)return 0;
r=L;
while(r->next!=NULL && k<i-1)
{
r=r->next;k++;
}
if(r->next==NULL)
{
printf("error!\n");
return 0;
}
s=(DLinkList)malloc(sizeof(DNode));
if(s)
{
s->data=e;
r->next->prior=s;
s->next=r->next;
s->prior=r;
r->next=s;
return 1
}
else
return 0;
}

int DLinkList(DLinkList L,int i,char *e)//r为 删除结点
{
DLinkList r;
int k=0;
if(i<=0)return 0;
r=L;
while(r->next!=NULL && k<i-1)
{
r=r->next;k++;
}
if(r==NULL)
{
printf("error!\n");
return 0;
}
*e=r->data;
r->prior->next=r->next;//前驱结点的后驱指针  指向  后驱结点
r->next->prior=r->prior;//后驱结点的前驱指针 指向  前驱结点
free(r);
return 0;
}
*/

//**************************************二单元************************************************************************

/*
顺序栈
#include<stdio.h>
#include<stdlib.h>
#define Size 50
#define LEN sizeof(Stack)
typedef struct
{
char  elem[Size];
int top;
}SeqStack,*Stack;

void  InitStack(Stack s)
{
s->top=-1;
}

int Push(Stack s,char x)
{
if(s->top==Size-1)
return 0;
s->top++;
s->elem[s->top]=x;
return 1;
}

int  Pop(Stack s,char *x)
{
if(s->top==-1)
return 0;
else
{
*x=s->elem[s->top];
s->top--;
return 1;
}
}

int GetTop(Stack s,char *x)
{
if(s->top==-1)
return 0;
else
{
*x=s->elem[s->top];
return 1;
}
}

void Top(Stack s)
{
s->top=4;
}

int main()
{
Stack s;char x;
s=(Stack)malloc(LEN);
InitStack(s);

printf("input Stack element and '#' end:\n");
x=getchar();
while(x!='#')
if(Push(s,x))
x=getchar();

printf("output Stack element :\n");
while(Pop(s,&x))
putchar(x);
printf("\n");

Top(s);

printf("output Stack top element:\n");
if(GetTop(s,&x))
putchar(x);
printf("\n");

return 0;
}*/

/*
链栈
#include<stdio.h>
#include<malloc.h>

typedef struct Node
{
char data;
struct Node *next;
}LinkStack,*Stack;

int Push(Stack top,char x)
{
Stack s;
s=(Stack)malloc(sizeof(Stack));
if(s==NULL)return 0;
s->data=x;
s->next=top->next;
top->next=s;
return 1;
}

int Pop(Stack top,char *x)
{
Stack s;
s=top->next;
if(s==NULL)
return 0;
top->next=s->next;
*x=s->data;
free(s);
return 1;
}
int main()
{
Stack top;
char x;

top=(Stack)malloc(sizeof(Stack));
printf("input stack element and '# end :\n");
x=getchar();
while(x!='#')
{
Push(top,x);
x=getchar();
}

printf("output stack element:\n");
while(Pop(top,&x))
putchar(x);
return 0;
} */

/*双端栈

#include<stdio.h>
#include<stdlib.h>
#define LEN sizeof(Stack)
#define M 100
typedef struct
{
char Stack[M];
int top[2];
}DStack,*Stack;

void InitStack(Stack s)
{
s->top[0]=-1;
s->top[1]=M;
}

int Push(Stack s,char  x,int i )
{
if(s->top[0]+1==s->top[1])return 0;
switch(i)
{
case 0:
s->top[0]++;
s->Stack[s->top[0]]=x;
break;
case 1:
s->top[1]--;
s->Stack[s->top[1]]=x;
break;
default:
return 0;
}
return 1;
}

int Pop(Stack s,char *x,int i)
{
switch(i)
{
case 0:
if(s->top[0]==-1)
return 0;
*x=s->Stack[s->top[0]];
s->top[0]--;
break;
case 1:
if(s->top[1]==M)
return 0;
*x=s->Stack[s->top[1]];
s->top[1]++;
break;
default:
return 0;
}
return 1;
}

int main()
{
char x;
int i;
Stack s;
s=(Stack)malloc(LEN);
InitStack(s);
printf("input Stack element '#' end  and  Top :\ni=");
scanf("%d",&i);
x=getchar();
while(x!='#')
if(Push(s,x,i))
x=getchar();

printf("input top   :\n ");
scanf("%d",&i);
printf("output  stack element:\n");
while(Pop(s,&x,i))
putchar(x);
printf("\n");
}*/

/*#include<stdio.h>错误多栈共享新手莫笑
#include<stdlib.h>
#define M 2
typedef struct Node
{
char  data;
struct Node *next;
}LinkStack,*Stack;

Stack top[M];

void InitStack(Stack top[M])
{
int i;
for(i=0;i<M;i++)
top[i]->next=NULL;
}

int Push(Stack top[M],char x, int  i)
{
Stack s;
s=(Stack)malloc(sizeof(LinkStack));
if((i<0&&i>M))return 0;
switch(i)
{
case 0:
s->data=x;
s->next=top[0]->next;
top[0]->next=s;
break;
case 1:
s->data=x;
s->next=top[1]->next;
top[1]->next=s;
break;
default :
return 0;
}
return 1;
}
int main()
{
char x;int i;
for(i=0;i<M;i++)
top[i]=(Stack)malloc(sizeof(LinkStack));
for(i=0;i<M;i++)
InitStack(top[i]);
printf("input top order number:\n");
scanf("%d",&i);
printf("input stack element :\n");
x=getchar();
while(x!='#')
if(Push(top[M],x,i))
x=getchar();
return 0;
}*/