Question

你好，感谢你刚才的回答，但是还是运行不对，可以麻烦你帮我改一下下面这个程序吗？

#include <stdio.h>
#include <stdlib.h>
typedef struct node //自定义链表结构体
{
int data;
struct node *next;
}LNode ;
LNode *create(int n)
{
LNode *head,*p,*q;
int i,m;
p=(LNode*)malloc(sizeof(LNode));
p->next=NULL;
head=p; //建立头结点
printf("Please enter %d integers:\n",n);
for(i=1;i<=n;i++)
{
q=(LNode*)malloc(sizeof(LNode));
scanf("%d",&m); //输入链表的data值
q->data=m;q->next=NULL;
p->next=q;p=q;
}
return head;
}
int DeleteLink(LNode* head,int i)
{
LNode *p,*q;
int j=0;
p=head;
while((p!=NULL)&&(j<i-1))
{
p=p->next;
j++;
}
if(p==NULL) return 0;
q=p->next;
p->next=q->next;
free(q);
return 0;
}
Print(LNode *head,int m) //输出函数
{
int i;
LNode *p;
p=head;
printf ("\n");
while (p->next!=NULL)
{
p=p->next;
printf ("%d ",p->data);
}
return 0;
}
int main ()
{
int n,i;
LNode *head,*p;
p=(LNode*)malloc(sizeof(LNode));
p->next=NULL;
head=p;
LNode *create(int);
int DeleteLink(LNode *, int);
int Print(LNode *,int);
printf("How many nodes do you want in this linklist?\n");
scanf("%d",&n);
create(n);
printf("Which node do you want to delete?\n");
scanf("%d",&i);
DeleteLink(head,i);
Print(head,n-1);
return 0;
}

Answer 1

代码太长，无暇细看。有一个关于链表基本操作的函数模版，发给你作为参考。希望对你有所帮助。

#include<stdio.h>
#include <stdlib.h>
#include <math.h>

/************************************************************************/
/* 常量定义                                                           */
/************************************************************************/
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1

/************************************************************************/
/* 线性表的单链表存储结构*/
/************************************************************************/
typedef struct LNode
{
     ElemType data;
     struct LNode *next;
}LNode, *LinkList;

//////////////////////////////////////////////////////////////////////////
//
// 带有头结点的单链表的基本操作(13个)
//
//////////////////////////////////////////////////////////////////////////

/************************************************************************/
/* 操作结果：构造一个空的线性表L */
/************************************************************************/
void InitList(LinkList *L)
{
     *L = (LinkList)malloc(sizeof(struct LNode)); /* 产生头结点，并使L指向此头结点 */
     if( !*L ) /* 存储分配失败 */
          exit(OVERFLOW);
     (*L)->next = NULL; /* 指针域为空 */
}

/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：销毁线性表L */                                                             
/************************************************************************/
void DestroyList(LinkList *L)
{
     LinkList q;
     while(*L)
     {
          q = (*L)->next;
          free(*L);
          *L=q;
     }
}
/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：将L重置为空表 */
/************************************************************************/
void ClearList(LinkList L) /* 不改变L */
{
     LinkList p, q;
     p = L->next; /* p指向第一个结点 */
     while(p) /* 没到表尾 */
     {
          q = p->next;
          free(p);
          p = q;
     }
     L->next = NULL; /* 头结点指针域为空 */
}

/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：若L为空表，则返回TRUE，否则返回FALSE */
/************************************************************************/
Status ListEmpty(LinkList L)
{
     /* 非空 */
     return (L->next) ? FALSE : TRUE;
}

/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数 */
/************************************************************************/
int ListLength(LinkList L)
{
     int i = 0;
     LinkList p = L->next; /* p指向第一个结点 */
     while(p) /* 没到表尾 */
     {
          i++;
          p = p->next;
     }
     return i;
}

/************************************************************************/
/* L为带头结点的单链表的头指针。*/
/* 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */
/************************************************************************/
Status GetElem(LinkList L, int i, ElemType *e) /* 算法2.8 */
{ 
     int j = 1; /* j为计数器 */
     LinkList p = L->next; /* p指向第一个结点 */
     while(p && j < i) /* 顺指针向后查找，直到p指向第i个元素或p为空 */
     {
          p = p->next;
          j++;
     }
     if( !p || j > i) /* 第i个元素不存在 */
          return ERROR;
     *e = p->data; /* 取第i个元素 */
     return OK;
}

