单向链表的基本操作

一、链表与数组：

  首先，我们来看看为啥我们有了数组，还需要链表呢？那么我们来看看链表与数组的区别。

二者都属于一种数据结构：

从逻辑结构来看：

1、 数组必须事先定义固定的长度(元素个数)，不能适应数据动态地增减的情况。当数据增加时，可能超出原先定义的元素个数；当数据减少时，造成内存浪费;数组可以根据下标直接存取。

2、 链表动态地进行存储分配，可以适应数据动态地增减的情况，且可以方便地插入、删除数据项。(数组中插入、删除数据项时，需要移动其它数据项，非常繁琐)链表必须根据next指针找到下一个元素

从内存存储来看：

(静态)数组从栈中分配空间, 对于程序员方便快速,但是自由度小

链表从堆中分配空间, 自由度大但是申请管理比较麻烦

  从上面的比较可以看出，如果需要快速访问数据，很少或不插入和删除元素，就应该用数组;相反， 如果需要经常插入和删除元素就需要用链表数据结构了。

二、单向链表的相关操作：

1、定义链表结构体：

这里没有使用头结点。

struct Node
{
int num;              //这里用来方便查找链表位置，可以省略
datatype data;        //数据
struct Node *pNext;   //指向下一个结点
};
typedef struct Node node;   //定义一个node类型

2、插入数据（后面）：

void backadd(node **ppnode,int num, datatype data)
{
node *pNewnode = (node *)malloc (sizeof(node));

//creat a  new node
pNewnode->num =num;    //给新结点赋值
pNewnode->data=data;

if(*ppnode == NULL)     //如果首元结点为空
{
*ppnode = pNewnode;     //将新加入的结点作为首元结点
pNewnode->pNext = NULL;
}

else  //the first node isn't empty
{
node *p = *ppnode;    //head

while(p->pNext != NULL)
{
p=p->pNext;
}
p->pNext = pNewnode;   //Insert

}

}

这里用到了二级指针，用于保存头结点指针的地址。如果不用二级指针则需要一个node *的返回值，才能改变结点的地址。

调用：

node *pNode = NULL;    //定义头结点
backadd(&pNode,1,11);   //出入的是地址

2、结点查找：

  因为我们在结构体中每个结点我们能设置了一个num，现在我们就可以通过匹配这个num来查找某个结点。

node *search(node *pNode,int num)
{
node *p=pNode;
for(;p!=NULL; p=p->pNext)  //遍历整个链表，知道为空
{
if(num == p->num)   //通过设定数字查找
{
return p;
break;
}
}
return NULL;
}

3、替换结点内容：

  这里与查找有些类似，需要先查找到对于结点，然后再对其内容进行替换。

int change(node *pNode,int oldnum,int newnum,datatype newdata)
{
while(pNode->pNext != NULL) //终止条件
{
if(pNode != NULL)
{
if(oldnum == pNode->num)
{
pNode->num=newnum;  //赋值
pNode->data=newdata;
return 1;
}
pNode = pNode->pNext; //遍历整个链表，一直到最后pNode->pNext = NULL
}
}

printf("can't find the node,modify failed!");
return 0;
}

4、删除结点

让上一个结点直接跳过要删除的结点，指向要删除结点的下一个结点。

node *delete(node *pNode,int num)
{
node *p1 = NULL;
node *p2 = NULL;

p1=pNode;   //Save the infomation of the linklist

while(p1 != NULL)
{
if(p1->num == num)   //查找结点
{
break;
}
else
{
//p2指向前一个结点
p2=p1;  //Save the previous node
p1=p1->pNext;
}
}

if(p1 == pNode)   //要删除的点是第一个结点
{
pNode=p1->pNext;   //把第一个结点地址变为下一个结点地址
free(p1);
}

else
{
p2->pNext=p1->pNext;  //ignore p1(delete it)
free(p1);
}
return pNode;
}

这里也可以用for循环来实现，传入一个n值来控制要删除具体那个结点。用for循环控制p要移动的次数。接下来，我们在数据的插入中将会用到。

5、数据插入（中间，前面）

  和删除类似，需要找到前后两个结点并用p1,p2来保存。再进行相关操作。是删除结点的反操作。

在中间插入图解：

void insert(node **pNode,int n,int newnum,datatype newdata)
{
node *p1,*p2;
p1=p2=NULL;
p1=*pNode;
int i=0;

while(p1 != NULL)
{
for(i=1;i<n;i++)   //用for循环找出要在第几个结点前面插入
{
p2=p1;
p1=p1->pNext;
}
break;
}

node *pNewnode=(node *)malloc(sizeof(node));
pNewnode->num=newnum;
pNewnode->data=newdata;
printf("%p",pNewnode);

if(pNode == p1)    //insert it on the head
{
pNewnode->pNext = *pNode;
*pNode=pNewnode;
}

else            //中间
{
pNewnode->pNext=p1;
p2->pNext=pNewnode;
}

}

6、链表逆序：

  逆序：数据颠倒，但是地址不变。也就是说要把链表的指向颠倒过来。需要三个变量，p1,p2用来遍历整个链表，p3类似于一个临时变量，方便p1,p2进行数据交换。最后p2==NULL时退出，p1地址作为头结点的值，并且把原来头结点的下一个地址置空。

node *inverted(node *pNode)
{
node *p1,*p2,*p3;
p1=p2=p3=NULL;
p1=pNode;
if(pNode == NULL || pNode->pNext ==NULL)
{
return pNode;
}
else
{
p1=pNode;
p2=pNode->pNext;
}

while(p2 != NULL)
{
p3 = p2->pNext;
p2->pNext=p1;
p1=p2;
p2=p3;
}
pNode->pNext = NULL;  //首元结点变最后一个结点，所以指向空
pNode=p1;             //p1移动到最后，把p1地址赋给首元结点。
return pNode;
}

7、链表摧毁：

移动一次后，把前面的结点free并置空。

void link_destory(node *pNode)
{
node *p1;
while( pNode != NULL)
{
p1=pNode->pNext;
pNode=p1;
free(p1);
p1=NULL;
}
}

总结：

关于free()与野指针：

  链表的操作关键在与操作指针，所以经常出现段错误。为了避免这种情况，我们定义指针后一定要对它进行初始化，而且操作之前要判断是否为NULL，这很重要，经常容易出错。还有就是，在用完要记得free，那么之后，free之后，指针就变成了野指针，一定要把指针赋值为NULL。

比如，在这个例子中，我们可以看到，指针free之后地址依旧不变，只不过它的值变了，变成了一个野指针。



形象点来说就是：

你大学的宿舍，入学后就申请，大学四年一直是你在用，别人不能用；大学毕业后，还给了学校，学校究竟有没有分配给别人你就不清楚了，反正你再也不能使用； 分配给你的寝室号一直在那，你的心也一直记得那个号码

关于二级指针

  指针的指针就是二级指针。指针用来存放地址，那么二级指针就是用来存放指针的地址。所以当程序中操作链表结点的地址时候，比如，要更改头结点的时候，就需要通过二级指针来实现，我们传入的头结点是一个，node**类型这时候不需要返回值。我们如果不想用二级指针，也可以通过通过返回 node * 的头结点来实现。