C语言（数据结构）高手进，顺序表及链表的问题

1.顺序表的后插（入）的C程序
2.单链表的头插（入）的C程序
3.单链表的在i的位置之后插（入）的C程序

答案：1.顺序表的具易做图置插入与尾插入（即追加）
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
 /* 顺序表的动态分配存储结构 */
typedef int ElemType;       //元素类型ElemType为int
#define Ok 1
#define OVERFLOW -1
#define LIST_INIT_SIZE 100  //顺序表初始容量(能容纳的元素个数)
#define LISTINCREMENT   10  //容量增量
//定义顺序表类型SqList：
typedef struct
{ElemType *elem; //存储空间基址(顺序表的起址)
 int length;     //当前长度
 int listsize;   //当前容量
}SqList;
/* 初始化：构造一个空的顺序表L */
Status InitList_Sq(SqList *L)
{unsigned int nSize;
 nSize = LIST_INIT_SIZE * sizeof(ElemType);//[z1] 
 L->elem = (ElemType *)malloc(nSize);//分配初始的存储空间
 if (!L->elem)    //若未分配成功，
  exit(OVERFLOW); //则终止程序(退出码OVERFLOW)
 L->length = 0;                //初始长度
 L->listsize = LIST_INIT_SIZE; //初始容量
 return OK; 
}//InitList_Sq
/* 插入：在顺序表L的位置i前插入元素e
   若插入成功返回OK，否则返回ERROR。
   算法步骤：
   1: 若表容量不够则扩展
   2: 第n至i个元素后移一个位置
   3: e放入位置i
   4: 表长加1
*/
Status ListInsert_Sq(SqList *L, int i, ElemType e)
{unsigned int nSize;
 ElemType *newbase, *p, *q;
 
 if ((i < 1) || (i > L->length + 1)) //若位置i非法
  return ERROR;                      //则返回ERROR
 //若表容量不够则扩展:
 if (L->length >= L->listsize)  //若满容，
 {                              //则扩容：
  L->listsize += LISTINCREMENT; //新容量
  nSize = L->listsize * sizeof(ElemType);//[z2] 
  newbase = (ElemType *)realloc(L->elem,nSize);//[z3] 
  if (!newbase)      //若未分配成功，
   exit(OVERFLOW);   //则终止程序(退出码OVERFLOW)
  L->elem = newbase; //新的表起址
 }//end if
/* 追加：将数组a中的元素追加到表L中。
   其中a以ENDELEM作结束元素。
   (ENDELEM定义在PreDef.h中)
*/
void ListAppend_Sq(SqList *L, ElemType *a)
{int i = 0;
 while (a[i] != ENDELEM)
 {
  ListInsert_Sq(L, L->length + 1, a[i]);
  i++;
 }//end while
}//ListAppend_Sq
 
2、单链表的两种插入操作（这儿使用的是带头结点的单链表为例）
 
#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
 
#define Ok 1
#define OVERFLOW -1
 
/* 单链表存储结构 */
typedef char ElemType;//元素类型ElemType为char
//定义单链表类型LinkList：
typedef struct LNode
{ElemType data;      //数据域
 struct LNode *next; //指针域(链域)
}LNode, *LinkList;
/* 以上定义了单链表结点类型LNode及指向表结点的指针类型(单链表类型)Linklist。 
*/
 
/* 初始化：构造一个空的单链表L */
Status InitList_L(LinkList *L)  //[z1] 
{LNode *h;
 h = (LNode *)malloc(sizeof(LNode));//申请头结点空间
 if (!h)          //若未申请成功，
  exit(OVERFLOW); //则终止程序(退出码OVERFLOW)
 h->next = NULL;  //头结点链域置空
 *L = h;          //表头指针指向头结点
 return OK; 
}//InitList_L
/* 头插若干个结点，结点值v。
*/
void Headinsert_L(LinkList L, ElemType v)
{
 LNode *head, *p;
 ElemType c;
 head = L;  
 c = v;     //c指向当前结点值位置
 p = (LNode *)malloc(sizeof(LNode));//申请新结点空间
 p->data = c;   //新结点值
 p->next = head->next; 
 head->next = p;
 }//Headinsert
 
/* 按位序查找：(头结点看作第0个结点)
   找出单链表L的第i个结点并返回指向该结点的指针
   若i<0或i>表长，则返回NULL
*/
LNode *GetNode_L(LinkList L, int i)
{
 LNode *p;
 int c = 0; //计数器置0
 p = L;     //当前结点为头结点
 //从头结点开始搜索：
 while ((c < i) && (p->next != NULL))
 {//若未到位且下一结点存在，则搜索下一结点
  c++;        //计数器加1
  p = p->next;//下一结点作为当前结点
 }//end while
 if (c == i)  //若搜索了i步，
  return p;   //则返回最后搜索点；
 else         //否则，
  return NULL;//返回NULL
}//GetNode_L
/* 插入：在单链表L的位置i前插入元素e
   若插入成功返回OK，否则返回ERROR。
   算法步骤：
   1. 找出第i结点前驱pre
   2. 生成新结点
   3. 新结点值置为e
   4. 使新结点指向pre的后继
   5. 使pre指向新结点
*/
Status ListInsert_L(LinkList L,int i,ElemType e)
{LNode *pre, *pnew;
 pre = GetNode_L(L, i-1);//找出第i结点前驱
 if (!pre) return ERROR; //若未找到则退出
 pnew = (LNode *)malloc(sizeof(LNode));//申请新结点空间
 pnew->data = e;         //新结点值置为e
 pnew->next = pre->next; //新结点指向pre的后继
 pre->next = pnew;       //pre指向新结点
 return OK;
}//ListInsert_L
 

  1:
 void EndInsert(SqList *L,ElemType e)
{
/*没写表满的情况增加补上*/
    L->elem[L->length]=e;
    ++L->length;
}
  2:
void HeadInsert(LinkList L,ElemType e)
{
    LinkList p=L,s;
    s=(LinkList)malloc(sizeof(LNode));
    s->elem=e;
    s->next=p->next;
    p->next=s;
}
  3:
void ListInsert(LinkList L,int i,ElemType e)
{
    int j=0;
    LinkList p=L,s;
    while(p&&j<i)
    {
        ++j;p=p->next;
    }
    if(!p||j>i)
    return 0;
    s=(LinkList)malloc(sizeof(LNode));
    s->elem=e;
    s->next=p->next;
    p->next=s;
}
 
 
 
 
 

上一个：求《C语言入门经典》中文版，或《c程序设计教程》！
下一个：在C语言中，什么叫做面向对象，什么叫做面向过程？