/************************************************************************/
/* 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)*/
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
/************************************************************************/
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
     int i = 0;
     LinkList p = L->next;
     while(p)
     {
          i++;
          if(compare(p->data,e)) /* 找到这样的数据元素 */
               return i;
          p=p->next;
     }
     return 0;
}

/************************************************************************/
/* 初始条件: 线性表L已存在 */
/* 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱  */
/* 返回OK；否则操作失败，pre_e无定义，返回INFEASIBLE */
/************************************************************************/
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e)
{
     LinkList q, p = L->next; /* p指向第一个结点 */
     while(p->next) /* p所指结点有后继 */
     {
          q = p->next; /* q为p的后继 */
          if(q->data == cur_e)
          {
               *pre_e = p->data;
               return OK;
          }
          p = q; /* p向后移 */
     }
     return ERROR;
}

/*************************************************************************/
/* 初始条件：线性表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继*/
/* 返回OK; 否则操作失败，next_e无定义，返回INFEASIBLE */
/*************************************************************************/
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e)
{
     LinkList p = L->next; /* p指向第一个结点 */
     while(p->next) /* p所指结点有后继 */
     {
          if(p->data == cur_e)
          {
               *next_e = p->next->data;
               return OK;
          }
          p = p->next;
     }
     return ERROR;
}

/************************************************************************/
/* 在带头结点的单链线性表L中第i个位置之前插入元素e */
/************************************************************************/
Status ListInsert(LinkList L, int i, ElemType e)
{
     int j = 0;
     LinkList p = L, s;
     while( p && j < i-1) /* 寻找第i-1个结点 */
     {
          p = p->next;
          j++;
     }
     if( !p|| j > i-1) /* i小于1或者大于表长 */
          return ERROR;
     s = (LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
     s->data = e; /* 插入L中 */
     s->next = p->next;
     p->next = s;
     return OK;
}

/************************************************************************/
/* 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值               */
/************************************************************************/
Status ListDelete(LinkList L, int i, ElemType *e)
{
     int j = 0;
     LinkList p = L, q;
     while(p->next && j < i-1) /* 寻找第i个结点，并令p指向其前岖 */
     {
          p = p->next;
          j++;
     }
     if( !p->next || j > i-1) /* 删除位置不合理 */
          return ERROR;
     q = p->next; /* 删除并释放结点 */
     p->next = q->next;
     *e = q->data;
     free(q);
     return OK;
}

/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi() */
/************************************************************************/
void ListTraverse(LinkList L, void(*vi)(ElemType))
{
     LinkList p = L->next;
     while(p)
     {
          vi(p->data);
          p = p->next;
     }
     printf("\n");
}

/************************************************************************/
/* 初始条件：线性表L已存在。打印链表的data域 */
/************************************************************************/
void ListPrint(LinkList L)
{
     LinkList p = L->next;
     while(p)
     {
          printf("%d ", p->data);
          p = p->next;
     }
     printf("\n");
}

void printInt(int data)
{
     printf("%d ", data);
}

/************************************************************************/
/* 插入排序 */
/************************************************************************/
void ListSort(LinkList L)
{
     LinkList first; /*为原链表剩下用于直接插入排序的节点头指针*/
     LinkList t; /*临时指针变量：插入节点*/
     LinkList p; /*临时指针变量*/
     LinkList q; /*临时指针变量*/
     first = L->next; /*原链表剩下用于直接插入排序的节点链表*/
     L->next = NULL; /*只含有一个节点的链表的有序链表。*/
     while (first != NULL) /*遍历剩下无序的链表*/
     {
          /*无序节点在有序链表中找插入的位置*/
          for (t = first, q = L; ((q!=NULL) && (q->data < t->data)); p = q, q = q->next);
          /*退出for循环，就是找到了插入的位置*/
          first = first->next; /*无序链表中的节点离开，以便它插入到有序链表中。*/
          if (q == L)
               L = t; /*插在第一个节点之前*/
          else
               p->next = t; /*p是q的前驱*/ 
          t->next = q; /*完成插入动作*/
     }
}

void main()
{
     LinkList L;
     int e;
     InitList(&L);
     ListInsert(L, 1, 2);
     ListInsert(L, 1, 3);
     ListInsert(L, 1, 67);
     ListInsert(L, 1, 6);
     ListInsert(L, 1, 5);
     ListDelete(L, 2, &e);
     ListSort(L);
     ListTraverse(L, printInt);
}