单链表的建立、插入、删除、遍历

首先建立结构体Linklist以及全局指针head作为表头，具体不在赘述,除此之外本次只详细描述尾插法，头插法不再述说。

创建

声明一结点q和计数器变量i；
初始化一空链表p；
让p的头结点的指针指向NULL，即建立一个带头结点的单链表；
循环实现后继结点的赋值和插入。

尾插法代码如下：

Linklist *Create()
{
	Linklist *p,*q;
	head = NULL;
	while(i--)
	{
		p = new Linklist;   //分配内存空间
		p->data =           //对p中数据进行赋值操作
			if(head=NULL)
				head=p;     //head为空，使头指针指向节点p
			else
		q->next = p;		//把新节点添加到表尾
		q = p;				//把指针指向新节点
	}
	if(head!=NULL)
		q->next=NULL;  		//尾节点的指针域置空
}

插入

单链表第i个数据插入结点的算法思路：
声明一结点p指向链表头结点，初始化j从1开始；
当j<1时，就遍历链表，让p的指针向后移动，不断指向下一结点，j累加1；
若到链表末尾p为空，则说明第i个元素不存在；
否则查找成功，在系统中生成一个空结点s；
将数据元素e赋值给s->data；
单链表的插入刚才两个标准语句；s->next = p->next;p->next = s;
返回成功。

代码如下：

Linklist pHead;//链表

int insert(Linklist* pNode)
{
	Linklist *p,*q;
	
	//第一种情况，链表为空
	if(pHead = NULL)
	{
		pHead=node;
		return;
	}
	//第二种情况，pNode节点num值小于等于链表头结点的num值（num 链表判定值）
	if(pNode->num<=pHead->num)
	{
		pNode->next=pHead;
		
		pHead=pNode;//将pNode插入到pHead前面成为链表头
		
		return;
	}
	//第三种情况，循环查找正确位置
	p=pHead;
	q=pHead->next;
	while(q!=NULL)
	{
		if(pNode->num>q->num)//判断pNode节点的num是否（大于）当前节点num，具体问题具体分析
		{
			p=q;
			q=q->next;//不断后移进行查找
		}
		else
			break;
	}
	//将pNde节点插入正确的位置
	p->next=pNode;
	pNode->next=q;
}

删除

单链表第i个数据删除结点的算法思路：
声明结点p指向链表第一个结点，初始化j=1；
当j<1时，就遍历链表，让P的指针向后移动，不断指向下一个结点，j累加1；
若到链表末尾p为空，则说明第i个元素不存在；
否则查找成功，将欲删除结点p->next赋值给q；
单链表的删除标准语句p->next = q->next；
将q结点中的数据赋值给e，作为返回；
释放q结点。
可以这样：p->next = p->next->next;
也可以是：q=p->next; p->next=q->next;

代码如下：

Linklist pHead;//链表

void del(int num)
{
	Linklist *p,*q;
	
	//第一种情况，链表为空
	if(pHead = NULL)
		return;
	//第二种情况，删除链表头
	p=pHead；
		if(p->num==num)
		{
			pHead=p->next;
			
			delete p;
			
			return;
		}
		//第三种情况，循环查找删除位置
		q=p->next;
		while(q!=NULL)
		{
			if(q->num==num)
			{
				p->next=q->next;
				delete p;
				return;
			}
			if(q->num>num)
				return;
			p=q;
			q=q->next;
		}
}	

遍历

获得链表i个数据的算法思路：
声明一个结点p指向链表第一个结点，初始化j从1开始；
当j<i时，就遍历链表，让p的指针向后移动，不断指向一下结点，j+1；

直到链表末尾p为空，输出每个位置的数据元素。

代码如下：

Linklist pHead;//链表

void print()
{
	Linklist *p=pHead;
	
	while(p!=NULL)
	{
		p=p->next;
		cout<<        //输出相应数据
	}
}

另附上一个完整的代码：

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

//定义结构体类型struct node
struct node{
    int  data;
	struct node *next;    
}; 

//用typedef定义结构体类型Lnode、结构指针类型LinkList
typedef struct node Lnode, *LinkList;

