数据结构实验一

#include <stdio.h>
#include <malloc.h>
#define MaxSize 50
typedef int ElemType;
typedef struct
{
ElemType data[MaxSize];
int length;
} SqList;
void CreateList(SqList*& L, ElemType a[], int n)
{
L = (SqList*)malloc(sizeof(SqList));
for (int i = 0; i < n; i++)
L->data[i] = a[i];
L->length = n;
}
void InitList(SqList*& L)
{
L = (SqList*)malloc(sizeof(SqList));
L->length = 0;
}
void DestroyList(SqList*& L)
{
free(L);
}
bool ListEmpty(SqList* L)
{
return(L->length == 0);
}
ElemType ListLength(SqList* L)
{
return(L->length);
}
void DispList(SqList* L)
{
for (int i = 0; i < L->length; i++)
printf("%d ", L->data[i]);
printf("\n");
}
bool GetElem(SqList* L, int i, ElemType& e)
{
if (i<1 || i>L->length)
return false;
e = L->data[i - 1];
return true;
}
ElemType LocateElem(SqList* L, ElemType e)
{
int i = 0;
while (i < L->length&& L->data[i] != e) i++;
if (i >= L->length)
return 0;
else
return i + 1;
}
bool ListInsert(SqList*& L, int i, ElemType e)
{
int j;
if (i<1 || i>L->length + 1 || L->length == MaxSize)
return false;
i--;
for (j = L->length; j > i; j--)
L->data[j] = L->data[j - 1];
L->data[i] = e;
L->length++;
return true;
}
bool ListDelete(SqList*& L, int i, ElemType& e)
{
int j;
if (i<1 || i>L->length)
return false;
i--;
e = L->data[i];
for (j = i; j < L->length - 1; j++)
L->data[j] = L->data[j + 1];
L->length--;
return true;
}
void replace(SqList* L, int i, ElemType e)
{
L->data[i] = e;
}
ElemType get1(SqList* L, int i)
{
if (i <1 || i>L->length) return false;
else return(L->data[i - 1]);
}
ElemType get2(SqList* L, int i)
{
if (i<-1 || i > L->length - 1) return false;
else return(L->data[i + 1]);
}
void det(SqList* L, ElemType x, ElemType y)
{
int i = 0, k = 0;
while (i < L->length)
{
if (L->data[i] >= x && L->data[i] <= y)
k++;
else { L->data[i - k] = L->data[i]; }
i++;
}
L->length = k;
}
void replacement(SqList* L)
{
ElemType temp;
for (int i = 0; i < L->length / 2; i++) {
temp = L->data[i];
L->data[i] = L->data[L->length - 1 - i];
L->data[L->length - 1 - i] = temp;
}
}
int main()
{
int x, y;
SqList* L;
ElemType e;
printf("顺序表的基本算法如下：\n");
printf("（1）初始化线性表L\n");
InitList(L);
L->data[0] = 2;
L->data[1] = 6;
L->data[2] = 3;
L->data[3] = 9;
L->data[4] = 2;
L->data[5] = 3;
L->data[6] = 7;
L->data[7] = 4;
L->length = 8;
replace(L, 4, 0);
x=get1(L, 3);
y=get2(L, 6);

replacement(L);
DispList(L);
printf("x=%d,y=%d", x,y);
}、
 

#include<stdio.h>
#include<malloc.h>
typedef char ElemType;
typedef struct LNode
{
ElemType data; //指向后继结点
struct LNode *next; //声明单链表结点类型
}LinkNode;

void CreateListF(LinkNode *&L,ElemType a[],int n){
LinkNode *s;
L=(LinkNode *)malloc(sizeof(LinkNode));
L->next=NULL;
for(int i=0;i<n;i++)
{
s=(LinkNode *)malloc(sizeof(LNode));
s->data=a[i];
s->next=L->next;
L->next=s;
}
}

void CreateListR(LinkNode *&L,ElemType a[],int n)
{
LinkNode *s,*r;
L=(LinkNode *)malloc(sizeof(LinkNode));
L->next=NULL;
r=L;
for(int i=0;i<n;i++)
{
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=a[i];
r->next=s;
r=s;
}
r->next=NULL;
}

void InitList(LinkNode *&L)
{
L=(LinkNode *)malloc(sizeof(LinkNode));
L->next=NULL;
}

void DestroyList(LinkNode *&L)
{
LinkNode *pre=L,*p=pre->next;
while(p!=NULL)
{
free(pre);
pre=p;
p=pre->next;
}
free(pre);
}

bool ListEmpty(LinkNode *&L)
{
return(L->next==NULL);
}

int ListLength(LinkNode *&L)
{
int i=0;
LinkNode *p=L;
while(p!=NULL)
{
i++;
p=p->next;
}
return(i);
}

void DispList(LinkNode *L)
{
LinkNode *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
printf("\n");
}

bool GetElem(LinkNode *L,int i,ElemType &e)
{
int j=0;
LinkNode *p=L;
if(i<=0) return false;
while(j<i&&p!=NULL)
{j++;
p=p->next;
}
if(p==NULL)
return false;
else
{
e=p->data;
return true;
}
}

int LocateElem(LinkNode *L,ElemType &e)
{
int i=1;
LinkNode *p=L->next;
while(p!=NULL&&p->data!=e)
{
p=p->next;
i++;
}
if(p==NULL)
return(0);
else
return(i);
}

bool ListInsert(LinkNode *&L,int i,ElemType &e)
{
int j=0;
LinkNode *p=L,*s;
if(i<=0) return false;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return false;
else
{
s=(LinkNode *)malloc(sizeof(LinkNode));
s->data=e;
s->next=p->next;
p->next=s;
return true;
}
}

bool ListDelete(LinkNode *&L,int i,ElemType &e)
{
int j=0;
LinkNode *p=L,*q;
if(i<=0) return false;
while(j<i-1&&p!=NULL)
{
j++;
p=p->next;
}
if(p==NULL)
return false;
else
{
q=p->next;
if(q==NULL)
return false;
e=q->data;
p->next=q->next;
free(q);
return true;
}
}