单链表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;
}

• 单链表的排序 

 排序算法种类很多，网上有许多关于数组排序相关的算法和程序可以参考，其实链表排序和数组排序一个道理，只不过链表的遍历需要通过指针来操作，下面给出了使用冒泡排序来排序创建好的链表

//对链表排序
void bubble_sort(pNode List)
{
  if((List->next==NULL)||(List->next->next==NULL))
     {
        return;
     }
    pNode Tmp,head,Tmp1;
    int t;
    head=List;
    for(Tmp=head->next;Tmp->next!=NULL;Tmp=Tmp->next)
    {
        for(Tmp1=head->next;Tmp1->next!=NULL;Tmp1=Tmp1->next)
        {
            if(Tmp1->data>Tmp1->next->data) //将数字小的数放在前面
            {
                t=Tmp1->data;
                Tmp1->data=Tmp1->next->data;
                Tmp1->next->data=t;
            }
        }
    }
}

下面是一个综合例子，使用头插法创建一个链表，开始时创建了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;
}