C语言线性表

你必须的把此函数中的函数调用如ListLength、GerElem、LocateElem、ListInsert实现后就可以使用这个函数了。。。这些函数不是库文件里自带的，需要你自己完善。。。

成都创新互联公司于2013年成立，先为新县等服务建站，新县等地企业，进行企业商务咨询服务。为新县企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

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

#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;in;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;iL-length;i++)

printf("%c ",L-data[i]);

printf("\n");

}

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

{

if (i1 || iL-length)

return 0;

e=L-data[i-1];

return 1;

}

int LocateElem(SqList *L, ElemType e)

{

int i=0;

while (iL-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 (i1 || iL-length+1)

return 0;

i--; //将顺序表位序转化为elem下标

for (j=L-length;ji;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 (i1 || iL-length)

return 0;

i--; //将顺序表位序转化为elem下标

e=L-data[i];

for (j=i;jL-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;in;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;in;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 (ji 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 (ji-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 (ji-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;

}

}

c语言简单程序，有一段线性表插入的函数，请高手详细解析，十分感谢

这是数据结构中标准的线性表插入程序，但是它不是真正的c语言，而是类c哦。

status Insertlist(Sqlist L,int i,Elemtype e){

Elemtype *p; //在这里定义了一个*p的指针，目的是找到链表中每个结点的首地址就可以了，不用找一个结点的所用地址啊

int j;

if(L.length==L.listsize) //L.listsize是代表的表的上限值，是事先设定好的

printf("内存分配空间已不够，请重新分配:\n");

p=L.elem;//这条语句应该写在下一条语句的后面，也就是分配后的地址给到临时指针变量p中

L.elem=(Elemtype *)realloc(p,(LISTSIZE+L.listsize)*sizeof(Elemtype));

//这条语句是想一下子分配足够大的线性表空间，realloc在C中不认可的，实现时还要用malloc，这里只是设计实现的，而分配成功后L.elem只是得到分配单元的首地址，不成功则是空值。

if(!p){

printf("分配空间失败");

exit(0);

}

L.elem=p;//这条语句应该没用吧

L.length++;//这条语句应该放在成功插入的后面，也就是return 1;语句之前才对

L.listsize=L.listsize+LISTSIZE_INCE;

if(i1||iL.length){ //这里用到的是运算符||，代表是“或”，也就是说i1代表输入时误操作造成，而iL.length代表输入的位置超出表中数据的个数，位置找不到。

printf("插入位置输入不正确，请重新操作:\n");

return 0;//代表插入失败

}

else{

for(j=L.length-1;j=i;j--)//从i到最后表尾顺次下移，腾出i的位置

L.elem[j+1]=L.elem[j];

L.elem[i]=e;//将数据插入到i的位置中

return 1;//代表插入成功

}

return 1;

}

线性表的基本操作c语言实现

代码如下：

头文件：

2_1.h

#ifndef  _2_1_H

#define  _2_1_H

typedef void SeqList;

typedef void SeqListNode;

//创建线性表

SeqList * SeqList_Create(int capacity);

//销毁线性表

void SeqList_DesTroy(SeqList * list);

void SeqList_Clear(SeqList* list);

int SeqList_Length(SeqList* list);

int SeqList_Capacity(SeqList* list);

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos);

SeqListNode* SeqList_Get(SeqList* list, int pos);

SeqListNode* SeqList_Delete(SeqList* list, int pos);

#endif

源文件：

// 顺序线性表.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include malloc.h

#include stdlib.h

#include "2_1.h"

typedef unsigned int TSeqListNode;

typedef struct {

int len;     //长度

int capacity;//总长度

TSeqListNode * node;//每个节点的指针

} TSeqList;

int main()

{

SeqList* list = SeqList_Create(5);//创建线性表

int i = 6;//赋值6个变量，已超过线性表最大值 5

int j = 1;

int k = 2;

int x = 3;

int y = 4;

int z = 5;

int index = 0;

SeqList_Insert(list, i, 7); //将这6个变量插入线性表中

SeqList_Insert(list, j, 0);

SeqList_Insert(list, k, 0);

SeqList_Insert(list, x, 0);

SeqList_Insert(list, y, 0);

SeqList_Insert(list, z, 0);

//遍历

for(index=0; indexSeqList_Length(list); index++)

{

int* p = (int*)SeqList_Get(list, index);

printf("%d  ", *p);

}

printf("\n");

//删除操作

while( SeqList_Length(list) 0 )

{

int* p = (int*)SeqList_Delete(list, 0);

printf("删除了： %d\n", *p);

}

SeqList_Clear(list);

SeqList_DesTroy(list);

system("pause");

return 0;

}

//创建线性表

SeqList * SeqList_Create(int capacity)

{

TSeqList* ret = NULL ;

if(capacity = 0)

{

ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity);  //为线性表分配空间，包含结 //构体和节点的总大小

}

if(NULL != ret)

{

ret-len = 0;

ret-capacity = capacity;

ret-node = (TSeqListNode*)(ret + 1);//将节点指向上述分配到的空间的后部分

}

return ret;

}

//销毁

void SeqList_DesTroy(SeqList * list)

{

free(list);

}

//清空

void SeqList_Clear(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

if(NULL != ret)

{

ret-len = 0;

}

}

//获得线性表的长度

int SeqList_Length(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int len = -1;

if(NULL != ret)

{

len = ret-len;

}

return len;

}

//线性表的总长度

int SeqList_Capacity(SeqList* list)

{

TSeqList * ret = (TSeqList*)list;

int capacity = -1;

if(NULL != ret)

{

ret-capacity = capacity;

}

return capacity;

}

//插入

int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)

{

TSeqList * sList = (TSeqList*)list;

int i,ret = -1;

if((sList != NULL) (pos = 0) sList-capacity = sList-len+1)

{

if(pos = sList-len)

{

pos = sList-len;

}

for(i = sList-len; i pos; i--)

{

sList-node[i] = sList-node[i-1];

}

sList-node[i] = (TSeqListNode)node;

++sList-len;

ret = 1;

}

return ret;

}

//获得指定位置的节点

SeqListNode* SeqList_Get(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

TSeqListNode* node = NULL;

if(NULL != sList pos=0 pos sList-len)

{

node = (TSeqListNode*)sList-node[pos];

}

return node;

}

//删除

SeqListNode* SeqList_Delete(SeqList* list, int pos)

{

TSeqList * sList = (TSeqList*)list;

SeqListNode * node = SeqList_Get( list, pos);

int i;

if(sList != NULL pos = 0 pos sList-len)

{

for( i=pos+1; isList-len; i++)

{

sList-node[i-1] = sList-node[i];

}

sList-len--;

}

return node;

}

演示：

资料拓展：

线性表是最基本、最简单、也是最常用的一种数据结构。

线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。

我们说“线性”和“非线性”，只在逻辑层次上讨论，而不考虑存储层次，所以双向链表和循环链表依旧是线性表。

在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。一般线性表也就是我们通常所说的“线性表”，可以自由的删除或添加结点。受限线性表主要包括栈和队列，受限表示对结点的操作受限制。

线性表的逻辑结构简单，便于实现和操作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。

C语言文字线性表

#include stdio.h

#includeWindows.h

int *pi;

int m=15;

struct node{

int data;

struct node *next;

};

void Get_data(void)

{

while(m0)

{

scanf("%d",pi);getchar();

if(*pi0)return;

pi++;

}

}

void Print_slist(struct node *h)

{

struct node *p;

p=h-next;

if(p=='\0')

{

printf("Linklist is null!\n");

}

else

{

// printf("heead");

while(p!='\0')

{

printf("%d\t",p-data);

p=p-next;

}

printf("end\n");

}

}

void Delete_node(struct node *h,int x)

{

struct node *p,*q;

q=h;p=h-next;

if(p!='\0')

{

while((p!='\0')(p-data!=x))

{

q=p;p=p-next;

}

if(p-data==x)

{

q-next=p-next;free(p);

}

}

}

void Insert_node(struct node *h,int x,int y)

{

struct node *s,*p,*q;

s=(struct node *)malloc(sizeof(struct node));

s-data=y;

q=h;

p=h-next;

while((p!='\0') (p-data!=x))

{

q=p;p=p-next;

}

q-next=s;s-next=p;

}

void main()

{

int x;

struct node *phead,*s,*r;

phead=(struct node*)malloc(sizeof(struct node));

r=phead;

scanf("%d",x);

while(x=0 m0)

{

s=(struct node*)malloc(sizeof(struct node));

s-data=x;

r-next=s;

scanf("%d",x);

m--;

}

r-next='\0';

Print_slist(s);

}

c语言动态数组如何扩充空间

c语言动态数组扩充空间，主要是利用动态存储分配库函数来实现的，常用的有malloc函数和calloc函数。

malloc（）是C语言中动态存储管理的一组标准库函数之一。其作用是在内存的动态存储区中分配一个长度为size的连续空间。其参数是一个无符号整形数，返回值是一个指向所分配的连续存储域的起始地址的指针。

例如：

char *x;

x = (char *)malloc(10); //x就指向了包含10个字符单元的存储空间。

扩展资料：

函数定义

其函数原型为void *malloc(unsigned int size)；其作用是在内存的动态存储区中分配一个长度为size的连续空间。此函数的返回值是分配区域的起始地址，或者说，此函数是一个指针型函数，返回的指针指向该分配域的开头位置。

如果分配成功则返回指向被分配内存的指针(此存储区中的初始值不确定)，否则返回空指针NULL。当内存不再使用时，应使用free()函数将内存块释放。函数返回的指针一定要适当对齐，使其可以用于任何数据对象。

参考资料来源：百度百科-malloc函数

本文标题：c语言线性表扩容的函数 c语言线性表扩容的函数有哪些
文章来源：http://pwwzsj.com/article/dooidch.html