单链表操作

单链表：

即单向的链表，其中的操作包括，创建链表、插入节点、删除节点、排序链表、逆序链表等

typedef struct Node
{
	int value;
	struct Node* next;
}Node;

链表的创建，返回一个指向链表头结点的指针，节点的值为输入的值，当输入为0时停止！ 

Node* list_creat()
{
	Node *head, *ptr, *src;
	int num;
	head=(Node *)malloc(sizeof(Node));
	if(head==NULL)
	{
		cout<<"error creat head node "<<endl;
		return head;
	}
	ptr=head;
	while(cin>>num)
	{
		if(num==0)
			break;
		src=(Node *)malloc(sizeof(Node));
		src->value=num;
		ptr->next=src;
		ptr=src;
	}
	ptr->next=NULL;
	head=head->next;
	return head;
}

链表长度，参数为一个指向链表头节点的指针，返回一个整数表示链表节点的个数 

int list_length(Node* head)
{
	if(head==NULL)
		return 0;
	Node *ptr;
	ptr=head;
	int length=0;
	while(ptr!=NULL)
	{
		length++;
		ptr=ptr->next;
	}
	return length;
}

链表节点删除，参数为指向链表头节点的指针和要删除的节点的值

Node* node_delete(Node *head,int num)
{
	Node *ptr1,*ptr2;
	if(head==NULL)
	{
		printf("error linked list");
		return head;
	}
	ptr1=head;
	while(ptr1->value!=num&&ptr1->next!=NULL)
	{
		ptr2=ptr1;
		ptr1=ptr1->next;		
	}
	if(num==ptr1->value)
	{
		if(head==ptr1)
		{
			head=ptr1->next;
		}
		else
		{
			ptr2->next=ptr1->next;
			delete ptr1;
		}
	}
	else
		printf("the value not find\n");
	return head;
}

链表节点插入，参数指向链表头结点的指针和插入节点的值  

Node* node_insert(Node *head,int num)
{
	Node *ptr1,*ptr2,*ptr3;
	ptr1=(Node *)malloc(sizeof(Node));
	ptr1->value=num;
	if(NULL==head)
	{
		head=ptr1;
		return head;
	}
	ptr2=head;
	ptr3=ptr2;
	while(ptr1->value>ptr2->value)
	{
		ptr3=ptr2;
		if(NULL==ptr2->next)
			break;
		ptr2=ptr2->next;
	}
	if(ptr2==ptr3)
	{
		if(ptr2==head)
		{
			ptr1->next=ptr2;
			head=ptr1;
		}
		else
		{
			ptr2->next=ptr1;
			ptr1->next=NULL;
		}
	}
	else
	{
		ptr3->next=ptr1;
		ptr1->next=ptr2;
	}
	return head;
}

链表排序：采用的是冒泡排序

Node *list_sort(Node *head)
{
	Node *ptr1,*ptr2;
	if(NULL==head||NULL==head->next)
		return head;
	int length=list_length(head);
	int temp;
	for(int i=0;i!=length;++i)
	{
		ptr1=head;
		for(int j=0;j!=length-i-1;++j)
		{
			if(ptr1->value>ptr1->next->value)
			{
				temp=ptr1->value;
				ptr1->value=ptr1->next->value;
				ptr1->next->value=temp;
			}
			ptr1=ptr1->next;
		}
	}
	return head;

}

链表逆转：

Node *list_reverse(Node *head)
{
	Node *ptr1,*ptr2,*ptr3;
	if(NULL==head||NULL==head->next)
		return head;
	ptr1=head;
	ptr2=ptr1->next;
	ptr1->next=NULL;
	while(ptr2)
	{
		ptr3=ptr2->next;
		ptr2->next=ptr1;
		ptr1=ptr2;
		ptr2=ptr3;
	}
	head=ptr1;
}

链表打印：

void list_print(Node* head)
{
	Node *ptr;
	int n=list_length(head);
	ptr=head;
	if(NULL==head)
	{
		printf("error linked list");
		return ;
	}
	while(ptr!=NULL)
	{
		cout<<ptr->value<<" ";
		ptr=ptr->next;
	}
	cout<<endl;
}

struct ListNode
{
	int m_nvalue;
	ListNode *m_pNext;
};

void AddToTail(ListNode **pHead, int value)
{
	ListNode* pNew=new ListNode();
	pNew->m_nvalue=value;
	pNew->m_pNext=NULL;
	if(*pHead==NULL)
	{
		*pHead=pNew;
	}
	else
	{
		ListNode *pNode=*pHead;
		while(pNode->m_pNext!=NULL)
			pNode=pNode->m_pNext;
		pNode->m_pNext=pNew;
	}
}

void RemoveNode(ListNode **pHead, int value)
{
	if(pHead==NULL||*pHead==NULL)
		return ;
	ListNode *pToBeDelete =NULL;
	if((*pHead)->m_nvalue==value)
	{
		pToBeDelete=*pHead;
		*pHead=(*pHead)->m_pNext;
	}
	else
	{
		ListNode *pNode=*pHead;
		while(pNode->m_pNext!=NULL&&pNode->m_pNext->m_nvalue!=value)
		{
			pNode=pNode->m_pNext;
		}
		if(pNode->m_pNext!=NULL&&pNode->m_pNext->m_nvalue==value)
		{
			pToBeDelete=pNode->m_pNext;
			pNode->m_pNext=pNode->m_pNext->m_pNext;
		}
		if(pToBeDelete!=NULL)
		{
			delete pToBeDelete;
			pToBeDelete=NULL;
		}
	}
}

void PrintListReversingly_Iteratively(ListNode* pHead)
{
	std::stack<ListNode*> nodes;
	ListNode* pNode=pHead;
	while(pNode !=NULL)
	{
		nodes.push(pNode);
		pNode=pNode->m_pNext;
	}
	while(!nodes.empty())
	{
		pNode=nodes.top();
		printf("%d\t",pNode->m_nvalue);
		nodes.pop();
	}
}

void PrintListReversingly_Recursively(ListNode* pHead)
{
	if(pHead==NULL)
		return;
	if(pHead->m_pNext!=NULL)
		PrintListReversingly_Recursively(pHead->m_pNext);
	printf("%d\t",pHead->m_nvalue);
}