线性表的链式存储结构

最新推荐文章于 2021-01-27 21:17:13 发布
原创 最新推荐文章于 2021-01-27 21:17:13 发布 · 411 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了线性表的链式存储结构，包括数据域、指针域、节点定义和头结点的概念。讨论了单链表的尾插和尾删操作，以及插入和删除的基本步骤，涵盖了不同情况下的处理策略，帮助理解链表的动态操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

       前面介绍过，线性表分为两种（顺序表和链表），它们各有优缺。对于顺序表而言，对元素遍历以及寻找是相当便利的，但是它最大的缺点就是在插入和删除某个元素时需要移动大量数据，这显然要耗费时间，后来发现链式存储结构恰好能解决这个问题。

      在顺序结构中，只需要将数据元素信息存储就好了，但是在链式结构中除了要存数据元素信息外，还要存储它的后继元素的存储地址。下来总结一些有关链式存储结构的小知识：

(1)数据域：把存储数据元素信息的域称为数据域；

(2)指针域：把存储直接后继位置的域称为指针域，指针域中存储的信息称为指针或链；

(3)结    点：数据域和指针域这两部分信息组成某个数据元素的存储映像，称为结点；

(4)头结点：在单链表的第一个结点前附设的一个结点(只是为了方便对链表进行操作)；

(5)头结点的特点：其数据域可以不存储任何信息，头结点的指针域存储指向第一个结点的指针，如下图。


下面介绍一些单链表的基本操作：

void PushBack(pLinkList pList,DataType x); //在链表尾插
void PopBack(pLinkList pList);             //尾删
void PushFront(pLinkList pList,DataType x);//头插
void PopFront(pLinkList pList);             //头删
void PrintList(pLinkList pList);           //打印链表
void Insert(pLinkList pList,pLinkNode pos,DataType x);  //在指定位置插入元素x
void Erase(pLinkList pList,pLinkNode pos); //删除指定位置的元素
void Remove(pLinkList pList,DataType x);   //删除一个元素X
void RemoveAll(pLinkList pList,DataType x);//删除所有元素x
void Bubble(pLinkList pList);              //对链表进行排序

(1)尾插：进行尾插时我们需要考虑以下几点

@空链表时，将新开辟的节点赋值给头指针所指向的下一结点，并将尾插结点的指针域置为空即可；

@有节点的情况下，先找到链表的尾部然后进行插入。如下图所示：

代码实现：

void PushBack(pLinkList pList,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL;
	assert(pList);
	NewNode=CreateNode(x);
	cur = pList->pHead;
	if(NULL==pList->pHead)         //空链表情况
	{
       pList->pHead=NewNode;
	   NewNode->next=NULL;
	   return;
	}
	while(cur->next!=NULL)          //找到最后一个节点
	{
		cur=cur->next;
	}
	cur->next=NewNode;
}


2.尾删

@空链表情况直接返回；

@只有一个节点的情况;

@大于1个节点，一种方法是在找最后一个结点的时候将它的前一个结点保存下来，因为在删除后我们需要将目前倒数第二个结点的指针域置为空；另一种方法就是不需要记录它的前一个结点，我们只需要通过cur指针找到链表的倒数第二个结点就可以了，再通过倒数第二个结点的指针域找到最后一个结点；

void PopBack(pLinkList pList)
{
   pLinkNode cur = NULL;
   assert(pList);
   cur=pList->pHead;
if(NULL==pList->pHead)         
{
    return ;
}
else
{
	if(NULL==cur->next)     
	{
            free(cur);
	    pList->pHead=NULL;
	}
	else
	{
		//大于1个节点，先找到倒数第二个节点
		while(cur->next->next!=NULL)      
		{
		   cur=cur->next;
		}
		free(cur->next);      
		cur->next=NULL;
	}
}
}
3.头插

@链表为空；

@有节点的情况，改变指针域的指向。

