c语言顺序表和链表分配空间_C语言关于链表与顺序表的结构问题静态顺序表与静态链表的区别是什么

① c语言关于链表与顺序表的结构问题，静态顺序表与静态链表的区别是什么

静态链表是用数组实现的，是顺序的存储结构，在物理地址上是连续的，而且需要预先分配大小。动态链表是用申请内存函数（C是malloc,C++是new）动态申请内存的，所以在链表的长度上没有限制。动态链表因为是动态申请内存的，所以每个节点的物理地址不连续，要通过指针来顺序访问。静态链表在插入、删除时也是通过修改指针域来实现的，与动态链表没有什么分别（动态链表还需要删除内存）。。不知道我的回答是不是解决了你的问题，希望可以帮到你。（其实用链表一般都是动态链表或者结构数组）

② C语言（数据结构），顺序表及链表的问题

1..顺序表的后插（入）的C程序#include <stdio.h>#include <stdlib.h>#include <malloc.h>#define LIST_INIT_SIZE 100 //顺序表初始容量(能容纳的元素个数)#define LISTINCREMENT 10 //容量增量typedef int ElemType; //元素类型ElemType为inttypedef int Status; //函数返回值类型Status为int//定义顺序表类型SqList：typedef struct{ElemType *elem; //存储空间基址(顺序表的起址)int length; //当前长度int listsize; //当前容量}SqList;/* 初始化：构造一个空的顺序表L 初始容量 LIST_INIT_SIZE */Status InitList_Sq(SqList *L){unsigned int nSize;nSize = LIST_INIT_SIZE * sizeof(ElemType);//欲分配空间字节数L->elem = (ElemType *)malloc(nSize);//分配初始的存储空间if (!L->elem) //若未分配成功，exit(-1); //则终止程序(退出码-1)L->length = 0; //初始长度L->listsize = LIST_INIT_SIZE; //初始容量return 1; }//InitList_Sq/* 追加：将c追加到表L末尾。*/Status ListAppend_Sq(SqList *L, ElemType a){ unsigned int nSize; ElemType *newbase, *p, *q; //若表容量不够则扩展: if (L->length >= L->listsize) //若满容， { //则扩容： L->listsize += LISTINCREMENT; //新容量 nSize = L->listsize * sizeof(ElemType);//欲分配空间字节数 newbase = (ElemType *)realloc(L->elem,nSize);//重新分配空间 if (!newbase) //若未分配成功， exit(-1); //则终止程序(退出码-1) }L->elem[L->length]=e; //e插入顺序表末尾 ++L->length; //表长加1 return 1; }//ListAppend_Sq2.单链表的头插（入）的C程序（这儿使用的是带头结点的单链表为例）#include <stdio.h>#include <stdlib.h>#include <malloc.h>typedef char ElemType;//元素类型ElemType为chartypedef int Status; //函数返回值类型Status为int//定义单链表类型LinkList：typedef struct LNode{ElemType data; //数据域struct LNode *next; //指针域(链域)}LNode, *LinkList;/* 以上定义了单链表结点类型LNode及指向表结点的指针类型(单链表类型)Linklist。 *//* 初始化：构造一个空的单链表L */Status InitList_L(LinkList *L) {LNode *h;h = (LNode *)malloc(sizeof(LNode));//申请头结点空间if (!h) //若未申请成功，exit(-1); //则终止程序(退出码-1)h->next = NULL; //头结点链域置空*L = h; //表头指针指向头结点return 1; }//InitList_L/* 头插若干个结点，结点值v。*/void Headinsert_L(LinkList L, ElemType v){LNode *head, *p;ElemType c;head = L; c = v; //c指向当前结点值位置p = (LNode *)malloc(sizeof(LNode));//申请新结点空间p->data = c; //新结点值p->next = head->next; head->next = p;}//Headinsert3.单链表的在i的位置之后插（入）的C程序//预定义、头文件、单链表的结点结构定义、初始化等同上/* 按位序查找：(头结点看作第0个结点)找出单链表L的第i个结点并返回指向该结点的指针若i<0或i>表长，则返回NULL*/LNode *GetNode_L(LinkList L, int i){LNode *p;int c = 0; //计数器置0p = L; //当前结点为头结点//从头结点开始搜索：while ((c < i) && (p->next != NULL)){//若未到位且下一结点存在，则搜索下一结点c++; //计数器加1p = p->next;//下一结点作为当前结点}//end whileif (c == i) //若搜索了i步，return p; //则返回最后搜索点；else //否则，return NULL;//返回NULL}//GetNode_L/* 插入：在单链表L的位置i前插入元素e若插入成功返回OK，否则返回ERROR。算法步骤：1. 找出第i结点前驱pre2. 生成新结点3. 新结点值置为e4. 使新结点指向pre的后继5. 使pre指向新结点*/Status ListInsert_L(LinkList L,int i,ElemType e){LNode *pre, *pnew;pre = GetNode_L(L, i-1);//找出第i结点前驱if (!pre) return 0; //若未找到则退出pnew = (LNode *)malloc(sizeof(LNode));//申请新结点空间pnew->data = e; //新结点值置为epnew->next = pre->next; //新结点指向pre的后继pre->next = pnew; //pre指向新结点return 1;}//ListInsert_L

