c語言初始動態分配線性表_線性表的基本操作c語言實現

1. c語言——線性表

#include"stdio.h"
#include<malloc.h>

typedef char ElemType;

typedef struct LNode
{ElemType data;
struct LNode *next;
}LinkList;

void CreatListF(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;
L->next=s;
}
}

void CreateListR(LinkList *&L,ElemType a[],int n) //尾插法建表
{
LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList));
r=L;
for(i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=a[i];
r->next=s;
r=s;
}
r->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);
}

int ListEmpty(LinkList *L) //判斷線性表是否為空
{
return(L->next==NULL);
}

int ListLength(LinkList *L) //求線性表的長度
{
LinkList *p=L;int n=0;
while(p->next!=NULL)
{
n++;p=p->next;
}
return(n);
}

void DispList(LinkList *L) //輸出線性表
{
LinkList *p=L->next;
while(p!=NULL)
{
printf("%c",p->data);
p=p->next;
}
}

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)
return 0;
else
{
e=p->data;return 1;
}
}

int LocateElem(LinkList *L,ElemType e) //按元素值查找
{
LinkList *p=L->next;
int i=1;
while(p!=NULL&&p->data!=e)
{
p=p->next;i++;
}
if(p==NULL)return(0);
else return(i);
}

int ListInsert(LinkList *&L,int i,ElemType e) //插入數據元素
{
int j=0;
LinkList *p=L,*s;
while(j<i-1&&p!=NULL)
{
j++;p=p->next;
}
if(p==NULL)return 0;
else
{
s=(LinkList *)malloc(sizeof(LinkList));
s->data=e; s->next=p->next; 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)
{
j++;p=p->next;
}
if(p==NULL)
return 0;
else
{
q=p->next;
if(q==NULL)return 0;
e=q->data;
p->next=q->next;
free(q);
return 1;
}
}

int main()
{
ElemType e,a[5]={'a','b','c','d','e'};
LinkList *h;

InitList(h); //初始化順序表h
CreateListR(h,&a[0],5); //依次採用尾插入法插入a，b，c，d，e元素
printf("單鏈表為：");
DispList(h); printf("\n"); //輸出順序表h

printf("該單鏈表的長度為：");
printf("%d",ListLength(h)); printf("\n"); //輸出順序表h的長度
if(ListEmpty(h)) printf("該單鏈表為空。\n");
else printf("該單鏈表不為空。\n"); //判斷順序表h是否為空

GetElem(h,3,e);printf("該單鏈表的第3個元素為：");
printf("%c",e); printf("\n"); //輸出順序表h的第3個元素
printf("該單鏈表中a的位置為：");
printf("%d",LocateElem(h,'a')); printf("\n"); //輸出元素'a'的位置

ListInsert(h,4,'f'); //在第4個元素位置插入'f'素
printf("在第4 個元素位置上插入'f'後單鏈表為：");
DispList(h); printf("\n"); //輸出順序表h

ListDelete(h,3,e); //刪除L的第3個元素
printf("刪除第3個元素後單鏈表為：");
DispList(h); printf("\n"); //輸出順序表h

DestroyList(h); //釋放順序表h
return 0;
}

2. 用c語言寫一個程序，初始化一個線性表。跪求

