线性表c语言实现 求高人完善

Posted 2023-04-17

内容：比较顺序存储和链接存储两种存储结构的优缺点。（参考教材4.1）
(1) 分别用顺序存储和链接存储实现线性表的基本操作；
(2) 比较两者的优缺点，并说明两者的适用场合。

实验参考代码：
1、 线性表的顺序实现
#include <stdio.h>
#define FALSE 0
#define TRUE 1
#define MaxSize 100
typedef int BOOL;
typedef int T;

typedef struct list //线性表的定义


void CreateList(List *lst, int maxsize)


BOOL IsEmpty(List lst)


BOOL IsFull(List lst)


BOOL Replace(List *lst, int pos, T x)


void Clear(List *lst)


BOOL Insert(List *lst, int pos, T x)


BOOL Remove(List *lst, int pos, T* x)


BOOL Retrieve(List lst, int pos, T* x)

void PrintList(List l) //打印表中元素


T* InputElement() //从键盘输入表中元素


void main( ) //本驱动程序仅为示例，功能简单，请同学们在此基础上加以改进

List l; T x;
CreateList(&l,10); /* 构造一个容量为10的空线性表*/
Insert(&l,0,10);
Insert(&l,1,9);
Insert(&l,2,8); /*在线性表中依次插入元素*/
PrintList(l); /*显示栈中元素*/
x=*InputElement(); Insert(&l,3,x); /*调用InputElement函数接受新元素x，并令其进栈*/
PrintList(l); /*显示栈中元素*/

此处增加语句，验证表中定义的其他运算。



2、 线性表的链接实现
#include <stdio.h>
#include <stdlib.h>
#define FALSE 0
#define TRUE 1
#define IS_FULL(ptr) (!(ptr))
typedef int BOOL;
typedef int T;

//定义线性表的链接实现
typedef struct node


Node;

typedef struct list


List;

//创建元素
T* InputElement()




//显示元素
void PrintElement(T x)




//构造新结点
Node* NewNode()




Node* NewNode1()




Node* NewNode2(T x)




//创建线性表
void BuildList(List *lst )

Node* p, *r=NULL;
char c;
lst->First=NULL;
lst->Size=0;
printf("Another element? y/n");
while ((c= getchar()) == '\n');
while (tolower(c)!='n')
p=NewNode1();
if(lst->First!=NULL) r->Link=p; else lst->First=p;
r=p;
lst->Size++;
printf("Another element? y/n");
while ((c= getchar()) == '\n');



//输出线性表
void PrintList(List lst)




Node* set_pos(List lst, int pos)




BOOL IsEmpty(List lst)




BOOL Insert(List *lst, int pos, T x)




BOOL Remove(List *lst, int pos, T* x)




BOOL Retrieve(List lst, int pos, T* x)




//驱动程序
void main()

List lst;
T x;
BuildList(&lst);
PrintList(lst);
Insert(&lst,4,-4); PrintList(lst);
Insert(&lst,0,100); PrintList(lst);
Remove(&lst,1,&x); PrintList(lst);

此处增加语句，验证表中定义的其他运算。

#include <stdio.h>
#include <malloc.h>
#define MaxSize 50
typedef char ElemType;
typedef struct
ElemType data[MaxSize]; //存放顺序表元素
int length; //存放顺序表的长度
SqList; //顺序表的类型定义
void CreateList(SqList *&L,ElemType a[],int n)
//建立顺序表

int i;
L=(SqList *)malloc(sizeof(SqList));
for (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);

int ListEmpty(SqList *L).

return(L->length==0);

int ListLength(SqList *L)

return(L->length);

void DispList(SqList *L)

int i;
if (ListEmpty(L)) return;
for (i=0;i<L->length;i++)
printf("%c ",L->data[i]);
printf("\\n");

int GetElem(SqList *L,int i,ElemType &e)

if (i<1 || i>L->length)
return 0;
e=L->data[i-1];
return 1;

int 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;

int ListInsert(SqList *&L,int i,ElemType e)

