数据结构之链式表

链式表是一种常见的基础数据结构，它通过指针将一组零散的内存块按线性的顺序连接起来，形成一个线性表。

链式表可以分为单向链表、双向链表和循环链表三种基本形式。其中，单向链表每个节点只有一个指向下一个节点的指针；双向链表每个节点有两个指针，一个指向前一个节点，一个指向后一个节点；循环链表与单向或双向链表类似，不同之处在于链表的尾节点指向链表的头节点，形成一个循环。

链式表有以下优点：

1. 支持动态增加和删除节点，不需要预先指定容量；
2. 可以很容易地实现链表元素的插入和删除操作，不需要移动其他元素；
3. 适合元素的频繁插入和删除操作，可以有效地减少内存碎片的产生；
4. 支持随机访问元素，时间复杂度为 O(n)。

但链式表也有一些缺点：

1. 需要额外的指针空间存储节点间的链接信息；
2. 不支持随机访问元素，访问任何一个节点需要遍历整个链表；
3. 内存不连续，对 CPU 缓存不友好，可能导致缓存未命中。

以下是我学习郝斌老师的视频敲出来的代码（单链表算法）：

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


//定义了一个列表节点的数据类型
typedef struct Node
{
    int data;  //数字域
    struct Node * pNext;  //指针域
}Node,*PNode;

//函数声明
PNode Create_List(void);//功能：创建一个非循环单链表
void Traverse_List(PNode);//功能：遍历链表 
bool is_empty_List(PNode);//功能：判断链表是否为空 
int length_List(PNode);//功能：求链表的长度 
bool insert_List(PNode,int,int);//功能：添加一个元素 
bool delete_List(PNode,int,int *);//功能：删除一个元素 
void sort_List(PNode);//功能：升序排序 

int main()
{
    PNode pHead=NULL;//pHead用来存放链表头结点的地址
	
	int val;
    pHead = Create_List();
    Traverse_List(pHead);

    int len=length_List(pHead);
    printf("链表长度是：%d\n",len);
	
	sort_List(pHead);
	printf("升序：");
	Traverse_List(pHead);

	insert_List(pHead,3,10);
	Traverse_List(pHead);
	
	delete_List(pHead,4,&val);
	Traverse_List(pHead);
	printf("你删除的元素是：%d\n",val);

    free(pHead);

    return 0;
}

PNode Create_List(void)
{
    int len;  //用来存放有效节点的个数
    int i;
    int val;  //用来临时存放用户输入的节点值

    //分配了一个不存放有效数据的头结点
    PNode pHead=(PNode)malloc(sizeof(Node));

    if(NULL==pHead)
    {
        printf("分配失败，程序终止！\n");
        exit(-1);//终止程序
    }

    //用pTail指向尾节点 
    PNode pTail=pHead;
    pTail->pNext=NULL;

    printf("请输入您需要生成的链表节点的个数:len = ");
    scanf("%d",&len);

    for(i=0;i<len;i++)
    {
        printf("请输入第%d个节点的值：",i+1);
        scanf("%d",&val);

        PNode pNew=(PNode)malloc(sizeof(Node));
        if(NULL==pNew)
        {
            printf("分配失败，程序终止！\n");
            exit(-1);
        }

        pNew->data=val;
        pTail->pNext=pNew;
        pNew->pNext=NULL;
        pTail=pNew;
    }

    return pHead;
}

bool is_empty_List(PNode pHead)
{
    if(pHead->pNext==NULL)
        return true;
    else
        return false;
}

void Traverse_List(PNode pHead)
{
    if(is_empty_List(pHead))
        printf("链表为空");

    PNode p=pHead->pNext;

    while(NULL!=p)
    {
        printf("%d   ",p->data);
        p=p->pNext;
    }
    printf("\n");
}

int length_List(PNode pHead)
{
	PNode p=pHead->pNext;
	int len=0;
	
	while(NULL!=p)
	{
		len++;
		p=p->pNext;
	}
	return len;
}

void sort_List(PNode pHead)
{
	int i,j,t;
	int len=length_List(pHead);
	PNode p,q;

	for(i=0,p=pHead->pNext;i<len-1;i++,p=p->pNext)
	{
		for(j=i+1,q=p->pNext;j<len-1;j++,q=q->pNext)
		{
			if(p->data>q->data)
			{
				t=p->data;
				p->data=q->data;
				q->data=t;
			}
		}
	}
}

bool insert_List(PNode pHead,int pos,int val)//pos是位置 &&pos>=1
{
	int i=0;
	PNode p=pHead;
	
	while(NULL!=p&&i<pos-1)
	{
		p=p->pNext;
		i++;
	}

	if(i>pos-1||NULL==p)
		return false;
	PNode pNew=(PNode)malloc(sizeof(Node));

	if(NULL==pNew)
	{
		printf("分配失败，程序终止！\n");
        exit(-1);
	}

	pNew->data=val;
	pNew->pNext=p->pNext;
	p->pNext=pNew; 
	return true;
}

bool delete_List(PNode pHead,int pos,int * pVal)
{
	int i=0;
	PNode p=pHead;
	
	while(NULL!=p->pNext&&i<pos-1)
	{
		p=p->pNext;
		i++;
	}

	if(i>pos-1||NULL==p->pNext)
		return false;
	PNode q=p->pNext;
	*pVal=q->data;

	//删除p后面的节点 
	p->pNext=p->pNext->pNext;
	free(q);
	q=NULL;
	return true;
}