图解线性表的链式存储

 

 

 

 

#ifndef _MYLINKLIST_H_
#define _MYLINKLIST_H_

//链表
typedef void LinkList;

//链表节点
typedef struct _tag_LinkListNode
{
	struct _tag_LinkListNode *next;
}LinkListNode;


LinkList* LinkList_Create();

void LinkList_Destroy(LinkList* list);

void LinkList_Clear(LinkList* list);

int LinkList_Length(LinkList* list);

int LinkList_Insert(LinkList* list, LinkListNode* node, int pos);

//获取pos位置的节点 (pos从0开始)
LinkListNode* LinkList_Get(LinkList* list, int pos);

LinkListNode* LinkList_Delete(LinkList* list, int pos);

#endif

 

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "knDebug.h"
#include "knLinklist.h"

/*
	1、指针指向谁就把谁的地址赋给指针
	2、分清楚 链表的操作逻辑和辅助指针变量之间的关系
	3、结构体的首地址跟结构体中的第一个域的地址相同

	优点：
		无需一次性定制链表的容量
		插入和删除操作无需移动数据元素
	缺点：
		数据元素必须保存后继元素的位置信息
		获取指定数据的元素操作需要顺序访问之前的元素

	适用场景：
	对于插入或者删除数据越频繁的操作,单链表的效率优势就越是明显
	
	对于插入和删除操作的算法，就2步：
		step1 遍历查找pos位置的元素, 时间复杂度为o(n)
		step2 插入和删除操作       ,时间复杂度为o(1)


*/

//创建一个带有头结点的链表
//结点 = 指针域+数据域

//头结点
typedef struct _tag_LinkList
{
	LinkListNode header;	//头指针
	int length;				//链表的实际长度(附加信息)
}TLinkList;

//创建头结点
LinkList* LinkList_Create()
{
	TLinkList *ret = (TLinkList*)malloc(sizeof(TLinkList));
	if (ret == NULL)
	{
		return NULL;
	}
	ret->header.next = NULL;		//头指针
	ret->length = 0;				//链表长度
	return ret;
}

void LinkList_Destroy(LinkList* list)
{
	if (list == NULL){
		return;
	}
	free(list);
	return;
}

void LinkList_Clear(LinkList* list)
{
	TLinkList *tList = NULL;
	if (list == NULL){
		return;
	}
	tList = (TLinkList*)list;
	tList->header.next = NULL;
	tList->length = 0;
	return;
}

int LinkList_Length(LinkList* list)
{
	TLinkList *tList = NULL;
	if (list == NULL){
		return -1;
	}
	tList = (TLinkList *)list;
	return tList->length;
}


int LinkList_Insert(LinkList* list, LinkListNode* node, int pos)
{
	int i = 0;
	int ret = 0;
	TLinkList *tList = NULL;
	LinkListNode *current = NULL;

	if (list == NULL || node == NULL || pos < 0){
		ret = -1;
		DEBUG("func LinkList_Insert() err: %d\n", ret);
		return ret;
	}
	tList = (TLinkList*)list;
	//辅助指针变量指向链表头结点
	current = &tList->header;
	for (i = 0; i < pos && (current->next != NULL); i++){
		current = current->next;
	}
	//node连接后续结点
	node->next = current->next;
	//当前节点连接node节点
	current->next = node;
	tList->length++;
	return ret;
}

//获取pos位置的节点
LinkListNode* LinkList_Get(LinkList* list, int pos)
{
	int i = 0;
	TLinkList *tList = NULL;
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;

	tList = (TLinkList *)list;
	if (list == NULL || pos < 0 || pos >= tList->length){
		DEBUG("list == NULL || pos < 0 || pos >= tList->length");
		return NULL;
	}
	//让辅助指针变量指向链表头结点
	current = &tList->header;
	for (i = 0; i < pos && (current->next != NULL); i++){
		current = current->next;//获取3号元素,只需拿到2号位置即可
	}
	ret = current->next;
	return ret;
}

//删除pos位置的节点
LinkListNode* LinkList_Delete(LinkList* list, int pos)
{
	int i = 0;
	TLinkList *tList = NULL;
	LinkListNode *current = NULL;
	LinkListNode *ret = NULL;
	tList = (TLinkList*)list;
	if (list == NULL || pos < 0 || pos >= tList->length){
		DEBUG("list == NULL || pos < 0 || pos >= tList->length\n");
		return NULL;
	}
	//让辅助指针变量指向头结点
	current = &tList->header;
	for (i = 0; i < pos && (current->next != NULL); i++){
		current = current->next;//获取3号元素,只需要拿到2号位置即可
	}
	ret = current->next;//缓存下来要删除的元素
	current->next = ret->next;
	tList->length--;
	return ret;
}


/*
头结点：
单链表的第一个节点前附设一个结点，成为头结点。
他的数据域可以不存储任何信息,但可以存储线性表的长度等附加信息

头指针与头结点的异同：
头指针：
1、头指针是指链表指向第一个节点的指针,若链表有头结点，则是指向头结点的指针
2、头指针具有标识作用,所以常用头指针冠以链表的名字
3、无论链表是否为空,头指针均不为空。头指针是链表的必要元素

头结点：
1、头结点是为了操作的统一和方便而设立的，放在第一个元素的节点之前,数据域一般
无意义(也可以存放链表的长度)
2、头结点不一定是链表的必要元素
3、有了头结点，对第一元素结点前插入结点和删除第一结点，其操作与其他结点的操作就统一了


*/

 

#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "knDebug.h"
#include "knLinklist.h"

//业务节点 
typedef struct Teacher
{
	LinkListNode node;//头结点 必须在第一个域的位置
	char name[64];
	int age;
}Teacher;

void test()
{
	Teacher t0, t1, t2, t3, t4;
	LinkList *list = NULL;
	int length, i = 0;
	t0.age = 30;
	t1.age = 31;
	t2.age = 32;
	t3.age = 33;
	t4.age = 34;

	list = LinkList_Create();
	length = LinkList_Length(list);

	//业务节点是teacher 和算法分类的 思想
	LinkList_Insert(list, (LinkListNode*)&t1, LinkList_Length(list));//尾插法(在0号位置插入,实际就是头插)
	LinkList_Insert(list, (LinkListNode*)&t2, LinkList_Length(list));//尾插法
	LinkList_Insert(list, (LinkListNode*)&t3, LinkList_Length(list));//尾插法

	LinkList_Insert(list, (LinkListNode*)&t0, 0);//头插法

	//遍历链表 带头结点的链表是从0号位置开始
	for (i = 0; i < LinkList_Length(list); i++){
		Teacher * tmp = (Teacher *)LinkList_Get(list, i);
		if (tmp != NULL){
			printf("%d ", tmp->age);
		}
	}
	printf("\n");
#if 1
	printf("在2号位置插入 34\n");
	//测试插入元素
	LinkList_Insert(list, (LinkListNode*)&t4, 2);
	for (i = 0; i < LinkList_Length(list); i++){
		Teacher * tmp = (Teacher *)LinkList_Get(list, i);
		if (tmp != NULL){
			printf("%d ", tmp->age);
		}
	}
	printf("\n");
#endif

	while (LinkList_Length(list) > 0){
		Teacher *tmp = (Teacher*)LinkList_Delete(list, 0);
		if (tmp != NULL){
			printf("detete age: %d \n", tmp->age);
		}
	}
	LinkList_Destroy(list);
}

int main()
{
	test();
	system("pause");
	return 0;
}