数据结构与算法单链表

1.什么是链表

     链表我的理解要包含以下特征：（1）.由n个节点离散分配；（2）.每个节点通过指针连接（3）每一个节点由一个前驱节点和一个后驱节点（4）.首节点没有前驱节点，尾节点没有后驱节点；

     满足上面的4条，我们就称为链表；链表既然由很多个节点，那节点又由什么组成？节点由两个部分组成，一是数据域，用来存放有效数据；二是指针域，用来指向下一个节点；下面用C语言来构建链表数据结构，首先应该构造出节点，然后再把所有的节点连起来，就构成了链表；

（1）节点的构造

typedef struct Node
{
    ElementType element;
    Position next;
}Node;

（2）链表的创建

     在创建链表之前，我们需要需要了解一下专业术语：

   首节点：存放第一个有效数据的节点；

   尾节点：存放最后一个有效数据的节点；

   头节点：头节点的数据类型与首节点的数据类型相同，并且头节点是首节点前面的那个节点，并不存放有效数据；头节点的存在只是为了方便链表的操作。

   头指针：指向头节点的指针；

   尾指针：指向尾节点的指针；

首先，我们应该创建一个头节点，并用头指针指向它，用C语言描述：用malloc向计算机申请一块内存，并定义一个指向与头节点数据类型相同的指针（一定要判断申请内存是否成功）；

然后，要知道要创建链表的长度，用一个循环来每次创建一个节点，并把每个节点连在一起；

（3）检查空表

int IsEmpty(List L)  
{  
    return L->Next==NULL;  
}  

如果是空表，表的第一个指针指向NULL。
（4）查找节点

Position Find(ElementType X, List L)  
{  
    Position P;  
    P = L->Next;  
    while(L!=NULL && L->Element!=X)  
        P = P->Next;  
    return P;  
}  

（5）插入节点

void Insert(ElementType X,List L,Position P)  
{  
    Position tmp;  
    Tmp = malloc(sizeof(struct Node));  
    if(tmp==NULL)  
        FatalError("Out of Space!");  
    Tmp->Element = X;  
    Tmp->Next = P->Next;  
    P->Next = Tmp;  
}  

（6）删除节点

6.1删除节点之前，我们要找到所删除节点的位置，即前驱

Position FindPrevious(ElementType X, List L)  
{  
    Position P;  
    P=L;  
    while(P->Next!=NULL && P_>Next->Element!=X)  
        P=P->Next;  
    return p;  
}  

6.2找到前驱后进行删除

void Delete(ElementType X,List L)  
{  
    Position P,Tmp;  
    P = FindPrevious(X,L);  
    if(!IsLast(P,L))  
    {  
        Tmp = P->Next;  
        p->Next = Tmp->Next;  
        free(Tmp);  
    }  
}  
int IsLast(Position P,List L)  
{  
    return P->Next==NULL;  
}  

本篇博客主要介绍带头结点的单链表的一系列操作，包括链表的创建，链表的插入，链表的删除，链表的查找，判断一个链表是否为空，以及在写程序的时候一些注意事项等内容。链表是数据内容的基础，学好了，后面栈就比较容易了。下面就发布可以运行的完整的程序来例举了上述所有的内容

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

struct Node;
typedef struct Node* ptrToNode;
typedef ptrToNode List;
typedef ptrToNode Position;
typedef int ElementType;

typedef struct Node
{
    ElementType element;
    Position next;
}Node;


List createList(int *ptr, int len)
{
    List head;
    Position p;
    Position tmp;
    head =(Position)malloc(sizeof(struct Node)); 
    p = (Position)malloc(sizeof(struct Node)); 
    int i = 0;
    for(; i < len; i++)
    {
	if (i == 0)
	{
		p -> element = *(ptr + i);//遍历第一个元素 
		head -> next = p;
	}
	else
	{
   		tmp = (Position)malloc(sizeof(struct Node)); 
	     	tmp -> element=*(ptr+i);
        	p -> next = tmp;
		p = p->next;
	}
    }
    p -> next = NULL;
    return head;
}


int IsEmpty(List L)
{
   return L->next == NULL;
}

Position FindPrevious(ElementType X, List L)
{
	Position p;
	p = L;
	while(p->next != NULL && p->next->element != X)
		p = p ->next;
	return p;

}

void Delete(ElementType X, List L)
{
	Position previous;
	Position pnow;
	previous = FindPrevious(X,L);
	if(IsEmpty(previous))
	{
		printf("Sorry, there is no %d in the list!\n", X);
		exit(1);
	}
	else
	{
		pnow = previous -> next;
		previous -> next = pnow -> next;
		free(pnow);
	}
}
void prinList(List L)
{
	Position p = L -> next;
	printf("The list is: \n");
	while(p->next != NULL)
	{
		printf("%d ",p -> element);
		p = p -> next;
	}
	printf("\n");
}

void InsertList(ElementType X, Position P, List L)
{
	Position temp;
	temp =(Position)malloc(sizeof(struct Node)); 
	if (!temp)
	{
		printf("Out of space!\n");
		exit(1);
	}
	temp -> element = X;
	temp -> next = P -> next;
	P -> next = temp;
}
int main()
{
    int a[10] = {8,54,6,86,23,2,1,93,4,85};
    List L = (Position)malloc(sizeof(struct Node)); 
    L = createList(a,10);
    if(IsEmpty(L))
	{
		printf("The list is empty!\n");
		exit(1);
	}
	prinList(L);
	Delete(a[5],L);
	prinList(L);
	InsertList(a[3],L->next,L);
	prinList(L);
    return 0;
}

程序结果

参考博客：http://blog.youkuaiyun.com/lpp0900320123/article/details/20356143

                 http://blog.youkuaiyun.com/xiaxia__/article/details/16865859