线性表、栈、队列

顺序线性表：

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

typedef int ElemType;             //声明新类型名
typedef struct List
{
    ElemType * elem;
    int length;
    int maxsize;
}Sqlist;
 
void Init_Sqlist(Sqlist &L)         // 构造空线性表
{
    L.elem = (ElemType *)malloc(100 * sizeof(ElemType));
    if(!L.elem)      exit(-1);
    L.maxsize = 100;
    L.length = 0;
}
 
void DestroyList(Sqlist &L)           // 销毁线性表
{
    if(L.elem)             free(L.elem);
}
 
int GetLength(Sqlist L)  
{
    return (L.length);
}
 
void GetElem(Sqlist L,int i,ElemType &e)                // 用e返回L中第i个元素的值
{
    if(i<0 || i>L.length)     e = -1;
    e = L.elem[i-1];
}
 
void SqlistInsert(Sqlist &L,int i,ElemType e)        //   插入 在L中第i个位置之前插入新的元素e，L的长度加1
{
    int j;
    if(i<1 ||i>L.length+1)          exit(-1);
    if(L.length >= L.maxsize){
        L.elem = (ElemType * ) realloc (L.elem, (10 + 100)* sizeof(ElemType));
        if(!L.elem)         exit(-1);
        L.maxsize += 10;
    }
    for(j = L.length;j>=i-1;j--)
    {
        L.elem[j+1]  = L.elem[j];
    }
    L.elem[j+1] = e;
    L.length += 1;
}
 
void SqlistDelete (Sqlist &L,int i,ElemType &e)      // 删除 在L中删除出第i个数据元素，并用e返回其值，L的长度减1
{
 int j;
 if((i<1)||(i>L.length))      exit(-1);
if(L.length>L.maxsize)
   {
    L.elem=(ElemType *) realloc (L.elem,10*sizeof(ElenType));
     if(!L.elem)  exit(-1);
     L.maxsize+=10;
   }
   for(j=L.length;j<=i-1;j--)
   {
    L.elem[j-1]=L.elem[j];
   }
   L.elem[j+1]=e;
     L.length -= 1;
}
void PrintSqList(Sqlist L)             //输出链表
{    int i;
    for(i = 0;i<L.length;i++)
    {
        printf("%d ",L.elem[i]);
    }
}
 
int main()
{
    Sqlist L;
    int e;
    Init_Sqlist(L);
    int i;
    for(i = 1;i<=5;i++)
    {
        scanf("%d",&e);
        SqlistInsert(L,i,e);
    }
    PrintSqList(L);
    return 0;
}

链式线性表：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
 
typedef int ElemType;
typedef struct Node{
    ElemType data;
    struct Node * next;
}* Linklist;
 
void InitLinklist (Linklist &L){
    L = NULL;
}
 
void LinklistInsert1 (Linklist &L ,ElemType e)        //插入在链表的开头 (L为头指针)
{
    Linklist s ;
    s = (Linklist) malloc (sizeof(struct Node));
    s->data = e;
    s->next = L;
    L = s;   
}
void LinklistInsert2 (Linklist &L,int i,ElemType e){
    Linklist p=L ;
    int j = 0;
    while(p && j<i-1){
        p = p->next;
        j++;
    }
    if(!p|| j>i-1){
        Linklist s = (Linklist) malloc (sizeof(struct Node));
        s->data = e;
        s->next = p->next;
        p->next = s;
    }
}
 
void LinklistDelete(Linklist &L,int i,ElemType &e){
    int j=0;
    Linklist p, q;
    p  = L;
    while(p->next && j<i-1){
        p = p->next;
        j++;
    }
    if(! (p->next) || j>i-1){
        q = p->next;
        p->next=q->next;      //  或者 p->next=p->next->next
        e = q->data;
        free(q);
    }
}
 
void PrintLinklist(Linklist L){
    Linklist p;
    p = L;
    while(p){
        printf("%d ",p->data);
        p = p->next;
    }
}
 
void LinklistFind(Linklist L,int i,ElemType &e){
    int j=0;
    Linklist p=L;
    while(p && j<i-1){
        p=p->next;
        j++;
    }
    if(p && i>=0){
        e = p->data;
    }
    else e = -1;
}
 
int main(){
    int i;
    int e;
    Linklist  L;
    InitLinklist(L);
    for(i=1;i<=4;i++){
        LinklistInsert( L,i);
    }
    LinklistFind(L,1,e);
    printf("%d\n",e);
    LinklistDelete(L,3,e);
    printf("%d\n",e);
    PrintLinklist(L);
    LinklistInsert2(L,2,2);
    PrintLinklist(L);
    return 0;
}

顺序栈：

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
   
typedef int ElemType;  
typedef struct {  
 ElemType * base;  
 ElemType * top;  
 int  maxstacksize;  
}Stack;  
   
int   Empty_Stack(Stack  S) {  
 return  (S.top == S.base ? 1:0);  
}  
   
void   Init_Stack(Stack &S)           //构造一个空栈S  
{     
   S.base = (ElemType *) malloc (100 * sizeof(ElemType));  
   if(!S.base )   exit(-1);         //分配失败，异常输出  
   S.top = S.base;  
   S.maxstacksize = 100;  
}  
   
