資料結構C語言實現-2—線性表

阿新 • • 發佈：2018-12-21

Table of Contents

線性表順序儲存結構

#include <stdio.h>    

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 儲存空間初始分配量 */

typedef int Status;          /* Status是函式的型別,其值是函式結果狀態程式碼，如OK等 */
typedef int ElemType;        /* ElemType型別根據實際情況而定，這裡假設為int */

/* 輸出元素c */
Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

typedef struct
{
	ElemType data[MAXSIZE];        /* 陣列，儲存資料元素 */
	int length;                                /* 線性表當前長度 */
}SqList;

/* 初始化順序線性表 */
Status InitList(SqList *L) 
{ 
    L->length=0;
    return OK;
}

/* 初始條件：順序線性表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE */
Status ListEmpty(SqList L)
{ 
	if(L.length==0)
		return TRUE;
	else
		return FALSE;
}

/* 初始條件：順序線性表L已存在。操作結果：將L重置為空表 */
Status ClearList(SqList *L)
{ 
    L->length=0;
    return OK;
}

/* 初始條件：順序線性表L已存在。操作結果：返回L中資料元素個數 */
int ListLength(SqList L)
{
	return L.length;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：用e返回L中第i個數據元素的值,注意i是指位置，第1個位置的陣列是從0開始 */
Status GetElem(SqList L,int i,ElemType *e)
{
    if(L.length==0 || i<1 || i>L.length)
            return ERROR;
    *e=L.data[i-1];

    return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：返回L中第1個與e滿足關係的資料元素的位序。 */
/* 若這樣的資料元素不存在，則返回值為0 */
int LocateElem(SqList L,ElemType e)
{
    int i;
    if (L.length==0)
            return 0;
    for(i=0;i<L.length;i++)
    {
            if (L.data[i]==e)
                    break;
    }
    if(i>=L.length)
            return 0;

    return i+1;
}


/* 初始條件：順序線性表L已存在,1≤i≤ListLength(L)， */
/* 操作結果：在L中第i個位置之前插入新的資料元素e，L的長度加1 */
Status ListInsert(SqList *L,int i,ElemType e)
{ 
	int k;
	if (L->length==MAXSIZE)  /* 順序線性表已經滿 */
		return ERROR;
	if (i<1 || i>L->length+1)/* 當i比第一位置小或者比最後一位置後一位置還要大時 */
		return ERROR;

	if (i<=L->length)        /* 若插入資料位置不在表尾 */
	{
		for(k=L->length-1;k>=i-1;k--)  /* 將要插入位置之後的資料元素向後移動一位 */
			L->data[k+1]=L->data[k];
	}
	L->data[i-1]=e;          /* 將新元素插入 */
	L->length++;

	return OK;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：刪除L的第i個數據元素，並用e返回其值，L的長度減1 */
Status ListDelete(SqList *L,int i,ElemType *e) 
{ 
    int k;
    if (L->length==0)               /* 線性表為空 */
		return ERROR;
    if (i<1 || i>L->length)         /* 刪除位置不正確 */
        return ERROR;
    *e=L->data[i-1];
    if (i<L->length)                /* 如果刪除不是最後位置 */
    {
        for(k=i;k<L->length;k++)/* 將刪除位置後繼元素前移 */
			L->data[k-1]=L->data[k];
    }
    L->length--;
    return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：依次對L的每個資料元素輸出 */
Status ListTraverse(SqList L)
{
	int i;
    for(i=0;i<L.length;i++)
            visit(L.data[i]);
    printf("\n");
    return OK;
}

void unionL(SqList *La,SqList Lb)
{
	int La_len,Lb_len,i;
	ElemType e;
	La_len=ListLength(*La);
	Lb_len=ListLength(Lb);
	for (i=1;i<=Lb_len;i++)
	{
		GetElem(Lb,i,&e);
		if (!LocateElem(*La,e))
			ListInsert(La,++La_len,e);
	}
}

int main()
{
        
    SqList L;
	SqList Lb;
    
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L後：L.length=%d\n",L.length);
    for(j=1;j<=5;j++)
            i=ListInsert(&L,1,j);
    printf("在L的表頭依次插入1～5後：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L後：L.length=%d\n",L.length);
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10後：L.data=");
    ListTraverse(L); 

    printf("L.length=%d \n",L.length);

    ListInsert(&L,1,0);
    printf("在L的表頭插入0後：L.data=");
    ListTraverse(L); 
    printf("L.length=%d \n",L.length);

    GetElem(L,5,&e);
    printf("第5個元素的值為：%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d個元素的值為%d\n",k,j);
            else
                    printf("沒有值為%d的元素\n",j);
    }
    

    k=ListLength(L); /* k為表長 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 刪除第j個數據 */
            if(i==ERROR)
                    printf("刪除第%d個數據失敗\n",j);
            else
                    printf("刪除第%d個的元素值為：%d\n",j,e);
    }
    printf("依次輸出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 刪除第5個數據 */
    printf("刪除第%d個的元素值為：%d\n",j,e);

    printf("依次輸出L的元素：");
    ListTraverse(L); 

	//構造一個有10個數的Lb
	i=InitList(&Lb);
    for(j=6;j<=15;j++)
            i=ListInsert(&Lb,1,j);

	unionL(&L,Lb);

	printf("依次輸出合併了Lb的L的元素：");
    ListTraverse(L); 

    return 0;
}

線性錶鏈式儲存結構

#include "stdio.h"    
#include "string.h"
#include "ctype.h"      
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 20 /* 儲存空間初始分配量 */

typedef int Status;/* Status是函式的型別,其值是函式結果狀態程式碼，如OK等 */
typedef int ElemType;/* ElemType型別根據實際情況而定，這裡假設為int */


Status visit(ElemType c)
{
    printf("%d ",c);
    return OK;
}

typedef struct Node
{
    ElemType data;
    struct Node *next;
}Node;
typedef struct Node *LinkList; /* 定義LinkList */

/* 初始化順序線性表 */
Status InitList(LinkList *L) 
{ 
    *L=(LinkList)malloc(sizeof(Node)); /* 產生頭結點,並使L指向此頭結點 */
    if(!(*L)) /* 儲存分配失敗 */
            return ERROR;
    (*L)->next=NULL; /* 指標域為空 */

    return OK;
}

/* 初始條件：順序線性表L已存在。操作結果：若L為空表，則返回TRUE，否則返回FALSE */
Status ListEmpty(LinkList L)
{ 
    if(L->next)
            return FALSE;
    else
            return TRUE;
}

/* 初始條件：順序線性表L已存在。操作結果：將L重置為空表 */
Status ClearList(LinkList *L)
{ 
	LinkList p,q;
	p=(*L)->next;           /*  p指向第一個結點 */
	while(p)                /*  沒到表尾 */
	{
		q=p->next;
		free(p);
		p=q;
	}
	(*L)->next=NULL;        /* 頭結點指標域為空 */
	return OK;
}

/* 初始條件：順序線性表L已存在。操作結果：返回L中資料元素個數 */
int ListLength(LinkList L)
{
    int i=0;
    LinkList p=L->next; /* p指向第一個結點 */
    while(p)                        
    {
        i++;
        p=p->next;
    }
    return i;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：用e返回L中第i個數據元素的值 */
Status GetElem(LinkList L,int i,ElemType *e)
{
	int j;
	LinkList p;		/* 宣告一結點p */
	p = L->next;		/* 讓p指向連結串列L的第一個結點 */
	j = 1;		/*  j為計數器 */
	while (p && j<i)  /* p不為空或者計數器j還沒有等於i時，迴圈繼續 */
	{   
		p = p->next;  /* 讓p指向下一個結點 */
		++j;
	}
	if ( !p || j>i ) 
		return ERROR;  /*  第i個元素不存在 */
	*e = p->data;   /*  取第i個元素的資料 */
	return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：返回L中第1個與e滿足關係的資料元素的位序。 */
/* 若這樣的資料元素不存在，則返回值為0 */
int LocateElem(LinkList L,ElemType e)
{
    int i=0;
    LinkList p=L->next;
    while(p)
    {
        i++;
        if(p->data==e) /* 找到這樣的資料元素 */
                return i;
        p=p->next;
    }

    return 0;
}


/* 初始條件：順序線性表L已存在,1≤i≤ListLength(L)， */
/* 操作結果：在L中第i個位置之前插入新的資料元素e，L的長度加1 */
Status ListInsert(LinkList *L,int i,ElemType e)
{ 
	int j;
	LinkList p,s;
	p = *L;   
	j = 1;
	while (p && j < i)     /* 尋找第i個結點 */
	{
		p = p->next;
		++j;
	} 
	if (!p || j > i) 
		return ERROR;   /* 第i個元素不存在 */
	s = (LinkList)malloc(sizeof(Node));  /*  生成新結點(C語言標準函式) */
	s->data = e;  
	s->next = p->next;      /* 將p的後繼結點賦值給s的後繼  */
	p->next = s;          /* 將s賦值給p的後繼 */
	return OK;
}

/* 初始條件：順序線性表L已存在，1≤i≤ListLength(L) */
/* 操作結果：刪除L的第i個數據元素，並用e返回其值，L的長度減1 */
Status ListDelete(LinkList *L,int i,ElemType *e) 
{ 
	int j;
	LinkList p,q;
	p = *L;
	j = 1;
	while (p->next && j < i)	/* 遍歷尋找第i個元素 */
	{
        p = p->next;
        ++j;
	}
	if (!(p->next) || j > i) 
	    return ERROR;           /* 第i個元素不存在 */
	q = p->next;
	p->next = q->next;			/* 將q的後繼賦值給p的後繼 */
	*e = q->data;               /* 將q結點中的資料給e */
	free(q);                    /* 讓系統回收此結點，釋放記憶體 */
	return OK;
}

/* 初始條件：順序線性表L已存在 */
/* 操作結果：依次對L的每個資料元素輸出 */
Status ListTraverse(LinkList L)
{
    LinkList p=L->next;
    while(p)
    {
        visit(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}

/*  隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（頭插法） */
void CreateListHead(LinkList *L, int n) 
{
	LinkList p;
	int i;
	srand(time(0));                         /* 初始化隨機數種子 */
	*L = (LinkList)malloc(sizeof(Node));
	(*L)->next = NULL;                      /*  先建立一個帶頭結點的單鏈表 */
	for (i=0; i<n; i++) 
	{
		p = (LinkList)malloc(sizeof(Node)); /*  生成新結點 */
		p->data = rand()%100+1;             /*  隨機生成100以內的數字 */
		p->next = (*L)->next;    
		(*L)->next = p;						/*  插入到表頭 */
	}
}

/*  隨機產生n個元素的值，建立帶表頭結點的單鏈線性表L（尾插法） */
void CreateListTail(LinkList *L, int n) 
{
	LinkList p,r;
	int i;
	srand(time(0));                      /* 初始化隨機數種子 */
	*L = (LinkList)malloc(sizeof(Node)); /* L為整個線性表 */
	r=*L;                                /* r為指向尾部的結點 */
	for (i=0; i<n; i++) 
	{
		p = (Node *)malloc(sizeof(Node)); /*  生成新結點 */
		p->data = rand()%100+1;           /*  隨機生成100以內的數字 */
		r->next=p;                        /* 將表尾終端結點的指標指向新結點 */
		r = p;                            /* 將當前的新結點定義為表尾終端結點 */
	}
	r->next = NULL;                       /* 表示當前連結串列結束 */
}

int main()
{        
    LinkList L;
    ElemType e;
    Status i;
    int j,k;
    i=InitList(&L);
    printf("初始化L後：ListLength(L)=%d\n",ListLength(L));
    for(j=1;j<=5;j++)
            i=ListInsert(&L,1,j);
    printf("在L的表頭依次插入1～5後：L.data=");
    ListTraverse(L); 

    printf("ListLength(L)=%d \n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    i=ClearList(&L);
    printf("清空L後：ListLength(L)=%d\n",ListLength(L));
    i=ListEmpty(L);
    printf("L是否空：i=%d(1:是 0:否)\n",i);

    for(j=1;j<=10;j++)
            ListInsert(&L,j,j);
    printf("在L的表尾依次插入1～10後：L.data=");
    ListTraverse(L); 

    printf("ListLength(L)=%d \n",ListLength(L));

    ListInsert(&L,1,0);
    printf("在L的表頭插入0後：L.data=");
    ListTraverse(L); 
    printf("ListLength(L)=%d \n",ListLength(L));

    GetElem(L,5,&e);
    printf("第5個元素的值為：%d\n",e);
    for(j=3;j<=4;j++)
    {
            k=LocateElem(L,j);
            if(k)
                    printf("第%d個元素的值為%d\n",k,j);
            else
                    printf("沒有值為%d的元素\n",j);
    }
    

    k=ListLength(L); /* k為表長 */
    for(j=k+1;j>=k;j--)
    {
            i=ListDelete(&L,j,&e); /* 刪除第j個數據 */
            if(i==ERROR)
                    printf("刪除第%d個數據失敗\n",j);
            else
                    printf("刪除第%d個的元素值為：%d\n",j,e);
    }
    printf("依次輸出L的元素：");
    ListTraverse(L); 

    j=5;
    ListDelete(&L,j,&e); /* 刪除第5個數據 */
    printf("刪除第%d個的元素值為：%d\n",j,e);

    printf("依次輸出L的元素：");
    ListTraverse(L); 

    i=ClearList(&L);
    printf("\n清空L後：ListLength(L)=%d\n",ListLength(L));
    CreateListHead(&L,20);
    printf("整體建立L的元素(頭插法)：");
    ListTraverse(L); 
    
    i=ClearList(&L);
    printf("\n刪除L後：ListLength(L)=%d\n",ListLength(L));
    CreateListTail(&L,20);
    printf("整體建立L的元素(尾插法)：");
    ListTraverse(L); 


    return 0;
}

靜態連結串列

#include "string.h"
#include "ctype.h"      

#include "stdio.h"    
#include "stdlib.h"   
#include "io.h"  
#include "math.h"  
#include "time.h"

#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

#define MAXSIZE 1000 /* 儲存空間初始分配量 */

typedef int Status;           /* Status是函式的型別,其值是函式結果狀態程式碼，如OK等 */
typedef char ElemType;        /* ElemType型別根據實際情況而定，這裡假設為char */


Status visit(ElemType c)
{
    printf("%c ",c);
    return OK;
}

/* 線性表的靜態連結串列儲存結構 */
typedef struct 
{
    ElemType data;
    int cur;  /* 遊標(Cursor) ，為0時表示無指向 */
} Component,StaticLinkList[MAXSIZE];


/* 將一維陣列space中各分量鏈成一個備用連結串列，space[0].cur為頭指標，"0"表示空指標 */
Status InitList(StaticLinkList space) 
{
	int i;
	for (i=0; i<MAXSIZE-1; i++)  
		space[i].cur = i+1;
	space[MAXSIZE-1].cur = 0; /* 目前靜態連結串列為空，最後一個元素的cur為0 */
	return OK;
}


/* 若備用空間連結串列非空，則返回分配的結點下標，否則返回0 */
int Malloc_SSL(StaticLinkList space) 
{ 
	int i = space[0].cur;           		/* 當前陣列第一個元素的cur存的值 */
	                                		/* 就是要返回的第一個備用空閒的下標 */
	if (space[0]. cur)         
	    space[0]. cur = space[i].cur;       /* 由於要拿出一個分量來使用了， */
	                                        /* 所以我們就得把它的下一個 */
	                                        /* 分量用來做備用 */
	return i;
}


/*  將下標為k的空閒結點回收到備用連結串列 */
void Free_SSL(StaticLinkList space, int k) 
{  
    space[k].cur = space[0].cur;    /* 把第一個元素的cur值賦給要刪除的分量cur */
    space[0].cur = k;               /* 把要刪除的分量下標賦值給第一個元素的cur */
}

/* 初始條件：靜態連結串列L已存在。操作結果：返回L中資料元素個數 */
int ListLength(StaticLinkList L)
{
    int j=0;
    int i=L[MAXSIZE-1].cur;
    while(i)
    {
        i=L[i].cur;
        j++;
    }
    return j;
}

/*  在L中第i個元素之前插入新的資料元素e   */
Status ListInsert(StaticLinkList L, int i, ElemType e)   
{  
    int j, k, l;   
    k = MAXSIZE - 1;   /* 注意k首先是最後一個元素的下標 */
    if (i < 1 || i > ListLength(L) + 1)   
        return ERROR;   
    j = Malloc_SSL(L);   /* 獲得空閒分量的下標 */
    if (j)   
    {   
		L[j].data = e;   /* 將資料賦值給此分量的data */
		for(l = 1; l <= i - 1; l++)   /* 找到第i個元素之前的位置 */
		   k = L[k].cur;           
		L[j].cur = L[k].cur;    /* 把第i個元素之前的cur賦值給新元素的cur */
		L[k].cur = j;           /* 把新元素的下標賦值給第i個元素之前元素的ur */
		return OK;   
    }   
    return ERROR;   
}

/*  刪除在L中第i個數據元素   */
Status ListDelete(StaticLinkList L, int i)   
{ 
    int j, k;   
    if (i < 1 || i > ListLength(L))   
        return ERROR;   
    k = MAXSIZE - 1;   
    for (j = 1; j <= i - 1; j++)   
        k = L[k].cur;   
    j = L[k].cur;   
    L[k].cur = L[j].cur;   
    Free_SSL(L, j);   
    return OK;   
} 

Status ListTraverse(StaticLinkList L)
{
    int j=0;
    int i=L[MAXSIZE-1].cur;
    while(i)
    {
            visit(L[i].data);
            i=L[i].cur;
            j++;
    }
    return j;
    printf("\n");
    return OK;
}


int main()
{
    StaticLinkList L;
    Status i;
    i=InitList(L);
    printf("初始化L後：L.length=%d\n",ListLength(L));

    i=ListInsert(L,1,'F');
    i=ListInsert(L,1,'E');
    i=ListInsert(L,1,'D');
    i=ListInsert(L,1,'B');
    i=ListInsert(L,1,'A');

    printf("\n在L的表頭依次插入FEDBA後：\nL.data=");
    ListTraverse(L); 

    i=ListInsert(L,3,'C');
    printf("\n在L的“B”與“D”之間插入“C”後：\nL.data=");
    ListTraverse(L); 

    i=ListDelete(L,1);
    printf("\n在L的刪除“A”後：\nL.data=");
    ListTraverse(L); 

    printf("\n");

    return 0;
}

資料結構C語言實現-2—線性表

Table of Contents 靜態連結串列線性表順序儲存結構 #include <stdio.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #de

資料結構C語言實現——順序線性表SqList

delcaration.h #ifndef DECLARATION_H_INCLUDED #define DECLARATION_H_INCLUDED #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0

資料結構--C語言--已知線性表中的元素以值遞增有序排列，並以單鏈表作儲存結構。試寫一高效演算法，刪除表中所有值大於mink且小於maxk的元素

#include<stdio.h> #include<stdlib.h> #define OK 1 #define ERROR 0 #define LEN sizeof(struct LNode) struct LNode{ int data;//資料域 struct

資料結構-C語言實現順序表

#include<stdio.h> #include<stdlib.h> #define ERROR 0 #define LIST_INIT_SIZE 100 #define LISTINCREAMENT 10 #define OK 1

資料結構-C語言實現線性棧

#include<stdio.h> #include<stdlib.h> #define STACK_INIT_SIZE 100//儲存空間初始化分配量 #define STACKINCREAMENT 10//儲存空間分配增量 #defi

資料結構-C語言實現迴圈佇列

#include<stdio.h> #include<stdlib.h> #define MAXSIZE 100 #define OK 1 #define OVERFLOW -1 typedef struct{ int *base;

資料結構-c語言實現連結串列的建立，增刪，翻轉

很經典的課題了，這裡直接給出源程式： #include <stdio.h> #include <stdlib.h> #define LIST_MAX_LEN 10 typedef int ElementType; typedef int BOOL; #define TR

資料結構 c語言實現順序佇列（輸數字入隊，字元出隊）

一.標頭檔案seqqueue.h實現 #ifndef __SEQQUEUE_H__ #define __SEQQUEUE_H__ #include<stdio.h> #include<stdlib.h> #include<stdbool.h&g

嚴蔚敏資料結構C語言實現棧的基本操作

int main(){ SqStack S; SElemType *e; int n,i; InitStack(&S); printf("請輸入需要入棧的資料個數\n"); scanf("%d",&n); for(i=0;i<n;i++) { sca

0x00資料結構——C語言實現（棧+字尾表示式計算）

0x00資料結構——C語言實現（棧）棧的實現 /* 棧（tack）是限制插入和刪除只能在一個位置上進行的表，該位置是表的末端，叫做棧的頂（top）。對棧的基本操作有Push（進棧）和Pop（出棧）。 Functions: （在連結串列中增加

資料結構C++語言實現——圖

圖圖的基本概念圖是資料結構G＝（V，E） V（G）是G中結點的有限非空集合 E（G）是G中邊的有限集合若圖中代表一條邊的偶對是有序的，則稱為有向圖，<u，v>u稱為該邊的始點（尾），v稱為邊的終點（頭）。有向邊也稱為弧。

資料結構 C語言實現直接插入排序

一、直接插入排序簡介每次從無序表中取出第一個元素，把它插入到有序表的合適位置，使有序表仍然有序。第一趟比較前兩個數，然後把第二個數按大小插入到有序表中；第二趟把第三個資料與前兩個數從前向後掃描，把第三個數按大小插入到有序表中；依次進行下去，進行了(

資料結構C語言實現之鏈式佇列的6種演算法程式碼

#include <stdio.h>#include <stdlib.h>typedef int elemType;/************************************************************************//* 以下是關於佇列連

資料結構c語言版之順序表的刪除

#include<stdio.h> #include<stdlib.h> #define MAX 100 typedef struct { int data[MAX]; int last; }seqlist

[資料結構]c語言實現鏈棧的入棧，出棧，清空，銷燬等操作

最近在學習資料結構中的棧，於是在此記錄一下棧鏈式結構的抽象資料型別 /* 棧的抽象資料型別 ADT 棧(stack) Data 同線性表。元素具有相同的型別，相鄰元素具有前驅和後繼關係 Operation InitStack(*S)：初始化

資料結構 C語言線性表順序表實現2

話不多說，先上main函式流程圖 main流程圖方便看程式進行狀態。原本是想將所有的基礎資料結構寫完以後再傳的，可我等不及了，不寫點東西就感覺啥都沒做一樣。將程式碼集中在一個檔案了，方便傳送和閱讀一些。 #include <stdio.h> #include <stri

資料結構c語言版嚴蔚敏順序線性表12個基本操作及演算法的實現

標頭檔案： c1.h （相關標頭檔案及函式結果狀態程式碼集合） /* c1.h (程式名) */ #include<string.h> #include<ctype.h> #include<malloc.h> /

資料結構線性表順序結構c語言實現程式碼

#include<stdio.h> #include<stdlib.h> typedef int ElementType; typedef struct LNode * PtrToLNode; struct LNode{ ElementType D

資料結構 C語言線性表順序表實現

#include<stdio.h> #include<stdlib.h > /* C提供三種預處理。巨集定義、檔案包含、條件編譯。巨集定義:又稱為巨集代換、巨集替換，簡稱“巨集”。巨集定義格式：#define 識別符號字串檔案包含:#include<***

資料結構(C語言版嚴蔚敏著)——線性表

線性表定義：由零個或多個數據元素組成的有限序列。 · 需注意幾個關鍵點： -它是一個序列，也就是說元素之間是有先來後到的。 -若元素存在多個，則第一個元素無前驅，而最後一個元素無後繼，其他元素有且只有一個前驅和一個後繼。 -線性表強調是有限的，無論計算機發展到多強大，

資料結構C語言實現-2—線性表

線性表順序儲存結構

線性錶鏈式儲存結構

靜態連結串列

相關推薦