③ C语言链表分配空间问题。

malloc分配的空间的类型是void*的(struct
test
*)是将void*型强制转换为该类型
目的就是为了在指针操作时知迟型道所指向的类型占用多大码租猜空间
比如：p指向0x0001，p++时，如果没有强制转换，则p将指向0x0002
如果进行了强制转换，p++时，p指向
p+sizeof（struct
test）的位置型历
另外一个就是要类型匹配
指针P的类型是 struct
test
*，指向的也要是该类型的，知道了类型也就知道了占用空间的大小，
在进行偏移操作时就不会出问题

④ 顺序表和链表的基本操作，用C语言实现！

顺序存储的线性表的算法
#include "stdio.h"
#include "stdlib.h"
#define Status int
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{ElemType elem[MAXSIZE];
int length;
}SqList;
void InitList(SqList &L){
L.length=0;
}
/*建立顺序表*/
void CreateList(SqList &L)
{
int i;
printf("input the length");
scanf("%d",&L.length);//输入表长
for(i=1;i<=L.length;i++)
scanf("%d",&L.elem[i-1]);//输入元素
}
//顺序表的遍历
void printdata(ElemType e){
printf("%4d",e);
}
void Traverse(SqList L,void (*visit)(ElemType e))
{ int i;
printf("The elements of the lists are:\n");
for(i=1;i<=L.length;i++){
if (i%10==0)printf("\n");//每行显示10个元素
visit(L.elem[i-1]);//输出表中元素
}
printf("\n");
}

//有序顺序表L中插入元素e使序列仍有序
void Insert(SqList &L,ElemType e)
{int i,j;
if (L.length==MAXSIZE)exit(OVERFLOW);//表满,不能插入
for(i=1;i<=L.length&&L.elem[i-1]<=e;i++);//向后查找
for(j=L.length;j>=i;j--)
L.elem[j]=L.elem[j-1];//元素后移
L.elem[i-1]=e;//插入e
L.length=L.length+1;//表长加1
}
//建立递增有序的顺序表
void CreateList_Sorted(SqList &L)
{int i,num;
ElemType e;
L.length=0;
printf("Create a sorted list,Input the length of the list\n");
scanf("%d",&num);
printf("Input the data %d numbers\n",num);
for(i=1;i<=num;i++){
scanf("%d",&e);
Insert(L,e);
}
}
/*Merge two sorted lists*/
void MergeList(SqList La,SqList Lb,SqList &Lc)
{int *pa,*pb,*pc;
if (La.length+Lb.length>MAXSIZE) exit(OVERFLOW);
else
{pa=La.elem;pb=Lb.elem;pc=Lc.elem;
while (pa<La.elem+La.length&&pb<Lb.elem+Lb.length)
*pc++=(*pa<=*pb)?*pa++:*pb++;/*公共部分合并*/
while (pa<La.elem+La.length) *pc++=*pa++;
/*R1表的剩余部分放到R的后部*/
while (pb<Lb.elem+Lb.length) *pc++=*pb++;
/*R2表的剩余部分放到R的后部*/
Lc.length=La.length+Lb.length;/*R表长*/
}
}
//判断元素是否对称，对称返回TRUE 否则返回FALSE
Status Symmetric(SqList L)
{int low,high;
low=0;
high=L.length-1;
while(low<high)
if (L.elem[low]==L.elem[high]){low++;high--;}
else return(FALSE); return(TRUE); }
//顺序表的主函数部分
//#include "seqlist.h"
void main()
{SqList L1,L2,L;
int select;
ElemType e;
do{printf("\n1 insert 2 merge");
printf("\n3 symmetric 0 exit \n");
printf("Please select(0--3)\n");
scanf("%d",&select);
switch(select){
case 1:
InitList(L);
CreateList_Sorted(L);
Traverse(L,printdata);
printf("\nInput the element of inserted\n");
scanf("%d",&e);
Insert(L,e);
Traverse(L,printdata);
break;
case 2:
InitList(L1);
CreateList_Sorted(L1);
Traverse(L1,printdata);
InitList(L2);
CreateList_Sorted(L2);
Traverse(L2,printdata);
InitList(L);
MergeList(L1,L2,L);
Traverse(L,printdata);
break;
case 3:
InitList(L);
CreateList(L);
Traverse(L,printdata);
if (Symmetric(L)) printf("Yes!\n"); else printf("Not\n");
break;
case 0:break;
default:printf("Error! Try again!\n");
}
}while(select);
}

