单链表C语言操作

    链表是一种相对于顺序存储空间而言的链式存储结构，是一种在存储空间而言不连续的一种数据结构。其中的每个元素称为节点，包含有数据域和指针域，指针域存储的是指向下一个节点，数据域代表这个元素的数据

struct ListNode 
{ 
    int data; 
    struct ListNode *next; 
};

头节点，存放第一个节点的地址，数据域一般设为0，最后一个节点的指针域一般设为NULL，没有后继节点。

• 创建一个单链表，先创建一个头节点，然后用一个临时节点去初始化链表中的元素

pNode CreateListnew()
{
	int len;//链表长度
	int val;//节点的数值
	int i=0;
	//创建链表的头部 头节点不存放数据，指针指向第一个节点
	pNode pHead=(pNode)malloc(sizeof(Node));//分配空间
	if(pHead==NULL)
	{
		printf("malloc fail for header\r\n");
		return NULL;
	}
    pHead->next=NULL;//头节点指针域清空
	pNode tmp=pHead;//临时节点 初始是头节点

	for(i=0;i<Length;i++)
	{
		pNode pNew=(pNode)malloc(sizeof(Node));//分配空间
		if(pNew==NULL)
		{
			printf("malloc fail for new node\r\n");
			return NULL;
		}
		pNew->data=2*i;//新节点的数据域
		tmp->next=pNew;//将pNew指向新节点插入链表
		tmp=pNew;//将新节点赋给这个临时节点，方便下一次插入
	}
	tmp->next=NULL;//最后节点的指针域清空
	printf("create list success\r\n");
	return pHead;  //f返回头节点
}

• 单链表求长

设定当前指针P和一个计数器i，初始时P指向链表中的第一个结点，p每向下移动一个结点时，i就加1，直到到达p链表的尾部

//测试链表长度
int ListLength(pNode List)
{
    pNode P=List->next;//传参的是头节点，开始P应该是指向第一个节点
    int i=0;
    while(P!=NULL)
    {
        i++;
        P=P->next;
    }
    return i;
}

• 遍历链表

和单链表求长类似

//遍历
void TraverseList(pNode List)
{
    pNode P=List->next;
    printf("遍历链表值为:\r\n");
    if(P==NULL)
    {
        printf("list is null!\r\n");
    }
    while(P!=NULL)
    {
        printf("%d ",P->data);
        P=P->next;
    }
    printf("\r\n");
}

• 链表的尾插

找到整个链表的尾节点，创建一个新节点，是这个节点指向尾节点的next，并将这个新节点的指针域设置成空。

void tail_insert(pNode List,int val)
{
    pNode P=List;

    while(P->next!=NULL)
    {
        P=P->next;
    }
     pNode Tmp=(pNode)malloc(sizeof(Node));
    if(Tmp==NULL)
    {
        printf("malloc fail for Tmp");
        return -1;
    }
    P->next=Tmp;
    Tmp->data=val;
    Tmp->next=NULL;
}

• 单链表的头插

有新的结点就把此结点放在头结点的后面。操作过程中只需要把头节点的指针域赋给创建的新节点的指针域，也就是新节点的后继是原来的第一个节点，然后让新结点变为链表的第一个节点

void HeadInsert(pNode List,int val)
{
  pNode P=List;//头节点
  pNode Tmp=(pNode)malloc(sizeof(Node));
    if(Tmp==NULL)
    {
        printf("malloc fail for Tmp");
        return ;
    }
  Tmp->next=P->next;//头节点的指针域赋给创建的节点的指针域
  Tmp->data=val;
  P->next=Tmp; // 让新结点变为链表的第一个节点

}

• 链表中间插入

首先根据输入链表的插入索引获取要插入节点的前一个节点，创建一个新节点，前一个节点的指针域赋给这个新节点的指针域，并让前一个节点的指针域指向这个新创建的节点。

void InsertList(pNode List,int pos,int val)
{
    pNode P=List;
    int position=0;
    //寻找pos节点的前驱节点
    while(P!=NULL&&position<pos-1)
    {
        P=P->next;
        position++;
    }
    pNode Tmp=(pNode)malloc(sizeof(Node));
    if(Tmp==NULL)
    {
        printf("malloc fail for Tmp");
        return ;
    }
    //insert node
    Tmp->data=val;
    Tmp->next=P->next;
    P->next=Tmp;
}

• 单链表的删除

首先根据输入链表的删除索引获取要删除节点的前一个节点，创建一个新节点，前一个节点的指针域赋给这个新节点，并让新创建的节点的指针域指向前一个节点的指针域。

void DeleteList(pNode List,int pos)
{
    int position=0;
    pNode P=List;
    //寻找pos节点的前驱节点
    while(P!=NULL&&position<pos-1)
    {
        P=P->next;
        position++;
    }
    pNode Tmp=P->next;
    P->next=Tmp->next;
    free(Tmp);
    Tmp=NULL;
}

下面是一个综合例子，使用头插法创建一个链表，开始时创建了10个元素，然后可以使用上面的一些单链表的函数对这个链表进行插入，删除和遍历

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

#define Length 10

 struct ListNode
{
	int data;
	struct ListNode *next;
};
typedef struct ListNode Node;
typedef struct ListNode* pNode;
//typedef Node* pNode;

//链表初始化
void ListInit(pNode List)
{
    List=(pNode)malloc(sizeof(Node));//分配空间
    if(List==NULL)
    {
        printf("malloc fail\r\n");
        return;
    }
    List->next=NULL;
}