#include <stdio.h>
#include <malloc.h>
# define MaxSize 50
typedef struct{
ElemType data[MaxSize];//存放順序表元素
int length;//存放順序表長度
}SqList;//順序表類型定義
//建立順序表
void CreateList(SqList *&L,ElemType a[],int n){
int i;
for(i=0;i<n;i++){
L->data [i]=a[i];
}
L->length =n;
}
//順序表基本運算演算法
//初始化線性表InitList（L）
void InitList(SqList *&L){
L=(SqList *)malloc(sizeof(SqList));//分配存放線性表的空間
L->length =0;
}//本演算法的時間復雜度為O(1)
//銷毀線性表
void DestroyList(SqList *&L){
free(L);
}//本演算法的時間復雜度為O(1)
//判斷線性表是否為空
int ListEmpty(SqList *L){
return (L->length ==0);
}//本演算法的時間復雜度為O(1)
//求線性表的長度
int ListLength(SqList *L){
return (L->length);
}//本演算法的時間復雜度為O(1)
//輸出線性表
void DispList(SqList *L)
{
int i;
if(ListEmpty(L)) return;
for(i=0;i<L->length;i++){
printf(nn,L->data[i]);
}
printf("\n");
}//本演算法的時間復雜度為O(L->length)
//求線性表中某個數據的元素值
int GetElem(SqList *L,int i,ElemType &e)
{
if(i<1||i>L->length)
return 0;
e=L->data[i-1];//這兒體現了數組的優點，可以直接通過下標訪問
return 1;
}//本演算法的時間復雜度為O(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;
}//本演算法中基本運算為while循環中的i++語句，故時間復雜度為O(L->length)
//插入數據元素
int ListInsert(SqList *&L,int i,ElemType e){
int j;
if(i<1 || i>L->length+1)
return 0;//參數錯誤，返回0
i--;//將順序邏輯位序變為物理位序
for(j=L->length;j>i;j--){
L->data[j]=L->data[j-1];//將data[i]及後面的元素後移一個位置
}
L->data[i]=e;//插入元素e
L->length++;//增加長度
return 1;
}//本演算法的平均時間復雜度為O(n)
//刪除數據元素
int ListDelete(SqList *&L,int i,ElemType &e){
int j;
if(i<1 || i>L->length)
return 0;
i--;//將順序邏輯位序變為物理位序
e=L->data[i];
for(j=i;j<L->length-1;j++){
L->data[j]=L->data[j+1];//將data[i]之後的元素前移一個位置，這就是數組中的刪除思想
}
L->length--;
return 1;
}//本演算法的平均時間復雜度為O(n)

3. C語言中初始化線性表，並從鍵盤輸入值

數據結構如果只建立線性表那是不能使表保持順序的只有鏈表才能所以我用了鏈表
還有就是自己多看看書自己多想想代碼
#include <stdio.h>
#include <stdlib.h>

typedef int elemtype;

typedef struct xianxing
{
struct xianxing *next;
elemtype number;
}ST;

ST *Init_SequenList()//實現初始化一個線性表的函數
{
ST *L;
L = (ST *)malloc(sizeof(ST));
L->next = NULL;
return L;
}

ST * add_head(ST *head)//實現往鏈表內添加數字函數按照升順序的
{
ST *q ,*p;
p = head;
q = (ST *)malloc(sizeof(ST));
printf("請輸入你要添加的數:");
scanf("%d",&q->number);
if(p->next == NULL)
{
q->next = p->next;
p->next = q;
}
else
{
while(p->next->number < q->number)//比較大小找到插入的位置
{
p = p->next;
}
q->next = p->next;
p->next = q;
}
return head;
}

void show_head(ST *head)//顯示鏈表
{
ST *p;
p = head;
while(p->next)
{
printf("%d\n",p->next->number);
p = p->next;
}
}

void main()
{
ST *head;
int n ;//n個元素

printf("請輸入你要創建幾個元素:");
scanf("%d",&n);
head = Init_SequenList();//初始化一個線性表
while(n)
{
head = add_head(head);//往線性表裡添加數
n--;
}
show_head(head);//顯示鏈表
}

4. 跪求：線性表初始化函數的詳細解釋（c語言）

函數中不會修改main()函數中定義的變數，修改如下：
//---------------------------------------------------------------------------
#include
#include
#define
LIST_INIT_SIZE
100
#define
LISTINCREMENT
10
typedef
int
ElemType[LIST_INIT_SIZE];
typedef
struct
{
ElemType
*elem;
int
length;
int
listsize;
}SqList;
typedef
int
Status;
int
InitList_Sq(SqList
*L)
/*注意這里*/
{
L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
/*注意這里*/
if(!L->elem)
/*注意這里*/
L->length=1;
/*注意這里*/
printf("%d\n",L->length);
/*注意這里*/
L->listsize=LIST_INIT_SIZE;
/*注意這里*/
return
1;
}
int
main()
{
SqList
p=;
/*注意這里*/
InitList_Sq(&p);
/*注意這里*/
printf("%d\n",p.length);
return
0;
}
//---------------------------------------------------------------------------

5. 1、建立線性表的（動態分配）順序存儲結構。