/*单向链表的有关操作示例*/
/*类型定义及头文件部分,文件名为sllink.h*/
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;//元素实际类型
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList; //定义结点、指针类型名
//头插法建立无序链表
void CreateList(LinkList &L){
LinkList p;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("头插法建立链表，以0结束\n");
scanf("%d",&e);
while(e){
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
p->next=L->next;
L->next=p;
scanf("%d",&e);
}
}
/*非递减有序单向链表L插入元素e序列仍有序*/
void Insert_Sort(LinkList &L,ElemType e){
LinkList p,s;
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
p=L;
while(p->next&&p->next->data<=e)
p=p->next;/*查找插入位置*/
s->next=p->next; /*插入语句*p结点后插入*s结点*/
p->next=s;
}
/*建立递增有序的单向链表*/
void Create_Sort(LinkList &L){
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("建立有序表，输入任意个整型数据以0结束\n");
scanf("%d",&e);
while(e){
Insert_Sort(L,e);
scanf("%d",&e);
}
}
/*单向链表的遍历*/
void Traverse(LinkList L){
LinkList p;
printf("遍历链表");
for(p=L->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
/*在单向链表删除元素e*/
void Delete(LinkList &L,ElemType e){
LinkList p,q;
p=L;
q=L->next;
while(q&& q->data!=e){//查找元素的删除位置
p=q;
q=q->next;
}
if(!q) printf("\nnot deleted");/*未找到元素e*/
else {p->next=q->next;/*找到删除*/
free(q);}
}
/*单向链表的逆置*/
void exch(LinkList &L){
LinkList p,s;
p=L->next;
L->next=NULL;
while(p){
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
/*两个非递减有序单向链表合并后仍为非递减序列*/
void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc){
LinkList p,q,s,rear;
p=La->next;
q=Lb->next;
Lc=rear=La;
free(Lb);
while(p&&q){
if (p->data<q->data) {s=p;p=p->next; }
else {s=q;q=q->next; }
rear->next=s;/*较小元素插入表尾*/
rear=rear->next;
}
if (p) rear->next=p; else rear->next=q;
}

/*主函数部分,文件名为sllink.c*/
//#include "sllink.h"
void main(){
LinkList La,Lb,Lc;
ElemType e;
int select;
do{
printf(" 1 建立无序表，再删除指定元素\n");
printf(" 2 建立递增有序表，再逆置\n");
printf(" 3 建立两个递增有序表，将它们和并为一个仍递增表\n");
printf(" 0 退出，请输入选项(0-3)\n");
scanf("%d",&select);
switch(select){
case 0:
break;
case 1:
CreateList(La);
Traverse(La);
printf("输入需删除的元素\n");
scanf("%d",&e);
Delete(La,e);
Traverse(La);
break;
case 2:
Create_Sort(La);
Traverse(La);
exch(La);
printf("The list that is exchaged\n");
Traverse(La);
break;
case 3:
Create_Sort(La);Traverse(La);
Create_Sort(Lb);Traverse(Lb);
MergeIncrease(La,Lb,Lc);Traverse(Lc);
break;
default:
printf("输入选项错误，请重新输入！\n");
}

}while(select);
}
这些内容不知道能不能帮助到你。

⑤ c语言链表空间分配的问题，邀请诸位高手共析~

s=(pNode)malloc(sizeof(pNode))只申请了一个指针空间。故而后面free(s)，因为找不到s指向的Node节点空间。而报错滚卖。
申请一个pNode的空间，返回一个pNode型指针s，。s->next = s是指针s的强制性操作未知猜简空间(指针是C的精华，也是缺点。)。也就是操作了s指向空间（开大兆逗始的前四个为data，后四个为next.实际上，系统不认可,所以释放报错）。你可以强制性输出s里面的内容看看。
printf("data:[%d] next:[%p]\n",s->data,s->next);
不知道说明白了没有。不明白可以追问。

⑥ 数据结构 c语言版 ——顺序表的查找、插入与删除

#include<stdio.h>
#include<stdlib.h>
#define N 10 //顺序表的最大容量
int length=0; //顺序表的当前元素个数

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100//线性表存储的空间初始化分配量
#define LISTINCREAMENT 10 //线性表存储空间的分配增量

typedef struct LNode//线性单链表存储结构
{
int data;
struct LNode *next;
}LNode,*LinkList;

int CreatList_L(LinkList&L)//创建一个线性链表
{
L=(LinkList)malloc(sizeof(LNode));//分配一个空间给链表，作为头结点

if(!L) exit(OVERFLOW);
L->next=NULL;
return OK;
}
int DestroyList_L(LinkList &L)//销毁链表
{
if(L) free(L);
return OK;
}
int ListInsert_L(LinkList&L,int i,int e)//再练表的第i个元素前插入一个元素e
{
LinkList p=L;//p指针定位于i-1
LNode *s;
int j=0;
while(p&&j<i-1) {p=p->next;j++;}//定位
if(!p||j>i-1) return ERROR;//如果i<1或大于链表元素个数+1
s=(LNode*)malloc(sizeof(LNode));
if(!s) exit(OVERFLOW);
s->data=e; //完成插入操作
s->next=p->next;
p->next=s;
return OK;
}

int ListDelet_L(LinkList&L,int i,int&e)//删除链表L中的第i个元素，并返回给e;
{
LinkList p=L;
LNode* q;
int j=0;
while(!p&&j<i-1) {p=p->next;j++;}//p指针定位于i-1；
if(!p->next||j>i-1) return ERROR;

e=p->next->data; //完成删除操作
q=p->next;
p->next=p->next->next;
free(q);
return OK;

}

int ListTraverse_L(LinkList L,int n)//链表的遍历
{
int i=0;
if(!L)return ERROR;
L=L->next;
while(L)
{
if(L->data==n)return i;
L=L->next;
i++;
}

return FALSE;
}

int InverseSingleList_L(LinkList &L)
{
if(!L->next||!L->next->next)//如果链表少于2个Node那么链表不需要改变顺序
return OK;
LNode *p,*q;
p=L->next; //第一次因为p是最后一个连接所以把p->next设为空
q=p->next;
p->next=NULL;
p=q;
while(p)
{
q=p->next; //用q去保留p后面一个Node;
p->next=L->next;
L->next=p;
p=q;
}
return OK;
}

int main()
{
int List[N];
LinkList L;

int ch,exit='N';
do
{
system("CLS");
printf("\t\t********************************************\n");
printf("\t\t* 1.创建一个顺序表 .........(1) *\n");
printf("\t\t* 2.在顺序表中查找元表.........(2) *\n");
printf("\t\t* 3.在顺序表中插入元表.........(3) *\n");
printf("\t\t* 4.在顺序表中删除元表.........(4) *\n");
printf("\t\t* 5.退出 .........(5) *\n");
printf("\t\t********************************************\n");
printf("\n请选择操作代码：");
ch=getchar();

switch(ch)
{
case '1':
printf("\n请输入十个元素");
CreatList_L(L);
for(length=0;length<N;length++)
{
scanf("%d",&List[length]);
getchar();
ListInsert_L(L,length+1,List[length]);
}
printf("\n创建成功！");
getchar();
break;
case '2':
scanf("%d",&List[0]);
if(ListTraverse_L(L,List[0]))printf("该元素存在该年表的第%d个位置",ListTraverse_L(L,List[0]));
else printf("不存在该元素");
getchar();
break;
case '3':
scanf("%d%d",&length,&List[0]);
ListInsert_L(L,length,List[0]);
system("pause");
break;
case '4':
scanf("%d",&length);
ListDelet_L(L,length,List[0]);
system("pause");
break;
case '5':
printf("\n您是否真的要退出程序(Y/N):");
getchar();
exit=getchar();
break;
default:
getchar();
printf("\n无效输入，请重新选择...:");
getchar();
break;

}

}while(exit!='y'&&exit!='Y');

}

⑦ 顺序表和链表的比较

1）存储分配的方式
顺序表的存储空间是一次性分配的，链表的闷模存储空渣洞间是如罩枯多次分配的。
2）存储密度的比较（存储密度=结点值域所占的存储量／结点结构所占的存储总量）
顺序表的存储密度=1，链表的存储密度<1.

1）存取方式
顺序表可以随机存取，也可以顺序存取；链表只能顺序存储。
2）插入／删除时移动元素的个数
顺序表平均需要移动近一半元素；链表不需要移动元素，只需要修改指针。

⑧ 顺序表和链表的分配方式

顺序表分塌巧模配一组地址连续的空间，链表的话有静态链表和动态链表团缓之分宽吵，静态链表是用数组实现的，分配空间地址也是连续的，而动态链表比如单链表地址是随机的，内存中哪个空间未被占用都有可能被分配给单链表

c语言顺序表和链表分配空间

与c语言顺序表和链表分配空间相关的内容