void PushFront(pLinkList pList,DataType x)
{
	//1.空链表情况
	//2.有节点的情况
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL:
	NewNode=CreateNode(x);
	assert(pList);
	cur = pList->pHead;
	if(NULL==pList->pHead)         
	{
           pList->pHead=NewNode;
	   NewNode->next=NULL;
	   return;
	}
	   NewNode->next=cur;       //有节点的情况
	   pList->pHead=NewNode;   
	   printf("PushFront successfully!\n");
}

4.头删

@空链表直接返回；

@有节点情况改变指针指向。


void PopFront(pLinkList pList)
{
	//1.空链表情况
	//2.有节点的情况
	pLinkNode cur = NULL;
	pLinkNode del = NULL;
	assert(pList);
	if(NULL==pList->pHead)         
	{
        return ;
	}
	else
	{
		cur=pList->pHead->next;
		del=pList->pHead;
		free(del);
		pList->pHead=cur;
	}
	printf("PopFront successfully!\n");
}
5.在指定位置插入某个元素

@插入时先创建新节点，然后就是改变指针指向问题；

@在指定位置插入时又分为两种情况，在指定位置前插入和指定位置后插入。

void InsertFront(pLinkList pList,pLinkNode pos,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL;
	assert(pList);
	NewNode=CreateNode(x);
	cur=pList->pHead;
	if(NULL==cur)
	{
		PushFront(pList,x);
	}
	else
	{
		while(cur!=pos)
		{
			cur=cur->next;
		}
		NewNode->next=cur->next;
		cur->next=NewNode;
	}
}
void InsertBack(pLinkList pList,pLinkNode pos,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL;
	assert(pList);
	NewNode=CreateNode(x);
	cur=pList->pHead;
	if(NULL==cur)
	{
		PushFront(pList,x);
	}
	else
	{
		while(cur->next!=pos)
		{
			cur=cur->next;
		}
		NewNode->next=cur->next;
		cur->next=NewNode;
	}
}
6.删除

@删除函数又分为删除第一次查找到的指定元素和删除所有指定元素；

@删除时需要考虑空链表，有一个节点和多个节点的情况；有一个节点时先进行判断是否是指定要删除的对象，对于多个节点问题先要看一个特殊情况，如果要删除的对象就是首节点只需要将头指针指向原来第二个节点的位置，否则要进行遍历查找到要删除的对象，删除所有指定元素也是类似的。