int j;
if (i<1 || i>L->length+1)
return 0;
i--; //将顺序表位序转化为elem下标
for (j=L->length;j>i;j--) //将data[i]及后面元素后移一个位置
L->data[j]=L->data[j-1];
L->data[i]=e;
L->length++; //顺序表长度增1
return 1;

int ListDelete(SqList *&L,int i,ElemType &e)

int j;
if (i<1 || i>L->length)
return 0;
i--; //将顺序表位序转化为elem下标
e=L->data[i];
for (j=i;j<L->length-1;j++) //将data[i]之后的元素前移一个位置
L->data[j]=L->data[j+1];
L->length--; //顺序表长度减1
return 1;


#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct LNode //定义单链表结点类型

ElemType data;
struct LNode *next; //指向后继结点
LinkList;
void CreateListF(LinkList *&L,ElemType a[],int n)
//头插法建立单链表

LinkList *s;int i;
L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
L->next=NULL;
for (i=0;i<n;i++)

s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
s->data=a[i];
s->next=L->next; //将*s插在原开始结点之前,头结点之后
L->next=s;


void CreateListR(LinkList *&L,ElemType a[],int n)
//尾插法建立单链表

LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
L->next=NULL;
r=L; //r始终指向终端结点,开始时指向头结点
for (i=0;i<n;i++)

s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
s->data=a[i];
r->next=s; //将*s插入*r之后
r=s;

r->next=NULL; //终端结点next域置为NULL

void InitList(LinkList *&L)

L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
L->next=NULL;

void DestroyList(LinkList *&L)

LinkList *p=L,*q=p->next;
while (q!=NULL)
free(p);
p=q;
q=p->next;

free(p); //此时q为NULL,p指向尾结点,释放它

int ListEmpty(LinkList *L)

return(L->next==NULL);

int ListLength(LinkList *L)

LinkList *p=L;int i=0;
while (p->next!=NULL)
i++;
p=p->next;

return(i);

void DispList(LinkList *L)

LinkList *p=L->next;
while (p!=NULL)
printf("%c ",p->data);
p=p->next;

printf("\\n");

int GetElem(LinkList *L,int i,ElemType &e)

int j=0;
LinkList *p=L;
while (j<i && p!=NULL)
j++;
p=p->next;

if (p==NULL) //不存在第i个数据结点
return 0;
else //存在第i个数据结点
e=p->data;
return 1;


int LocateElem(LinkList *L,ElemType e)

LinkList *p=L->next;
int n=1;
while (p!=NULL && p->data!=e)
p=p->next;
n++;

if (p==NULL)
return(0);
else
return(n);

int ListInsert(LinkList *&L,int i,ElemType e)

int j=0;
LinkList *p=L,*s;
while (j<i-1 && p!=NULL) //查找第i-1个结点
j++;
p=p->next;

if (p==NULL) //未找到位序为i-1的结点
return 0;
else //找到位序为i-1的结点*p
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
s->data=e;
s->next=p->next; //将*s插入到*p之后
p->next=s;
return 1;


int ListDelete(LinkList *&L,int i,ElemType &e)

int j=0;
LinkList *p=L,*q;
while (j<i-1 && p!=NULL) //查找第i-1个结点
j++;
p=p->next;

if (p==NULL) //未找到位序为i-1的结点
return 0;
else //找到位序为i-1的结点*p
q=p->next; //q指向要删除的结点
if (q==NULL) return 0; //若不存在第i个结点,返回0
e=q->data;
p->next=q->next; //从单链表中删除*q结点
free(q); //释放*q结点
return 1;

参考技术A #include<stdio.h>
#include<stdlib.h>
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
// Status是函数的类型，其值是函数结果状态代码
typedef int Status;
typedef int ElemType;
#define LIST_INIT_SIZE 5
#define LISTINCREMENT 2
typedef struct
ElemType *elem;
int length;
int listsize;
SqList;
Status InitList_Sq(SqList &L)
//构造一个空的线性表L。
L.elem = (ElemType * )malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)exit(OVERFLOW);
L.length = 0;
L.listsize = LIST_INIT_SIZE;
return OK;
//InitList_Sq
Status ListInsert_Sq(SqList &L,int i,ElemType e)
ElemType *newbase,*p,*q;
if (i<1 ||i>L.length+1) return ERROR;
if (L.length>=L.listsize)
newbase = (ElemType * )realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
if(!newbase)exit(OVERFLOW);
L.elem = newbase;
L.listsize += LISTINCREMENT;

