c语言线性表扩容的函数 c语言线性表扩容的函数有哪些
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://mswzjz.cn/article/dooidch.html