数据结构 线性结构中的链表

定义：
n个节点离散分配
彼此通过指针相连
每个节点只有一个前驱节点，每个节点只有一个后续节点
首节点没有前驱节点，尾节点没有后续节点。

        专业术语：
                首节点：
                        第一个有效节点
                尾节点：
                        最后一个有效节点
                头节点：
                        头结点的数据类型和首节点的类型一样
                        没有存放有效数据，最最前面的，是在
                        首节点之前的，主要是为了方便对链表
                        的操作。
                头指针：（指向头）
                        指向头节点的指针变量
                尾指针：
                        指向尾节点的指针

分类：
a 单链表
b 双链表：
每一个节点有两个指针域
c 循环链表：
能通过任何一个节点找到其他所有的节点
d 非循环链表

//链表
#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>

typedef struct Node
{
  int data;//数据域
  struct Node * pNext;//指针域
}NODE,*PNODE;
//函数声明
PNODE creat_list(void);//创建链表
void traverse_list(PNODE pHead);//遍历输出链表中节点的值
bool is_empty(PNODE pHead);//判断链表是否为空
int length(PNODE pHead);//求链表中节点的个数
void sort_list(PNODE pHead);//排序
bool insert_list(PNODE pHead,int pos,int val);//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值为val；
bool delect_list(PNODE, int, int*);

//主函数入口
int main(void)
{
  PNODE pHead = NULL;//创建头指针
  int val;

  pHead = creat_list();//创建节点
  //排序前链表中节点的值
  traverse_list(pHead);//遍历节点
  if( is_empty(pHead))
  {
    printf("链表为空！即链表节点的个数为%d\n",length(pHead));

  }
  else
  {
    printf("链表不为空！且链表节点的个数为%d\n",length(pHead));
  }

//升序排序后的链接中节点的值
  printf("升序排序后的链接中节点的值\n");
  sort_list(pHead);
  traverse_list(pHead);//遍历节点

  insert_list(pHead,4,33333);
  //插入后的链接中节点的值
  printf("插入后的链接中节点的值\n");
  traverse_list(pHead);//遍历节点

  if( delect_list(pHead,2, &val) )
  {
    printf("删除成功，您删除的元素是：%d\n",val);
    }
  else
  {
    printf("删除不成功");
    }

  return 0;

  }


PNODE creat_list(void)
{
  int len;//存放有效节点的个数
  int i;
  int val;//临时存放输入的节点的值

  PNODE pHead = (PNODE)malloc(sizeof(NODE));
  if(pHead==NULL)
  {
    printf("分配失败，程序终止！\n");
    exit(-1);
  }

 PNODE pTail = pHead;
 pTail->pNext=NULL;

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

for(i=0;i<len;i++)
{
  printf("请输入第%d个节点的值：",i+1);
  scanf("%d",&val);

  PNODE pNew = (PNODE)malloc(sizeof(NODE));
  if(pNew==NULL)
  {
    printf("分配失败，程序终止！\n");
    exit(-1);
  }

  pNew->data=val;
  pTail->pNext=pNew;
  pNew->pNext=NULL;
  pTail=pNew;
}
return pHead; 
}

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

bool is_empty(PNODE pHead)
{
    if(NULL==pHead->pNext)
        return true;
    else 
        return false;
}
int length(PNODE pHead)
{
    int len=0;
    PNODE p = pHead->pNext;
    while(p!=NULL)
    {
      ++len;
      p=p->pNext;
    }
    return len;

}

void sort_list(PNODE pHead)
{
  int i,j,t;
  int len;
  len = length(pHead);
  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)//a[i]>a[j]
          {
            t=p->data;// t=a[i];
            p->data=q->data;//a[i]=a[j];
            q->data=t;//a[j]=t;
          }
      }
  }
  return;
}
//在pHead所指向链表的第pos个节点的前面插入一个新的节点，该节点的值为val；
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)
    return false;

PNODE pNew = (PNODE) malloc(sizeof(NODE));
if(NULL==pNew)
{
  printf("动态分配内存失败！\n");
  exit(-1);
}
pNew->data=val;
PNODE q=p->pNext;
p->pNext=pNew;
pNew->pNext=q;

return true;
}
//删除第pos个元素
bool delect_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)
    return false;

PNODE q = p->pNext;
*pval= q->data;
//删除p节点后面的节点
p->pNext=p->pNext->pNext;
free(q);
q=NULL;

return true;
}