q = &(L.elem[i-1]);
for(p = &(L.elem[L.length-1]);p>=q;--p)*(p+1) =*p;
*q = e;
++L.length;
return OK;

Status ListDelete_Sq(SqList &L,int i,ElemType &e)
ElemType *q,*p;
if((i<1)||(i>L.length))return ERROR;
p = &(L.elem[i-1]);
e = *p;
q = L.elem+L.length-1;
for (++p;p<=q;++p)*(p-1)=*p;
--L.length;
return OK;

void main()
SqList L;int i;ElemType e;
InitList_Sq(L);
for (i=0;i<LIST_INIT_SIZE;i++)

scanf("%d",&L.elem[i]);
++L.length;

for(i=0;i<L.length;i++)
printf("%d",L.elem[i]);
printf("\n");
scanf("%d,%d",&i,&e);
ListInsert_Sq(L,i,e);
for(i=0;i<L.length;i++)
printf("%d",L.elem[i]);
printf("\n");
scanf("%d",&i);
ListDelete_Sq(L,i,e);
for(i=0;i<L.length;i++)
printf("%d",L.elem[i]);
参考技术B #include"stdio.h"
#include"malloc.h"
struct Node

int data;
struct Node *next;
;
int n;
struct Node *creat(void)

struct Node *head;
struct Node *p1,*p2;
n=0;
p1=p2=(struct Node*)malloc(sizeof(struct Node));
head=NULL;
scanf("%d",&p1->data);
while(p1->data!=0)

n=n+1;
if(n==1)head=p1;
else p2->next=p1;
p2=p1;
p1=(struct Node*)malloc(sizeof(struct Node));
scanf("%d",&p1->data);

p2->next=NULL;
return(head);

void print(struct Node *head)

if(head==NULL)
printf("没有数据：\n");
else

while(head!=NULL)

printf("%d ",head->data);
head=head->next;


printf("\n");

struct Node *PAIXU(struct Node *head)

struct Node *p1,*p2;
if(head!=NULL)

p1=head;
while(p1->next!=NULL)

p2=p1->next;
while(p2!=NULL)

if(p1->data>p2->data)

n=p1->data;
p1->data=p2->data;
p2->data=n;

p2=p2->next;

p1=p1->next;


return(head);

struct Node *NIZHI(struct Node *head)

struct Node *p1,*p2,*p;
p1=head;
p2=p1->next;
p=p2->next;
p1->next=NULL;
while(p!=NULL)

p2->next=p1;
p1=p2;
p2=p;
p=p2->next;

p2->next=p1;
head=p2;
return(head);

struct Node *insert(struct Node *head,struct Node *L,int i)

struct Node *p;
p=head;
n=1;
while(n<i-1)

p=p->next;
n++;

L->next=p->next;
p->next=L;
return(head);

struct Node *del(struct Node *head,int i)

struct Node *p;
p=head;
n=1;
while(n<i-1)

p=p->next;
n++;

p->next=p->next->next;
return(head);
追问

能给个运行结果不，我电脑c++出问题了。谢谢

c语言 数据结构线性表

线性表

• 线性表功能以及
• • 线性表的接口实现

线性表功能以及

线性表有动态线性表和静态线性表，线性表本质是有限序列。
线性表和数组的区别：

1. 数组的大小是有限的 不可动态增加或减少。
2. 数组的访问可以直接下标引用，效率更高
3. 线性表是通过结构体实现的，线性表本质是一个结构体数组。

线性表的接口实现

接口实现与学籍管理系统，通讯录等无出其右，均是对结构体进行增 删 查 改 看

1. 创建一个结构体

typedef int  SLDataType;

typedef struct SeqList

	SLDataType* a;     // 在结构体SeqList中开辟动态数组a
	size_t size;      // 数组中已经存放的有效数据数量
	size_t capicity; // 最大可存放数据数量