//创建单链表
pNode CreateList()
{
	int len;//链表长度
	int val;//节点的数值
	int i=0;
	//创建链表的头部 头节点不存放数据，指针指向第一个节点
	pNode pHead=(pNode)malloc(sizeof(Node));//分配空间
	if(pHead==NULL)
	{
		printf("malloc fail for header\r\n");
		return NULL;
	}
	//创建链表的尾部 初始指向头部 并将指针域置位空
	pNode pTail=pHead;
	pTail->next=NULL;
	for(i=0;i<Length;i++)
	{
		pNode pNew=(pNode)malloc(sizeof(Node));//分配空间
		if(pNew==NULL)
		{
			printf("malloc fail for new node\r\n");
			return NULL;
		}
		pNew->data=2*i;
		pTail->next=pNew; //末尾节点指针指向下一个新数据
		pNew->next=NULL;
		pTail=pNew; //将新节点复制给末尾节点
	}
	printf("create list success\r\n");
	return pHead;
}
//创建单链表
pNode CreateListnew()
{
	int len;//链表长度
	int val;//节点的数值
	int i=0;
	//创建链表的头部 头节点不存放数据，指针指向第一个节点
	pNode pHead=(pNode)malloc(sizeof(Node));//分配空间
	if(pHead==NULL)
	{
		printf("malloc fail for header\r\n");
		return NULL;
	}
    pHead->next=NULL;//头节点指针域清空
	pNode tmp=pHead;

	for(i=0;i<Length;i++)
	{
		pNode pNew=(pNode)malloc(sizeof(Node));//分配空间
		if(pNew==NULL)
		{
			printf("malloc fail for new node\r\n");
			return NULL;
		}
		pNew->data=2*i;
		tmp->next=pNew;//将pNew指向新节点插入链表
		//pTail->next=pNew; //末尾节点指针指向下一个新数据
		//pNew->next=NULL;
		//pTail=pNew; //将新节点复制给末尾节点
		tmp=pNew;//将新节点赋给这个临时节点，方便下一次插入
	}
	tmp->next=NULL;//最后节点的指针域清空
	printf("create list success\r\n");
	return pHead;
}
//测试链表长度
int ListLength(pNode List)
{
    pNode P=List->next;
    int i=0;
    while(P!=NULL)
    {
        i++;
        P=P->next;
    }
    return i;
}

//遍历
void TraverseList(pNode List)
{
    pNode P=List->next;
    printf("遍历链表值为:\r\n");
    if(P==NULL)
    {
        printf("list is null!\r\n");
    }
    while(P!=NULL)
    {
        printf("%d ",P->data);
        P=P->next;
    }
    printf("\r\n");
}
//查询
pNode FindList(pNode List)
{
    pNode P=List->next;
    int num=0;
    int val=0;
    printf("input your val");
    scanf("%d",&val);
    while((P!=NULL)&&(P->data)!=val)
    {
        P=P->next;
        num++;
    }
    if(P!=NULL)
        printf("找到节点:%d",num+1);
    else
        printf("找不到对应的节点");
    printf("\r\n");
    return P;
}
void InsertList(pNode List,int pos,int val)
{
    pNode P=List;
    int position=0;
    //寻找pos节点的前驱节点
    while(P!=NULL&&position<pos-1)
    {
        P=P->next;
        position++;
    }
    pNode Tmp=(pNode)malloc(sizeof(Node));
    if(Tmp==NULL)
    {
        printf("malloc fail for Tmp");
        return ;
    }
    //insert node
    Tmp->data=val;
    Tmp->next=P->next;
    P->next=Tmp;

}
//头插  有新的结点就把此结点放在头结点的后面
void HeadInsert(pNode List,int val)
{
  pNode P=List;//头节点
  pNode Tmp=(pNode)malloc(sizeof(Node));
    if(Tmp==NULL)
    {
        printf("malloc fail for Tmp");
        return ;
    }
  Tmp->next=P->next;//头节点的指针域赋给创建的节点的指针域
  Tmp->data=val;
  P->next=Tmp; // 让新结点变为链表的第一个节点

}
void tail_insert(pNode List,int val)
{
    pNode P=List;

    while(P->next!=NULL)
    { // 让新结点变为链表的第一个节点
        P=P->next;
    }
     pNode Tmp=(pNode)malloc(sizeof(Node));
    if(Tmp==NULL)
    {
        printf("malloc fail for Tmp");
        return ;
    }
    P->next=Tmp;
    Tmp->data=val;
    Tmp->next=NULL;
}
void DeleteList(pNode List,int pos)
{
    int position=0;
    pNode P=List;
    //寻找pos节点的前驱节点
    while(P!=NULL&&position<pos-1)
    {
        P=P->next;
        position++;
    }
    pNode Tmp=P->next;
    P->next=Tmp->next;
    free(Tmp);
    Tmp=NULL;
}

int main()
{
		//pNode List=CreateList();
		pNode List=CreateListnew();//创建10个元素的节点并返回头节点
		TraverseList(List);
		printf("List Length:%d\r\n",ListLength(List));
		//FindList(List);
		InsertList(List,3,50);//指定位置插入
		TraverseList(List);//遍历
		printf("List Length:%d\r\n",ListLength(List));
		DeleteList(List,3);//删除元素
          TraverseList(List);//遍历
          tail_insert(List,999);//尾插
          TraverseList(List);//遍历
          HeadInsert(List,11);//头插
          TraverseList(List);//遍历
          printf("List Length:%d\r\n",ListLength(List));
		return 0;
}