void Remove(pLinkList pList,DataType x)
{
	pLinkNode cur=NULL;
	pLinkNode prev=NULL;
	pLinkNode del=NULL;
	assert(pList);
	cur=pList->pHead;
	prev=pList->pHead;
	if(NULL==pList->pHead)   //空链表
	{
		return;
	}
	if(NULL==cur->next)    //只有一个节点
	{
		if(cur->data==x)
		{
			free(cur->next);
			pList->pHead=NULL;
			return;
		}
	}
	else
	{
	   while(cur!=NULL)
	   {
		   if(cur->data==x)
		   {
			   del=cur;
			   pList->pHead=cur->next;
			   free(del);
			   return;
		   }
		   cur=cur->next;
		   while(cur!=NULL)
		   {
			   if(cur->data==x)
			   {
				   prev->next=cur->next;
				   free(cur);
				   return;
			   }
			   prev=cur;
			   cur=cur->next;
	}
}
void RemoveAll(pLinkList pList,DataType x)
{
	pLinkNode cur=NULL;
	pLinkNode prev=NULL;
	assert(pList);
	cur=pList->pHead;
	prev=pList->pHead;
	if(NULL==pList->pHead)
	{
		return;
	}
	while(cur!=NULL)
	{
       while(NULL==cur->next)
	   {
		   if(cur->data==x)
		   {
			free(cur->next);
			pList->pHead=NULL;
			return;
		   }
		   if(pList->pHead->data==x)
		   {
			   pList->pHead=cur->next;
			   free(cur);
			   cur=pList->pHead;
		   }
	   }
	}
	cur=cur->next;
	prev=pList->pHead;
	while(cur)
	{
		if(cur->data==x)
		{
			prev->next=cur->next;
			free(cur);
		    cur=prev;
		}
		prev=cur;
		cur->next;
	}
}
7.删除指定位置的元素 

void Erase(pLinkList pList,pLinkNode pos)
{
	pLinkNode cur=NULL;
	pLinkNode prev=NULL;
	pLinkNode del=NULL;
	assert(pList);
	cur=pList->pHead;
	prev=pList->pHead;
	if(NULL==pList->pHead)   //空链表
	{
		return;
	}
	if(NULL==cur->next)
	{
		if(cur==pos)        //只有一个节点且这个节点就是pos位置
		{
			free(pList->pHead);
			pList->pHead=NULL;
		}
		return;
	}
	if(cur==pos)        //多个节点时首节点就是pos位置
	{
		del=cur;
		pList->pHead=cur->next;
		free(del);
		return;
	}
	cur=cur->next;
	while(cur)
	{
		if(cur==pos)
		{
			prev->next=cur->next;
			free(cur);
			return;
		}
		prev=cur;
		cur=cur->next;
	}
}
8.对链表进行排序 

void BubbleSort(pLinkList pList)
{
	pLinkNode cur=NULL;
	pLinkNode tail=NULL;
	DataType tmp=0;
	assert(pList);
	cur=pList->pHead;
	if(NULL==pLinkList->pHead||NULL==pLinkList->pHead->next)
	{
		return;
	}
	while(cur!=tail)
	{
		while(cur->next!=tail)
		{
			if((cur->data )> (cur->next->data))
			{
				tmp=cur->data;
				cur->data=cur->next->data;
				cur->next->data=tmp;
			}
			cur=cur->next;    //cur向后移动进行下一次冒泡
		}
		tail=cur;            // 排序一趟tail指针向前走一个直至cur=tail排序完成              
		cur=pList->pHead;   //保证每次的外层循环从首节点开始
	}
}


对链表的一些重要操作描述完后给出完整代码方便阅读：

LinkList.h

#ifdef _LINKLIST__H_
#define _LINKLIST__H_

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

enum OP  
{  
    EXIT,  
    PUSHBACK,  
    POPBACK,  
    PUSHFRONT,  
    POPFRONT,
	INSERT, 
	REMOVE,  
    REMOVEALL,  
    ERASE,  
    SORT, 
    PRINT    
};  

typedef int DataType;

typedef struct LinkNode
{
	DataType data;
	struct LinkNode *next;
}LinkNode,*pLinkNode;
typedef struct LinkList
{
	pLinkNode pHead; 
}LinkList,*pLinkList;


void InitLinkList(pLinkList pList);       //初始化链表
void PrintLinkList(pLinkList pList);     //打印链表
void DestroyLinkList(pLinkList pList);  //销毁链表
void PushBack(pLinkList pList,DataType x);   //尾插
void PopBack(pLinkList pList);               //尾删
void PushFront(pLinkList pList,DataType x);  //前插
void PopFront(pLinkList pList);              //前删
pLinkNode FindNode(pLinkList pList,DataType x);  //找节点
void Insert(PlinkList pList,pLinkNode pos,DataType x);  //在特定位置插入x元素
void Erase(PlinkList pList,pLinkNode pos);              //在特定位置删除x元素
void Remove(pLinkList pList,DataType x);                //删除链表中第一次出现的x元素
void RemoveAll(pLinkList pList,DataType x);             //删除链表中所有x元素
void BubbleSort(pLinkList pList)；                      //对链表进行冒泡排序
void menu();

#endif

LinkList.c 

#include"LinkList.h"
void InitLinkList(pLinkList pList) 
{
	assert(pList);
	pList->pHead=NULL;
}
void PrintLinkList(pLinkList pList)
{
	pLinkNode cur=NULL;
	assert(pList);
	cur=pList->pHead;
	while(NULL!=cur)
	{
		printf("%d->",cur->data);
		cur=cur->next;
	}
	printf("over\n");
}
void DestroyLinkList(pLinkList pList) 
{
    pLinkNode prev = NULL;
    pLinkNode cur =NULL;
    assert(pList);
	cur = pList->pHead;
    if (NULL == pList->pHead)           //空链表的情况
    {
        return;
    }
    while (cur != NULL)
    {
        prev = cur;
        cur = cur->next;
        free(prev);
    }
    pList->pHead = NULL;

}
pLinkNode CreateNode(DataType x)
{
	pLinkNode NewNode=NULL;
	NewNode=(pLinkNode)malloc(sizeof(LinkNode));
	if(NULL==NewNode)
	{
		printf("out of memory\n");
		exit(1);
	}
	NewNode->data=x;
	NewNode->next=NULL;
	return NewNode;
}
void PushBack(pLinkList pList,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL;
	assert(pList);
	NewNode=CreateNode(x);
	cur = pList->pHead;
	if(NULL==pList->pHead)         //空链表情况
	{
       pList->pHead=NewNode;
	   NewNode->next=NULL;
	   return;
	}
	while(cur->next!=NULL)          //找到最后一个节点
	{
		cur=cur->next;
	}
	cur->next=NewNode;
}
void PopBack(pLinkList pList)
{
pLinkNode cur = NULL;
assert(pList);
cur=pList->pHead;
if(NULL==pList->pHead)         
{
    return ;
}
else
{
	if(NULL==cur->next)     
	{
        free(cur);
		pList->pHead=NULL;
	}
	else
	{
		//大于1个节点，先找到倒数第二个节点
		while(cur->next->next!=NULL)      
		{
			cur=cur->next;
		}
		free(cur->next);      
		cur->next=NULL;
	}
}
}
void PushFront(pLinkList pList,DataType x)
{
	//1.空链表情况
	//2.有节点的情况
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL:
	NewNode=CreateNode(x);
	assert(pList);
	cur = pList->pHead;
	if(NULL==pList->pHead)         
	{
       pList->pHead=NewNode;
	   NewNode->next=NULL;
	   return;
	}
	   NewNode->next=cur;       //有节点的情况
	   pList->pHead=NewNode;   
	   printf("PushFront successfully!\n");
}
void PopFront(pLinkList pList)
{
	//1.空链表情况
	//2.有节点的情况
	pLinkNode cur = NULL;
	pLinkNode del = NULL;
	assert(pList);
	if(NULL==pList->pHead)         
	{
        return ;
	}
	else
	{
		cur=pList->pHead->next;
		del=pList->pHead;
		free(del);
		pList->pHead=cur;
	}
	printf("PopFront successfully!\n");
}
pLinkNode FindNode(pLinkList pList,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode find = NULL;
	assert(pList);
	cur =pList->pHead;
	while(cur!=NULL)
	{
		if(cur->data==x)
		{
			return cur;
		}
		cur=cur->next;
	}
	return NULL;
}
void InsertFront(pLinkList pList,pLinkNode pos,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL;
	assert(pList);
	NewNode=CreateNode(x);
	cur=pList->pHead;
	if(NULL==cur)
	{
		PushFront(pList,x);
	}
	else
	{
		while(cur!=pos)
		{
			cur=cur->next;
		}
		NewNode->next=cur->next;
		cur->next=NewNode;
	}
}
void InsertBack(pLinkList pList,pLinkNode pos,DataType x)
{
	pLinkNode cur = NULL;
	pLinkNode NewNode=NULL;
	assert(pList);
	NewNode=CreateNode(x);
	cur=pList->pHead;
	if(NULL==cur)
	{
		PushFront(pList,x);
	}
	else
	{
		while(cur->next!=pos)
		{
			cur=cur->next;
		}
		NewNode->next=cur->next;
		cur->next=NewNode;
	}
}

void Erase(pLinkList pList,pLinkNode pos)
{
	pLinkNode cur=NULL;
	pLinkNode prev=NULL;
	pLinkNode del=NULL;
	assert(pList);
	cur=pList->pHead;
	prev=pList->pHead;
	if(NULL==pList->pHead)   //空链表
	{
		return;
	}
	if(NULL==cur->next)
	{
		if(cur==pos)        //只有一个节点且这个节点就是pos位置
		{
			free(pList->pHead);
			pList->pHead=NULL;
		}
		return;
	}
	if(cur==pos)        //多个节点时首节点就是pos位置
	{
		del=cur;
		pList->pHead=cur->next;
		free(del);
		return;
	}
	cur=cur->next;
	while(cur)
	{
		if(cur==pos)
		{
			prev->next=cur->next;
			free(cur);
			return;
		}
		prev=cur;
		cur=cur->next;
	}
}
void Remove(pLinkList pList,DataType x)
{
	pLinkNode cur=NULL;
	pLinkNode prev=NULL;
	pLinkNode del=NULL;
	assert(pList);
	cur=pList->pHead;
	prev=pList->pHead;
	if(NULL==pList->pHead)   //空链表
	{
		return;
	}
	if(NULL==cur->next)    //只有一个节点
	{
		if(cur->data==x)
		{
			free(cur->next);
			pList->pHead=NULL;
			return;
		}
	}
	else
	{
	   while(cur!=NULL)
	   {
		   if(cur->data==x)
		   {
			   del=cur;
			   pList->pHead=cur->next;
			   free(del);
			   return;
		   }
		   cur=cur->next;
		   while(cur!=NULL)
		   {
			   if(cur->data==x)
			   {
				   prev->next=cur->next;
				   free(cur);
				   return;
			   }
			   prev=cur;
			   cur=cur->next;
	}
}
void RemoveAll(pLinkList pList,DataType x)
{
	pLinkNode cur=NULL;
	pLinkNode prev=NULL;
	assert(pList);
	cur=pList->pHead;
	prev=pList->pHead;
	if(NULL==pList->pHead)
	{
		return;
	}
	while(cur!=NULL)
	{
       while(NULL==cur->next)
	   {
		   if(cur->data==x)
		   {
			free(cur->next);
			pList->pHead=NULL;
			return;
		   }
		   if(pList->pHead->data==x)
		   {
			   pList->pHead=cur->next;
			   free(cur);
			   cur=pList->pHead;
		   }
	   }
	}
	cur=cur->next;
	prev=pList->pHead;
	while(cur)
	{
		if(cur->data==x)
		{
			prev->next=cur->next;
			free(cur);
		    cur=prev;
		}
		prev=cur;
		cur->next;
	}
}
void BubbleSort(pLinkList pList)
{
	pLinkNode cur=NULL;
	pLinkNode tail=NULL;
	DataType tmp=0;
	assert(pList);
	cur=pList->pHead;
	if(NULL==pLinkList->pHead||NULL==pLinkList->pHead->next)
	{
		return;
	}
	while(cur!=tail)
	{
		while(cur->next!=tail)
		{
			if((cur->data )> (cur->next->data))
			{
				tmp=cur->data;
				cur->data=cur->next->data;
				cur->next->data=tmp;
			}
			cur=cur->next;    //cur向后移动进行下一次冒泡
		}
		tail=cur;            // 排序一趟tail指针向前走一个直至cur=tail排序完成              
		cur=pList->pHead;   //保证每次的外层循环从首节点开始
	}
}
void menu()
{
	printf("***********LinkList***************\n");
	printf("*****0.Exit********1.Init*********\n");
        printf("*****2.PushBack*****3.PopBack*****\n");
	printf("*****4.PushFront*****5.PopFront***\n");
	printf("*****6.Insert****7.Erase**********\n");
	printf("*****8.Remove*******9.RemoveAll***\n");
	printf("*****10.BubbleSort*****11.Print***\n");
}





test.c

#include"LinkList.h"
void test()
{
    LinkList list;  
    pLinkNode pos = NULL;  
    InitLinkList(&list);  
    int input = 1;  
    DataType x = 0; 
    DataType y = 0; 
    while (input)  
    {  
        menu();  
        printf("please your choice:");  
        scanf("%d",&input);  
        switch (input)  
        {  
        case EXIT:  
            DestroyLinkList(&list);  
            break;  
        case PUSHBACK:  
            printf("please input a number of insertion:");  
            scanf("%d",&x);  
            PushBack(&list, x);  
            break;  
        case POPBACK:  
            PopBack(&list);  
            break;  
        case PUSHFRONT:  
            printf("please input a number of insertion:");  
            scanf("%d", &x);  
            PushFront(&list, x);  
            break;  
        case POPFRONT:  
            PopFront(&list);  
            break; 
	case INSERT:  
            printf("please input a number of insertion:");  
            scanf("%d", &x);  
            printf("please input a number of the data of pos:");  
            scanf("%d", &y);   
            pos = Find(&list, x);
	    InsertFront(&list,pos,x);
	    InsertBack(&list,pos,x);
	    break;
        case REMOVE:  
            printf("please input a number of delete:");  
            scanf("%d", &x);  
            Remove(&list, x);  
            break;
	case REMOVEALL:  
            printf("please input a number of delete:");  
            scanf("%d", &x);  
            RemoveAll(&list, x);  
            break;  
	case ERASE:  
            printf("please input a number of delete:");  
            scanf("%d", &x);  
            pos = find(&list,x);  
            Erase(&list, pos);  
            break;
        case SORT:  
            BubbleSort(&list);  
            break;    
        case PRINT:  
            PrintLinkList(&list);  
            break;    
        }  
    } 
}
int main()
{
	test();
	system("pause");
	return 0;
}










【数据结构】CH2 线性表的链式存储结构
m0_72318954的博客
09-26 833
线性表的链式存储结构
线性表的链式存储结构和实现
leecam的博客
05-22 1089
若front指向最后一个结点，有front.next=null，在front结点后插入一个结点，也可执行上述中间插入程序段，所以尾插入是中间插入的特例，中间插入或尾插入都不会改变单链表的头指针head。线性表采用链式存储结构，称为线性链表（Linked List），逻辑上相邻的元素是分散存储的，因此必须采用指针变量记载前驱或者后继元素的地址，来存储元素之间的线性关系。遍历单链表时从第0个结点开始，沿着结点的next链，依次访问单链表中每个结点，并且每个结点只访问一次。结点（结点域，地址域）
线性表链式存储结构
kingvingjames的博客
01-27 519
前言 前面复习完了线性表。这里略微进行优缺点的分析。优点很明显，其是一个数组，数组操作简便，分析较为容易。那缺点呢？实则也很明显，事先不知道数据大小的时候只能往大的空间开，插入删除操作伴随着大量数据的移动。 （当然了自己测试的都是些小数据） 针对以上的缺点，一种名为“链表”的神奇物种就诞生了！ 怎么解决的这么多弱点呢，请听下面分解。 啊对了，这之后需要稍微停更一会，要先把实习DEHAZE的算法流程图做完还要讨论可实施性。 一、学习目标： 了解链表的定义，掌握链表的基本操作，基本的时间复杂度。 学习内容：
数据结构实验报告2线性表的链式存储结构.pdf
09-30
本实验报告详细介绍了线性表的链式存储结构，通过编程实践深入理解了链表的逻辑结构、基本操作以及链表算法的实现过程。 线性表作为一种常见的数据结构，其特点是元素之间存在一对一的线性关系。线性表中数据元素...
数据结构实验报告2线性表的链式存储结构.doc
07-11
实验报告的主题是“线性表的链式存储结构”，它主要涵盖了线性表的基本概念、链式存储方式以及相关的操作，如初始化、插入、删除、查找等。线性表是一种基本的数据结构，它是由n（n>=0）个相同类型元素构成的有限...
关于线性表的顺序存储和链式存储结构的实验报告
06-15
在数据结构实验报告中，线性表的存储结构被分为两大类：顺序存储结构和链式存储结构。 顺序存储结构（Sequential Storage Structure）是将线性表中的元素按顺序存储在一个连续的内存空间中。线性表的顺序存储结构...
线性表的链式存储结构..
07-11
实验二 线性表的链式存储结构 题目：设计并实现以下算法：给出用单链表存储多项式的结构，利用后接法生成多项式的单链表结构，实现两个多项式相加的运算，并就地逆置相加后的多项式链式。1. 用户可以根据自己的需求...
线性链表的链式存储结构
weixin_42164310的博客
03-10 689
数据结构之线性表 2.线性表的链式存储结构 线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的。 在链式结构中，除了要存储数据元素信息外，还要存储它的后继元素的存储地址。 为了表示每个数据元素ai与其直接后继数据元素ai+1之间的逻辑关系，对数据元素ai来说，除了存储其本身的信息之外，还需存储一个指示其直接后继的存储位置。把存储数据元素...
线性链表的顺序存储结构
GaoChuang_的博客
04-10 1118
线性表（List）        线性表 是数据元素的有序的并且有限的集合，线性表中的数据元素必须是同种类型的；        线性表的常用操作：                                          1.创建线性表                                      List*   List_Creat(
线性表的链式存储结构详解
Fern123g的博客
09-28 2359
前言：为什么会出现线性表的链式存储结构呢？因为顺序存储结构是采用一块连续的存储单元存储线性表，在对线性表进行插入删除时非常不方便，为了解决顺序存储结构中的这个缺点，于是人们就想能不能采用一种不连续的存储方式，哪里有空位就到哪里去，能够通过第一个元素依次找到其后的各个元素，于是就产生了链式存储结构 1、定义 链式存储结构采用一组任意的存储单元存储线性表（可以连续可以不连续）；n个结点链成一条链表 2、分类 链表分为单链表，双链表，静态链表，循环链表 3、易混淆点 （1）结点有数据域和指针域构成，next指针域
线性表的单链表存储结构
dadalan的专栏
09-05 2089
 // c2-2.h 线性表的单链表存储结构 struct LNode {   ElemType data;   LNode *next; }; typedef LNode *LinkList; // 另一种定义LinkList的方法 // bo2-2.cpp 单链表线性表(存储结构由c2-2.h定义)的基本操作(12个) Status InitList(LinkList &L) { // 操
数据结构二线性链表的链式存储结构
FreeBird的专栏
02-19 524
#include #include #define ERROR 0 #define OK 1 using namespace std; typedef int ElemType; typedef int status; typedef struct Node { ElemType data; struct Node *next; }Node; typedef
线性表的链式存储结构（菜鸟问题）
keepupblw的专栏
05-11 622
#include #include /*线性表的链式存储结构*/ #define OK 1 #define ERROR -1 typedef int ElemType; typedef int Status; typedef struct { //链式存储结构有哪些要素？ //每个元素有数据项和指针域 ElemType data; struct Node *
线性表之栈的链式存储实现
sinat_39061823的博客
07-10 327
栈的链式存储也称为链栈，和链表的存储原理一样，都可以通闲散空间来存储元素，用指针来建立各节点之间的逻辑关系。同顺序栈，链表的插入，删除操作也只能在栈顶进行。 链栈的C语言实现：（codeblocks完美运行） #include #include typedef struct Node { int data; //数据域
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值