链表的实现

要面试了，我很心虚，因为自己总是注重工程上的东西，理论上的，数据结构和算法基本全扔。

联想到之前给人讲IP地址分类，脱口而出A类地址是从00000001到11111110分布的，真想抽自己。

然后想自己划划链表等简单的实现，却发现连 链表节点的结构体都不会写了，心虚啊。

转载代码自链接http://yangzhizhen.iteye.com/blog/1472064

简单修改，使之可以在gcc下编译。gcc是不识别bool类型的，或者说ansi c 86标准是没有的，

在链接http://stackoverflow.com/questions/1608318/is-bool-a-native-c-type 中

bool exists in the current ANSI C - C99, but not in C89/90.

代码为

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>
//定义链表节点
typedef struct Node
{
 int data;    //数据域
 struct Node * pNext; //指针域
}NODE, * PNODE;    //NODE等价于struct Node, PNODE等价于struct Node *

//函数声明
PNODE createLinkList(void);        //创建链表的函数
void traverseLinkList(PNODE pHead);      //遍历链表的函数
char isEmpty(PNODE pHead);        //判断链表是否为空的函数
int getLength(PNODE pHead);        //获取链表长度的函数
char insertElement(PNODE pHead, int pos, int val);  //向链表中插入元素的函数，三个参数依次为链表头结点、要插入元素的位置和要插入元素的值
char deleteElement(PNODE pHead, int pos, int * pVal); //从链表中删除元素的函数，三个参数依次为链表头结点、要删除的元素的位置和删除的元素的值
void sort(PNODE pHead);         //对链表中的元素进行排序的函数(基于冒泡排序)
int main(void)
{
 int val;     //用于保存删除的元素
 PNODE pHead = NULL;   //PNODE等价于struct Node *
 pHead = createLinkList(); //创建一个非循环单链表，并将该链表的头结点地址赋给pHead
 traverseLinkList(pHead); //调用遍历链表的函数
 if(isEmpty(pHead))
  printf("链表为空！\n");
 else
  printf("链表不为空！\n");
 printf("链表的长度为：%d\n", getLength(pHead));
 //调用冒泡排序函数
 sort(pHead);
 //重新遍历
 traverseLinkList(pHead);
 //向链表中指定位置处插入一个元素
 if(insertElement(pHead, 4, 30))
  printf("插入成功!插入的元素为：%d\n", 30);
 else
  printf("插入失败!\n");
 //重新遍历链表
 traverseLinkList(pHead);
 //删除元素测试
 if(deleteElement(pHead, 3, &val))
  printf("元素删除成功!删除的元素是：%d\n", val);
 else
  printf("元素删除失败!\n");

 traverseLinkList(pHead);
 system("pause");
 return 0;
}

PNODE createLinkList(void)
{
 int length;  //有效结点的长度
 int i;
 int value;  //用来存放用户输入的结点的值
 //创建了一个不存放有效数据的头结点
 PNODE pHead = (PNODE)malloc(sizeof(NODE));
 if(NULL == pHead)
 {
  printf("内存分配失败，程序退出！\n");
  exit(-1);
 }
 PNODE pTail = pHead; //pTail始终指向尾结点
 pTail->pNext = NULL; //清空指针域
 printf("请输入您想要创建链表结点的个数：len = ");
 scanf("%d", &length);
 for(i=0;i<length;i++)
 {
  printf("请输入第%d个结点的值：", i+1);
  scanf("%d", &value);
  PNODE pNew = (PNODE)malloc(sizeof(NODE));
  if(NULL == pHead)
  {
   printf("内存分配失败，程序退出！\n");
   exit(-1);
  }
  pNew->data = value;  //向新结点中放入值
  pTail->pNext = pNew; //将尾结点指向新结点
  pNew->pNext = NULL;  //将新结点的指针域清空
  pTail = pNew;   //将新结点赋给pTail,使pTail始终指向为尾结点
 }
 return pHead;
}

void traverseLinkList(PNODE pHead)
{
 PNODE p = pHead->pNext;
 while(NULL != p)
 {
  printf("%d  ", p->data);
  p = p->pNext;
 }
 printf("\n");
 return;
}

char isEmpty(PNODE pHead)
{
 if(NULL == pHead->pNext)
  return 1;
 else
  return 0;
}

int getLength(PNODE pHead)
{
 PNODE p = pHead->pNext;   //指向首节点
 int len = 0;     //记录链表长度的变量
 while(NULL != p)
 {
  len++;
  p = p->pNext;    //p指向下一结点
 }
 return len;
}

void sort(PNODE pHead)
{
 int len = getLength(pHead);  //获取链表长度   
 int i, j, t;     //用于交换元素值的中间变量
 PNODE p, q;      //用于比较的两个中间指针变量
 for(i=0,p=pHead->pNext ; i<len-1 ; i++,p=p->pNext)
 {
  for(j=i+1,q=p->pNext;j<len;j++,q=q->pNext)
  {
   if(p->data > q->data)
   {
    t = p->data;
    p->data = q->data;
    q->data = t;
   }
  }
 }
 return;
}

char insertElement(PNODE pHead, int pos, int val)
{
 int i = 0;
 PNODE p = pHead;
 //判断p是否为空并且使p最终指向pos位置的结点
 while(NULL!=p && i<pos-1)
 {
  p = p->pNext;
  i++;
 }
 if(NULL==p || i>pos-1)
  return 0;
 //创建一个新结点
 PNODE pNew = (PNODE)malloc(sizeof(NODE));
 if(NULL == pNew)
 {
  printf("内存分配失败，程序退出!\n");
  exit(-1);
 }
 pNew->data = val;
 //定义一个临时结点，指向当前p的下一结点
 PNODE q = p->pNext;
 //将p指向新结点
 p->pNext = pNew;
 //将q指向之前p指向的结点
 pNew->pNext = q;
 return 1;
}

char deleteElement(PNODE pHead, int pos, int * pVal)
{
 int i = 0;
 PNODE p = pHead;
 //判断p是否为空并且使p最终指向pos结点
 while(NULL!=p->pNext && i<pos-1)
 {
  p = p->pNext;
  i++;
 }
 if(NULL==p->pNext || i>pos-1)
  return 0;
 //保存要删除的结点
 * pVal = p->pNext->data;
 //删除p后面的结点
 PNODE q = p->pNext;
 p->pNext = p->pNext->pNext;
 free(q);
 q = NULL;
  return 1;
}

以上代码中有个问题是频繁使用malloc，而malloc一般涉及到系统调用，没有必要使用malloc，如果非要使用指向结构体的指针，可以向申明变量一样声明一个结构体，再用指针指向它，在帖子最后有这个用法的例子。

但是在实现时，却发现了问题，在链接http://www.cnblogs.com/mxw09/archive/2010/09/02/1816496.html 中，作者做了经典解释：

在createlist时，每次malloc一个新节点，是为动态内存分配，而如果用我说的方式，就会出现所有指针指向一个内存，新值覆盖旧值的情况。

看来凡事不能想当然，要多知。

惭愧，结构体也用不灵光了，挨个试验简单用法的代码如下

#include<stdio.h>
#include <stdlib.h>
typedef struct node
{
	int data;
	struct node *next;
}Node, *pNode;
int main()
{
	Node node;
	node.data = 4;
	printf("%d\n", node.data);

	Node *pn = (Node *)malloc(sizeof(Node));
	pn->data = 5;
	printf("%d\n", pn->data);

	pNode pn2 = (pNode)malloc(sizeof(Node));
	pn2->data = 6;
	printf("%d\n", pn2->data);

	Node *n = &node;
	printf("%d\n", n->data);
	
}