屁話！我倒知道你編譯失敗！你的主函數main呢？？？下面的是我寫的。

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -2
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int ElemType;
typedef int Status;
typedef struct{
ElemType *elem;
int length;
int listsize;
}Sqlist;
Status InitList_Sq(Sqlist *L) {//千萬注意這里的參數是×L ，而不是&L，為什麼？
L->elem = (ElemType *) malloc (LIST_INIT_SIZE * sizeof(ElemType) );//這里為什麼是L->elem,而不是L.elem？
if(!L->elem) exit( OVERFLOW );
L->length=0;
L->listsize = LIST_INIT_SIZE;
return OK;//這句話純屬廢話
}

int main(void) {

Sqlist A;

InitList_Sq(&A);

}//

6. c語言對線性表進行初始化問題

你傳入init函數的參數是傳值調用，所以init函數中不會修改main()函數中定義的變數，修改如下：

//---------------------------------------------------------------------------

#include<stdio.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef int ElemType[LIST_INIT_SIZE];
typedef struct {
ElemType *elem;
int length;
int listsize;
}SqList;
typedef int Status;
int InitList_Sq(SqList *L) /*注意這里*/
{

L->elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType)); /*注意這里*/
if(!L->elem){return 0;} /*注意這里*/
L->length=1; /*注意這里*/
printf("%d\n",L->length); /*注意這里*/
L->listsize=LIST_INIT_SIZE; /*注意這里*/
return 1;
}
int main()
{
SqList p={NULL}; /*注意這里*/
InitList_Sq(&p); /*注意這里*/
printf("%d\n",p.length);
return 0;
}

//---------------------------------------------------------------------------

7. 求一用c語言編程的可以運行的線性表的初始化、插入和刪除操作。希望不要與網上雷同，做學慣用。

8. 如何C語言編寫線性表的初始化，求線性表長度，插入，刪除

#include<stdlib.h>
#include<stdio.h>
struct node
{
int num;
struct node *next;
};
struct node *head=NULL,*point,*newNode;
int Count=0;//鏈表長度
//增加節點
void Add(int i)
{
newNode=(struct node*)malloc(sizeof(struct node));
if(newNode==NULL)
exit(0);
if(head==NULL)
{
head=newNode;
}
else
{
point=head;
while(point->next!=NULL)
{
point=point->next;
}
point->next=newNode;
}
point=newNode;
point->num=i;
point->next=NULL;
Count++;
}
//查詢第i個結點
void Search(int i)
{
int n;
struct node *temp;
point=head;
for(n=0;n<i;n++)
{
temp=point;
point=point->next;
}
printf("%d\n",point->num);
}
//刪除第i個結點
void DeleteNode(int i)
{
int n=0;
struct node *temp;
point=head;
for(n=0;n<i;n++)
{
temp=point;
point=point->next;
}
temp->next=point->next;
Count--;
}
//遍歷列印鏈表
void Traversal()
{
point=head;
for(;point!=NULL;point=point->next)
{
printf("%d\t",point->num);
}
printf("\n");
}

9. 線性表的基本操作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; index<SeqList_Length(list); index++)

{

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

printf("%d ", *p);

}

printf(" ");

//刪除操作

while( SeqList_Length(list) > 0 )

{

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

printf("刪除了： %d ", *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; i<sList->len; i++)

{

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

}

sList->len--;

}

return node;

}

演示：

資料拓展：

線性表是最基本、最簡單、也是最常用的一種數據結構。

線性表中數據元素之間的關系是一對一的關系，即除了第一個和最後一個數據元素之外，其它數據元素都是首尾相接的（注意，這句話只適用大部分線性表，而不是全部。比如，循環鏈表邏輯層次上也是一種線性表（存儲層次上屬於鏈式存儲），但是把最後一個數據元素的尾指針指向了首位結點）。

我們說「線性」和「非線性」，只在邏輯層次上討論，而不考慮存儲層次，所以雙向鏈表和循環鏈表依舊是線性表。

在數據結構邏輯層次上細分，線性表可分為一般線性表和受限線性表。一般線性表也就是我們通常所說的「線性表」，可以自由的刪除或添加結點。受限線性表主要包括棧和隊列，受限表示對結點的操作受限制。

線性表的邏輯結構簡單，便於實現和操作。因此，線性表這種數據結構在實際應用中是廣泛採用的一種數據結構。

10. 怎樣在C語言創建線性表

c語言初始動態分配線性表

與c語言初始動態分配線性表相關的內容