void   Push_Stack(Stack &S, ElemType e)      //插入元素e为新的栈顶元素  
{  
  if(S.top - S.base >= S.maxstacksize) {  
  S.base = (ElemType *) realloc (S.base, (100 +10)*sizeof(ElemType));  
  if(!S.base)      exit(-1);  
   S.top = S.base + S.maxstacksize;  
   S.maxstacksize += 10;  
   }  
   *(S.top ++ )= e;  
}  
   
void  Pop_Stack(Stack &S, ElemType &e)             //删除S的栈顶元素，用e返回  
{  
 if(Empty_Stack(S))    e = -1;  
 e = *(--S.top);  
}  
   
void Get_Top(Stack S, ElemType &e)                     // 用e返回栈顶元素  
{  
 if(Empty_Stack(S) )       e = -1;  
 e =  * (S.top - 1);  
}  
  
int main(){  
 Stack S;  
 int i,e;  
 Init_Stack(S);  
 for(i=1;i<=5;i++){  
  Push_Stack(S,i);  
 }  
 Pop_Stack(S,e);  
 Get_Top(S,e);  
 printf("%d\n",e);  
 while(!Empty_Stack(S)){  
  Pop_Stack(S,e);  
  printf("%d\n",e);  
 }  
 return 0;  
}  

链式栈：

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
  
typedef int ElemType;  
typedef struct Node{  
 ElemType data;  
 struct Node * next;  
} *Stack;  
   
int  Empty_Stack(Stack S){  
 return (S == NULL ? 1 : 0) ;  
}  
   
void  Init_Stack(Stack &S)          //  构造空栈  
{  
 S = NULL;  
}  
    
void Get_Top(Stack S,ElemType & e){  
 if(Empty_Stack(S)) e = -1;  
 else e = S->data;  
}  
   
void Push_Stack(Stack &S,ElemType e)      //  存入数据  
{  
    Stack p;  
 p= (Stack) malloc(sizeof(struct Node));  
 p->data = e;  
 p->next = S;       // 或者 (*p).next = s;  
 S = p;  
}  
   
void  Pop_Stack(Stack &S,ElemType &e)          // 取出数据  
{  
 if (Empty_Stack(S))        exit(-1)；  
 else{  
  e = S->data;  
  S = S->next;  
 }  
}  
  
int main(){  
 Stack S;  
 Init_Stack(S);  
 int n;  
 ElemType e;  
 while(scanf("%d",&n)!=EOF){  
  while(n){  
   Push_Stack(S,n%2);  
   n /= 2;  
  }  
  while(!Empty_Stack(S)){  
   Pop_Stack(S,e);  
   printf("%d",e);  
  }  
  printf("\n");  
 }  
 return 0;  
}  

顺序队列：

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
   
typedef int ElemType;  
typedef struct Node  
{  
 ElemType *base;  
 int    front,rear;  
}Queue;  
   
int EmptyQueue(Queue &Q)  
 {  
    if(Q.front%100 == Q.rear)    return 1;  
    else         return 0;  
 }  
   
void  InitQueue(Queue &Q)  
{  
 Q.base=(ElemType*) malloc (100*sizeof(ElemType));  
 if(!Q.base)    exit(-1);  
 Q.front=0;  
 Q.rear=0;  
}  
   
void EnQueue(Queue &Q,ElemType e)  
{  
 if((Q.rear+1)%100==Q.front)    exit (-1);     // 队列已满  
 e=Q.base[Q.rear];  
 Q.rear=(Q.rear+1)%100;  
}  
   
void DeQueue(Queue &Q,ElemType &e)  
{  
 if(Q.front==Q.rear) exit (-1);        //队列已空  
 e=Q.base[Q.front];  
 Q.front=(Q.front+1)%100;  
}  
   
int main()  
{  
   return 0;  
}  

链式队列：

#include<stdio.h>  
#include<stdlib.h>  
#include<malloc.h>  
   
typedef int ElemType;  
typedef struct Node  
{  
 ElemType date;  
 struct Node * next;  
}QNode,*Queue;  
typedef struct{  
 Queue front,rear;  
}LinkQueue;  
   
void InitQueue(LinkQueue &Q)  
{  
 Q.front=Q.rear=(Queue)malloc (sizeof(QNode));  
 if(!Q.front) exit (-1);  
 Q.front->next=NULL;  
}  
   
void EnQueue(LinkQueue &Q,ElemType &e)         //入列  
{  
 Queue p;  
  p=(Queue) malloc(sizeof(QNode));  
 if(!p)  exit(-1);  
 p->date=e;  
 p->next=NULL;  
 Q.rear->next=p;  
  Q.rear=p;  
}  
   
void DeQueue(LinkQueue &Q,ElemType &e)           // 出列  
{    
 Queue p;  
 if(Q.front==Q.rear)  exit(-1);  
 p=Q.front->next;  
 e=p->date;  
 Q.front->next=p->next;  
 if(Q.rear==p)      Q.rear=Q.front;  
 free(p);  
}  
   
int main()  
{  
  return 0;  
}