SeqList;

该结构体在内存中存放是一体的 如图

如图 线性表的a指针开辟了一块连续的内存空间

可以见得 顺序表的本质是通过开辟一个类似a数组的连续空间 该空间 可伸缩，但是必须连续存放。

2. 顺序表的初始化
   断言的使用： assert可以快速诊断出传进来的指针是否为空
   使用memset进行初始化
   
   注意： 此变量可不调入进来
   上述代码 有什么问题呢？

越界访问 可见 初始化capicity个空间大小

void SeqListInit(SeqList* ps, size_t capicity)

assert(ps);
	memset(ps, 0, sizeof(SeqList));
	printf("Init is ok!");

3. 线性表的打印
   线性表的打印 本质是对a指针指向的内存空间的访问

void SeqListprint(SeqList* ps)

	assert(ps->a);
	for (size_t i = 0; i < ps->size; i++)
	
	
		printf("%d ", ps->a[i]); // ps->a 是对a的访问 
		                         // a的下标引用就是对a的解应用
		                         //*(ps->a+i)也可
	

注意 *(ps->a+i)是对a是一个指向连续空间的指针的更为准确解释 ps->a[i]则更为直观。

4. 线性表的增容
   线性表可增容比较容易是他和数组的区别

void CheckCapacity(SeqList* ps)

	if (ps->size == ps->capicity-2)//不可相等进 因为我们是从0开始计数的。否则会出现指针越界问题
	
		size_t newcapicity = ps->capicity==0?4:2 * ps->capicity;
		SeqList* newroom = (SeqList*)realloc
		(ps->a, newcapicity * sizeof(SLDataType)); 
		// 开辟的空间是给指针a使用的 所以要开辟和a一样属性的空间
		assert(newroom); 
		// 注意断言的使用
		ps->a = newroom;
		ps->capicity = newcapicity;
		
	

注意： 不可相等进 因为我们是从0开始计数的。否则会出现指针越界问题
可稍作优化 在函数外判断是否需要扩容 则可省去每次都调用函数的时间

void CheckCapacity(SeqList* ps)

        
      size_t newcapicity = ps->capicity==0?4:2 * ps->capicity;
		SeqList* newroom = (SeqList*)realloc
		(ps->a, newcapicity * sizeof(SLDataType)); 
		// 开辟的空间是给指针a使用的 所以要开辟和a一样属性的空间
		assert(newroom); 
		// 注意断言的使用
		ps->a = newroom;
		ps->capicity = newcapicity;
		
	

注意 不可忘记assert 防止出现空指针。

5. 线性表的放入
   尾插：

void SeqListPushBack(SeqList* ps, SLDataType x)

	assert(ps);
	if (ps->capicity == ps->size)
	
		CheckCapacity(ps);
	
	*(ps->a+ps->size)= x;
	ps->size++;

注：
a是一个指针 一定要对a进行解引用 。
头插
头插则是一个后面覆盖前面的问题。

void SeqListpushFront(SeqList* ps, SLDataType x)

	assert(ps); //勿忘判断
	if (ps->capicity == ps->size)
	
		CheckCapacity(ps);
	
	int i = ps->size;
	while (i > 0)
	
		*(ps->a + i ) = *(ps->a + i-1);// 此处切记 计数从0开始
		i--;
	
	*(ps->a + i) = x;
	ps->size++;
	

6. 线性表的删除

线性表的尾删： 与尾插一样 都是加加减减操作。

void SeqListPopBack(SeqList* ps)

	assert(ps);
	ps->size--;
	ps->a[ps->size] = 0;

线性表的头删： 线性表的头删也是覆盖

void SeqListPopFront(SeqList* ps)

	assert(ps);
	int i = 0;

	while (i<ps->size)
	
		*(ps->a + i) = *(ps->a + i + 1);
		i++;
	
	ps->size--;

7. 线性表的查找

void SeqListFind(SeqList* ps, SLDataType x)

	
	assert(ps);
	int i = 0;
	while (i<ps->size)
	
		if (*(ps->a + i) == x)
		
			printf("%d", i);