单向链表操作

// 链表操作.cpp : Defines the entry point for the console application.
//链表的创建，插入，删除，反转，数据排序~~~~~~~~~~~~

#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <windows.h>

typedef struct Node
{
	int value;
	struct Node *pNext;
}NODE, *PNODE;

PNODE create_list(void);
void traverse_list(PNODE pHead);   //带有头结点的输出
void traverse_nofront(PNODE );     //不带头结点的输出
bool insert_list(PNODE pHead, int pos, int val);//在第pos个节点前插入一个新节点，其值为val
bool delete_list(PNODE pHead, int pos, int *pVal);//删除第pos个节点，并通过pVal传回删除的节点值
PNODE reverse(PNODE pHead);
void bubble_sort(PNODE pHead);
int lenght(PNODE pHead);
void swap(int &, int &);
void destory_list(PNODE );

int main(int argc, char* argv[])
{
	int val;
	PNODE pHead = NULL;
	pHead = create_list();

	traverse_list(pHead);

	printf("插入节点后为：\n");
	insert_list(pHead, 3, 93);
	
	traverse_list(pHead);


	//quick_sort(pHead->pNext, NULL);
	traverse_nofront(pHead->pNext);

	if (delete_list(pHead, 3, &val))
	{
		printf("删除第%d个节点%d成功!!",3 , val );
	}
	
	traverse_list(pHead);

	bubble_sort(pHead);
	traverse_list(pHead);

	//带有头结点的操作输出
	//PNODE p = (PNODE)malloc(sizeof(NODE)); //由于返回的链表是没有头节点的，所以在这里需要造一个头结点，而不是只是一个指针就ok
	//p->pNext = reverse(pHead);
	//traverse_list(p);

	//不带头结点的输出
	traverse_nofront(reverse(pHead));

	destory_list(pHead);


	return 0;
}

PNODE create_list(void)
{
	int len, val;
	int i;
	PNODE pHead = (PNODE)malloc(sizeof(NODE));
	if (NULL == pHead)
	{
		printf("内存分配失败！！！！！！！！！\n");
		exit(-1);
	}
	
	PNODE pTail = pHead;
	pTail->pNext = NULL;

	printf("请输入要生成的链表节点个数：len = ");
	scanf("%d", &len);

	srand(time(NULL));
	for (i = 0; i < len; i++)
	{
		val = rand()%100;

		PNODE pNew = (PNODE)malloc(sizeof(NODE));
		if (NULL == pNew)
		{
			printf("内存分配失败！！！\n");
			exit(-1);
		}

		pNew->value = val;
		pTail->pNext = pNew;  //将尾节点的指针域（pTail->pNext）指向新创造的节点，这样实现将创建的节点串接起来~~~~
		pNew->pNext = NULL;
		pTail = pNew;         //可理解为将尾节点移到新建的节点。

	}

	return pHead;
}

void traverse_list(PNODE pHead)
{
	while (NULL != pHead->pNext)
	{
		printf("%d   ", pHead->pNext->value);
		pHead = pHead->pNext;
	}
	printf("\n");
}
void traverse_nofront(PNODE pHead)
{
	PNODE pList = pHead;
    while(pList != NULL)
    {
        printf("%d   ",pList->value);
        pList = pList->pNext;
    }
	printf("\n");
}

bool insert_list(PNODE pHead, int pos, int val)
{
	int i = 0;
	PNODE p = pHead;

	while (NULL != p && i < pos-1)
	{
		p = p->pNext;
		++i;
	}

	if (i > pos-1 || NULL == p)
	{
		printf("插入的节点位置有问题！！\n");
		return false;
	}

	PNODE pNew = (PNODE)malloc(sizeof(NODE));
	if(NULL == pNew)
	{
		printf("内存分配错误！！\n");
		exit(-1);
	}

	pNew->value = val;
	PNODE q = p->pNext;
	p->pNext = pNew;
	pNew->pNext = q;

	return true;
}

bool delete_list(PNODE pHead, int pos, int *pVal)
{
	int i = 0;
	PNODE p = pHead;
	
	while (NULL != p->pNext && i < pos-1)
	{
		p = p->pNext;
		++i;
	}
	
	if (i > pos-1 || NULL == p->pNext)
	{
		printf("删除的节点位置有问题！！\n");
		return false;
	}
	
	PNODE q = p->pNext;
	*pVal = q->value;
	p->pNext = q->pNext;
	free(q);
	q = NULL;

	return true;
}

PNODE  reverse(PNODE pHead)
{
	if (pHead == NULL || pHead->pNext == NULL)
	{
		return pHead;
	}
	PNODE pCurr = pHead->pNext;
	PNODE pPre = NULL;
	PNODE Next = NULL;

	do 
	{
		Next = pCurr->pNext;
		pCurr->pNext = pPre;
		pPre = pCurr;
		pCurr = Next;
	} while (pCurr != NULL);
	printf("Reverse success!!\n");
   return pPre;
}

void bubble_sort(PNODE pHead)
{
	PNODE i;
	PNODE j;
	for ( i = pHead->pNext; i != NULL; i = i->pNext)
		for( j = i->pNext; j != NULL; j = j->pNext)
		{
			if (i->value > j->value)
			{
				swap(i->value, j->value);
			}
		}

	printf("Bubble_sort success!!\n");
}
/*
void quick_sort(PNODE pHead, PNODE pEnd)
{
	if(pHead == NULL ||  pHead == pEnd)  return;

	PNODE pSlow = pHead;
	PNODE pFast = pHead->pNext;
	PNODE pTemp = pHead;

	while (pFast != pEnd)
	{
		if (pFast->value < pHead->value)
		{
			pTemp = pSlow;
			pSlow = pSlow->pNext;
		
			swap(pSlow->value, pFast->value);
		}
		pFast = pFast->pNext;
	}

	swap(pSlow->value, pHead->value);
	quick_sort(pHead, pSlow);
	quick_sort(pSlow->pNext, pEnd);
}
*/
void destory_list(PNODE pHead)
{
	PNODE temp;
	while (pHead != NULL)
	{
		temp = pHead;
		pHead = pHead->pNext;
		free(temp);
	}
	return;
}

int lenght(PNODE pHead)
{
	int len = 0;
	PNODE temp = pHead->pNext;
	while (NULL != temp)
	{
		len++;
		temp = temp->pNext;
	}
	return len;
}

void swap(int &a, int &b)
{
	a = a+b;
	b = a-b;
	a = a-b;
}