//函数原型声明
void  Build(LinkList head); //建立带头结点的单链表head
void Disp(LinkList head);   //输出带头结点的单链表head
int Del(LinkList head,int x); //删除单链表head中元素值为x的结点
void Insert(LinkList head,int x);  //在单链表head(该单链表按元素值升序)中插入新元素x
void FreeLink(LinkList head);  //彻底释放单链表

int main()
{
	LinkList head; //声明指向头结点的指针变量head
	int x; 
	
	//初始化单链表：申请头结点
	head=(LinkList)malloc(sizeof(Lnode));
	head->next=NULL; //head->next为空，表示该链表为空
	
	//建立单链表head
	Build(head);

	//顺序输出单链表
	Disp(head);

	//删除单链表head中元素值为x的结点
	printf("输入被删除的元素：\n");
	scanf("%d",&x);
	if( !Del(head,x) ) //若找到，删除，返回1，若找不到，返回0
		printf("该元素不存在\n");
	Disp(head);

	//在单链表head中插入新元素x, 使单链表依然保持升
	printf("输入新元素值：\n");
	scanf("%d",&x);	
    Insert(head,x);
	Disp(head);	

	//彻底释放单链表
	FreeLink(head);

	return 0;
}
void  Build(LinkList head)
{
	
    int d;
	LinkList s, rear;

	//rear指向head. rear总是指向表尾结点，初始时链表为空，rear执行head
	rear=head;

   //当读入数据不是-1,就建立新节点链入链表尾部
	printf("升序输入若干整数，输入-1表示输入结束\n");
	while(scanf("%d",&d),d!=-1)
	{
        //为当前整数建立结点s；
		s=(LinkList)malloc(sizeof(Lnode));
		s->data=d; //将d存入s的data域
		s->next=NULL; //s的后继为NULL		

        //将当前结点链入链表尾,做p的next
		rear->next=s;

        //rear指向新的表尾结点s
		rear=s;
	} 
}

void Disp(LinkList head)
{
	LinkList p;

	//这是带头结点的单链表，p指向首元素结点head->next
	p=head->next;

	//当p值非空
	while(p)
	{
		printf("%d\n",p->data); //输出当前结点的data
		p=p->next; //p指向后继结点
	}	
}

//若找到，删除，返回1，若找不到，返回-1
int Del(LinkList head,int x)
{
	//若要删除某一结点，需获取其前驱结点，故，使用两个指针，cur指向被删除结点， pre指向其前驱结点
	LinkList pre,cur;

	//带头结点的单链表，pre指向头结点，cur指向首元素结点
	pre =head;
	cur=head->next;
    
	//查找值为x的结点，若x存在，循环结束时, cur指向值为x的结点，pre指向其前驱
	while(cur && cur->data!=x)  //当cur非空 且 当前元素不是x，pre和cur均指向下一个结点
	{
		pre=cur; 
		cur=cur->next;
	}

	//若找不到值为x的元素，返回0
	if(cur==NULL)
		return 0;

	//删除cur所指结点
	pre->next=cur->next;
	free (cur);
	return 1;
}

//彻底释放单链表
void FreeLink(LinkList head)
{
	LinkList cur, temp;

	cur=head; //pre指向头结点	
	while(cur)
	{
		temp=cur->next; //将当前结点cur的后继指针暂存入temp中
		free(cur); // 释放当前结点
		cur=temp; //cur指向下一个结点
	}
}

//在单链表head(该单链表按元素值升序)中，插入新元素x
void Insert(LinkList head,int x)
{
	// 要在pre和cur之间插入新节点
	LinkList pre, cur, s;

	//带头结点的单链表，pre指向头结点，cur指向首元素结点
	pre =head;
	cur=head->next;

	//构造新节点s
	s=(LinkList)malloc(sizeof(Lnode));
	s->data=x; //将x存入s的data域
	s->next=NULL; //s的后继为NULL

	//寻找新结点插入位置
	while(cur && cur->data < x)  //当cur非空 且 当前元素比x小，pre和cur均后移一个结点
	{
		pre=cur; 
		cur=cur->next;
	}

	//在在pre和cur之间插入新节点s
	s->next=cur;
	pre->next=s;

}