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語言順序表和鏈表分配空間相關的內容