单链表的创建和遍历

//24
#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{}*
*/
typedef struct Node{
 int data;//数据域
 struct Node *pNext;//指针域，这是一个指针，且类型是指向和自己类型一样的 。

}NODE,*PNODE;//NODE就是struct Node{}  PNODE等价于struct Node{}*

//函数的声明
 PNODE create_list();
 //遍历输出
 void taverse_list(PNODE pHead);
 bool is_empty(PNODE pHead);//是否满

 int length_list(PNODE pHead);//长度

 void sort_list(PNODE);//排序

 bool insert_list(PNODE pHead, int pos, int val);//插入 1链表  2,位置 3，插入的值
 bool delete_list(PNODE pHead, int pos, int  *pval);//删除 1链表  2,位置 3，删的结果放在第3个参数里面

 int main(){
  PNODE pHead=NULL;//等价于struct Node * pHead=null;
  int len;
  int pval;
  pHead=create_list();//创建一个非循环单链表，并将该链表的头结点的地址赋pHead
  taverse_list(pHead);//遍历，不用返回值，但是一定需要参数

  if(is_empty(pHead))printf("链表为空");
  else{printf("链表不为空");}

  len=length_list(pHead);
  printf("链表长度是：%d\n",len);

  sort_list(pHead);
  taverse_list(pHead);

  insert_list(pHead,3,1111);
  taverse_list(pHead);
  printf("删除元素开始:\n");
  //删了之后放的位置
  if(delete_list(pHead, 4, &pval)){
   printf("删除成功，你删的是 %d",pval);
    
  }else{printf("删除失败，你删的不存在");}

  return 0;
 }
 //返回值是一个地址，不需要参数
 PNODE create_list(){
  int len;
  int i;
  int val;//有效节点的个数

  //1先要有一个头结点，再生成len的节点，每生成一个就将其挂在后面
  PNODE pHead=(PNODE)malloc(sizeof(NODE));
  if(pHead==NULL){
   printf("分配失败!\n");
   exit(-1);
  }
  //制造一个一直指向尾节点的指针
  PNODE pTail=pHead;
  pTail->pNext=NULL;

  printf("链表节点的个数：");
  scanf("%d",&len);

  for(i=0;i<len;++i){
   printf("请输入第%d节点的值",i+1);
   scanf("%d",&val);
   //2.每次都分配一个新的节点
   PNODE pNew=(PNODE)malloc(sizeof(NODE));
   if(pNew==NULL){
    printf("分配失败!\n");
    exit(-1);
   }
   //3.将pNew挂在上面；
   pNew->data=val;
   //cuowu!!pHead->pNext=pNew;
   //cuowu!!pNew->pNext=NULL;
   pTail->pNext=pNew;
   pNew->pNext=NULL;
   pTail=pNew;

  }
  return pHead;

 }
 //遍历输出
 void taverse_list(PNODE pHead){
  PNODE p=pHead->pNext;
  while(p!=NULL){
   printf("%d  ",p->data);
   p=p->pNext; 
  }
  printf("\n");
 }
 //A是否满
 bool is_empty(PNODE pHead){
  if(pHead->pNext==NULL){
   return true;
  }
  else return false;
 }
 //长度
 int length_list(PNODE pHead){
   PNODE p=pHead->pNext;
   int len=0;
  while(p!=NULL){
   ++len;
   p=p->pNext; 
  }
  return len;
 }

 //排序
 void sort_list(PNODE pHead){ 
 /* int i,j,t;
  for(i=0;i<len-1;++i){
   for(j=i+1;j<len;++j){ 
    if(a[i]>a[j]){
    t=a[j];
    a[j]=a[i];
    a[i]=t;
    
    }
   }  
  }
  */
  int i,j,t;
  int len=length_list(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[j];
    p->data=q->data;//a[j]=a[i];
    q->data=t;//a[i]=t;
    
    }
   }  
  }

 return ;
 }
 //插入 1链表  2,位置 3，插入的值
 //pos从1开始
 bool insert_list(PNODE pHead, int pos, int val){
  int i=0;
  PNODE p=pHead;

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

  PNODE pNew=(PNODE)malloc(sizeof(NODE));//分内存
  if(pNew==NULL)
  {
   printf("动态分配内存失败");
   exit(1);
  
  }
  pNew->data=val;//p指向 pos-1
  PNODE q=p->pNext;
  p->pNext=pNew;
  pNew->pNext=q;
  return true;
 }
 //删除 1链表  2,位置 3，删的结果放在第3个参数里面
 bool delete_list(PNODE pHead, int pos, int  *pval){
  int i=0;
  PNODE p=pHead;

  while(p->pNext!=NULL&&i<pos-1){
   p=p->pNext;
   i++;
  }
  if(i>pos-1||p->pNext==NULL)
   return false;
  PNODE q=p->pNext;
  *pval=q->data;//放
  //删
  p->pNext=p->pNext->pNext;
  free(q);
  q=NULL;
  return true;
 
 }