链表介绍

转载 2018年04月17日 00:40:33

介绍

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


和顺序表的区别:

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

代码实现

  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;  

链表的简单介绍

链表是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。由于链表的结构很简单,它由指针把若干个结点连接成链状结构,所以链表应该是面试时被提及最频繁的数据结...
  • Lovter_
  • Lovter_
  • 2016-10-09 19:38:37
  • 685

HashMap小结

hashMap是一种采用哈希算法的数组和链表相结合的数据结构。可能和其他的文章的不同, 我这儿分析hashmap都是一些自己的看法。在HashMap构造 函数中存在着两个参数一个是容量一个是负载因子,...
  • yinte12
  • yinte12
  • 2016-04-28 14:31:41
  • 515

单链表的所有操作list

#include #include typedef struct _list { int m_data;//成员变量 struct _list * next;//结构体调用自己的...
  • CHNIM
  • CHNIM
  • 2016-06-26 18:20:23
  • 964

用C++实现链表的操作

  • 2010年08月04日 15:21
  • 5KB
  • 下载

链表函数 (接口实现)范例

头文件(函数接口,链表类型定义)typedef struct node* link; struct node { int item; link next; }; typedef link No...
  • MACHINE_128
  • MACHINE_128
  • 2018-02-28 13:25:56
  • 17

拉链表简介

拉链表简介(转载,以mysql为例)在数据仓库中,经常会用历史数据和时间维度做数据分析。而保存历史数据最常见的方案是使用拉链表进行存储。首先创建测试表:create table deal_order ...
  • baidu_21088863
  • baidu_21088863
  • 2017-09-02 18:06:25
  • 933

真TM通俗易懂(链表、指针)

->是一个整体,它是用于指向结构体、C++中的class等含有子数据的指针用来取子数据。换种说法,如果我们在C语言中定义了一个结构体,然后申明一个指针指向这个结构体,那么我们要用指针取出结构体中的数据...
  • WDD_root
  • WDD_root
  • 2015-03-29 14:57:27
  • 852

Java学习之栈,队列,数组,链表

一、栈 特点:先进后出 二、队列 特点:先进先出 三、数组 特点:查询快,增删慢 int[] a={}; 四、链表 概念:通过一个链子把多个结点(元素)连接起来,由数据和地址组...
  • RookieThree
  • RookieThree
  • 2017-05-02 20:11:24
  • 140
收藏助手
不良信息举报
您举报文章:链表介绍
举报原因:
原因补充:

(最多只允许输入30个字)