链表和数组

链表和数组都是我们用来存储一系列数的基本数据结构，但是这两种数据结构各有各的优缺点！
数组是我们初学者最常用的一种数据结构，数组的有点在于知道一其中一个元素的地址，我们就可以推出其他数组元素的地址，但是我们知道在C中，数组是必须要在定义时确切的知道数组的长度，如果不知道数组的长度，我们必须要定义的足够长，这样就会产生两个问题，第一个就是数组长度如果还是不够的话我们是没办法的；第二个问题就是如果我们定义的数组长度过长，就会造成空间浪费。
但是链表就不同了，在你想要更大的空间时，链表完全可以申请出你需要的空间，在你不需要这些空间时，只需要free一下，空间就会被释放，而且由于链表的结构特殊，我们完全可以随意的在链表中插入数据，不会像数组一样插入时其他元素全要移动。
接下来我来给大家介绍一下链表：
首先 我们创建一个链表

#include<stdio.h>
    typedef struct _NODE
    {
    	int value;
    	struct _NODE * next;
    }NODE, *PNODE;// PNODE是一个结构体类型的指针变量类型名
    int main()
{
	PNODE pHead = NULL;
	return 0;
}

链表的每一个结点就是一个结构体。这样就创建出了一个空链表，他只有一个头指针，头指针为空。
然后给我们的链表要插入数据了
首先是头插法

void InsertHead(PNODE * ppHead, int value)//因为插入数据，头指针会改变，所以我们传入头指针的地址
{
	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	pNew->value = value;

	pNew->next = *ppHead;
	*ppHead = pNew;
}

尾插法

void InsertTail(PNODE * ppHead, int value)
{
	if (NULL == *ppHead)
	{
		InsertHead(ppHead, value);
	}
	else
	{
		PNODE pPos = *ppHead;
		while (pPos->next != NULL)
		{
			pPos = pPos->next;
		}

		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		pNew->value = value;
		pNew->next = NULL;
		pPos->next = pNew;
	}
}

我们可以看出，尾插法的时间复杂度是远高于头插法的，因为他每一次都要遍历到链表尾端
按下标插入

void InsertByIndex(PNODE * ppHead, unsigned int index, int value)
{
	PNODE pPos = *ppHead;
	int i = 0;
	if (index == 0 && (pPos != NULL))
	{
		pPos->value = value;
	}
	else
	{
		while (i < index  && (pPos != NULL))
		{
			pPos = pPos->next;
			i++;
		}
		pPos->value = value;
	}

}

头删法

void DeleteHead(PNODE * ppHead)
{
	if (*ppHead != NULL)
	{
		PNODE pPos = *ppHead;
		*ppHead = pPos->next;
		free(pPos);
		pPos = NULL;
	}
}

尾删法

   void DeleteTail(PNODE * ppHead)
{
	if (NULL == *ppHead || NULL == (*ppHead)->next)
	{
		DeleteHead(ppHead);
	}
	else
	{
		PNODE pPos = *ppHead;
		while (pPos->next->next != NULL)
		{
			pPos = pPos->next;
		}

		free(pPos->next);
		pPos->next = NULL;
	}
}

按下标删除

void DeleteByIndex(PNODE * ppHead, unsigned int index)
{
	PNODE pPos = *ppHead;
	int i = 0;
	PNODE t = NULL;
	if (index==0)
		{
	
		DeleteHead(ppHead);
		
		}
	else
	{
		while ((pPos != NULL) && (i < index - 1))
		{
			pPos = pPos->next;
			i++;
		}

		DeleteHead(&(pPos->next));
	}

按值删除

  void DeleteByValue(PNODE * ppHead, int value)
    {
    
    	PNODE pPos = NULL;
    	PNODE t = NULL;
    	pPos = *ppHead;
    		if (pPos->value == value)
    		{
    			t = pPos;
    			pPos = pPos->next;
    			free(t);
    			t = NULL;
    		}
    
    	lp:	while (!(pPos->next->value == value))
    		{
    			pPos = pPos->next;
    		}
    		t = pPos->next;
    		pPos->next = pPos->next->next;
    		free(t);
    		t = NULL;
    		if (pPos->next != NULL)
    			goto lp;
    		
    }

因为链表中可能有多个想同值，所以我是用了gouto语句来进行循环
链表的逆序

void Reverse(PNODE * ppHead)
{
	if (!(NULL == *ppHead || NULL == (*ppHead)->next))
	{
		PNODE p1, p2, p3;
		p1 = *ppHead;
		p2 = p1->next;
		p3 = p2->next;
		p2->next = p1;

		while (p3 != NULL)
		{
			p1 = p2;
			p2 = p3;
			p3 = p3->next;
			p2->next = p1;
		}

		(*ppHead)->next = NULL;
		*ppHead = p2;
	}
}

由于我也是初学，所以代码或者思想上中有什么问题，还希望大牛可以指出！