链表介绍

介绍

       链表是一种物理储存单元上非连续、非顺序的储存结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。


和顺序表的区别:

     顺序表使用数组存储线形的元素,其特点是可以随机存取,但是,因为逻辑上相邻的元素物理上也相邻,所以插入删除需要移动元素。链表使用指针链表示线形表元素的逻辑关系,插入和删除只需修改指针,不能随机存取。

代码实现

  1. typedef int DataType;  
  2. typedef struct Node  
  3. {//结构实现  
  4.     DataType data;  
  5.     struct Node* next;     
  6. }Node, *PNode;  
typedef int DataType;
typedef struct Node
{//结构实现
	DataType data;
	struct Node* next;   
}Node, *PNode;


  1. void InitList(PNode* PHead)//初始化  
  2. {  
  3.     assert(PHead);  
  4.     *PHead = NULL;  
  5. }  
  6.   
  7. PNode ByeNode(DataType data)//申请一个结点  
  8. {  
  9.     PNode newNode = NULL;  
  10.     newNode = (PNode)malloc(sizeof(Node));  
  11.     if (NULL == newNode)  
  12.     {  
  13.         printf("out of memory.\n");  
  14.         exit(1);  
  15.     }  
  16.     else  
  17.     {  
  18.         newNode->data = data;  
  19.         newNode->next = NULL;  
  20.     }  
  21.     return newNode;  
  22. }  
  23. void PopBack(PNode* PHead)//尾删  
  24. {  
  25.     assert(PHead);  
  26.     if (NULL == *PHead)  
  27.     {  
  28.         return;  
  29.     }  
  30.     else if(NULL == (*PHead)->next)  
  31.     {  
  32.         PNode TempNode = *PHead;  
  33.         free(TempNode);  
  34.         TempNode = NULL;  
  35.         *PHead = NULL;  
  36.     }  
  37.     else  
  38.     {  
  39.         PNode PCur = *PHead;  
  40.         while (PCur->next->next)  
  41.         {  
  42.             PCur = PCur->next;  
  43.         }  
  44.         PCur->next = NULL;  
  45.     }  
  46. }  
  47.   
  48. void PushBack(PNode* PHead, DataType data)//尾插  
  49. {  
  50.     assert(PHead);  
  51.     if (NULL == *PHead)  
  52.     {  
  53.         *PHead = ByeNode(data);  
  54.     }  
  55.     else  
  56.     {  
  57.         PNode PCur = NULL;  
  58.         PCur = *PHead;  
  59.         while (PCur->next)  
  60.         {  
  61.             PCur = PCur->next;  
  62.         }  
  63.         PCur->next = ByeNode(data);  
  64.     }  
  65. }  
  66.   
  67. void PushFront(PNode *PHead, DataType data)//头插  
  68. {  
  69.     assert(PHead);  
  70.     PNode PreNode = NULL;  
  71.     PNode Node = ByeNode(data);  
  72.     PreNode = *PHead;  
  73.     Node->next = PreNode;  
  74.     *PHead = Node;  
  75. }  
  76.   
  77. void PopFront(PNode *PHead)//头删  
  78. {  
  79.     assert(PHead);  
  80.     PNode PreNode = *PHead;  
  81.     if (NULL == *PHead)  
  82.     {  
  83.         return;  
  84.     }  
  85.     else if (NULL == (*PHead)->next)  
  86.     {  
  87.         *PHead = NULL;  
  88.     }  
  89.     else  
  90.     {  
  91.         *PHead = PreNode->next;  
  92.         free(PreNode);  
  93.         PreNode = NULL;  
  94.     }  
  95. }  
void InitList(PNode* PHead)//初始化
{
	assert(PHead);
	*PHead = NULL;
}

PNode ByeNode(DataType data)//申请一个结点
{
	PNode newNode = NULL;
	newNode = (PNode)malloc(sizeof(Node));
	if (NULL == newNode)
	{
		printf("out of memory.\n");
		exit(1);
	}
	else
	{
		newNode->data = data;
		newNode->next = NULL;
	}
	return newNode;
}
void PopBack(PNode* PHead)//尾删
{
	assert(PHead);
	if (NULL == *PHead)
	{
		return;
	}
	else if(NULL == (*PHead)->next)
	{
		PNode TempNode = *PHead;
		free(TempNode);
		TempNode = NULL;
		*PHead = NULL;
	}
	else
	{
		PNode PCur = *PHead;
		while (PCur->next->next)
		{
			PCur = PCur->next;
		}
		PCur->next = NULL;
	}
}

void PushBack(PNode* PHead, DataType data)//尾插
{
	assert(PHead);
	if (NULL == *PHead)
	{
		*PHead = ByeNode(data);
	}
	else
	{
		PNode PCur = NULL;
		PCur = *PHead;
		while (PCur->next)
		{
			PCur = PCur->next;
		}
		PCur->next = ByeNode(data);
	}
}

void PushFront(PNode *PHead, DataType data)//头插
{
	assert(PHead);
	PNode PreNode = NULL;
	PNode Node = ByeNode(data);
	PreNode = *PHead;
	Node->next = PreNode;
	*PHead = Node;
}

void PopFront(PNode *PHead)//头删
{
	assert(PHead);
	PNode PreNode = *PHead;
	if (NULL == *PHead)
	{
		return;
	}
	else if (NULL == (*PHead)->next)
	{
		*PHead = NULL;
	}
	else
	{
		*PHead = PreNode->next;
		free(PreNode);
		PreNode = NULL;
	}
}


  1. PNode Find(PNode* PHead, DataType data)//查找  
  2. {  
  3.     assert(PHead);  
  4.     PNode PCur = *PHead;  
  5.     while (PCur)  
  6.     {  
  7.         if (data == PCur->data)  
  8.             break;  
  9.         PCur = PCur->next;  
  10.     }  
  11.     return PCur;  
  12. }  
  13.   
  14. void Destroy(PNode* PHead)//销毁  
  15. {  
  16.     assert(PHead);  
  17.     PNode PCur = *PHead;  
  18.     while (PCur->next)  
  19.     {  
  20.         PNode Dnode = PCur;  
  21.         PCur = PCur->next;  
  22.         free(Dnode);  
  23.         Dnode = NULL;  
  24.     }  
  25. }  
  26.   
  27. int Empty(PNode PHead)//判空  
  28. {  
  29.     if (NULL == PHead)  
  30.         return 0;  
  31.     else  
  32.         return 1;  
  33. }  
  34.   
  35. int Size(PNode PHead)//求链表中结点的个数  
  36. {   
  37.     PNode Node = PHead;  
  38.     DataType num = 0;  
  39.     while (Node)  
  40.     {  
  41.         num++;  
  42.         Node = Node->next;  
  43.     }  
  44.     return num;  
  45. }  
  46.   
  47. void PrintList(PNode* PHead)//打印单链表  
  48. {  
  49.     PNode PCur = *PHead;  
  50.     assert(PHead);  
  51.     while (PCur)  
  52.     {  
  53.         printf("%d->",PCur->data);  
  54.         PCur = PCur->next;  
  55.     }  
  56.     printf("NULL\n");  
  57. }  
  58.   
  59. void Insert(PNode pos, DataType data)//在data后插入结点  
  60. {  
  61.     PNode newNode = ByeNode(data);  
  62.     PNode PreNode = pos;  
  63.     newNode->next = PreNode->next;  
  64.     PreNode->next = newNode;  
阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页