线性结构 顺序表

头文件

#ifndef _SEQUENCELIST_H_
#define _SEQUENCELIST_H_

#define SIZE       10
#define FAILURE    10000
#define SUCCESS    10001

typedef int DataType;

struct SequenceList
{ 
 DataType *data;
 int length;
};
typedef struct SequenceList List;

int InitSequence(List *l);
int EmptySequence(List l);
int InsertSequence(List *l, int p, DataType e);
int TraverseSequence(List l, void (*p)(DataType));
DataType GetElem(List l, int p, DataType *e);
int LocateElem(List l, DataType e, int(*p)(DataType, DataType));
DataType PriorElem(List l, DataType e);
DataType NextElem(List l, DataType e);
int DeleteSequence(List *l, int p, DataType *e);
int LengthSequence(List l);
int ClearSequence(List *l);
int DestroySequence(List *l);
#endif

函数调用

#include <stdio.h>
#include "SequenceList.h"
#include <stdlib.h>

int InitSequence(List *l)
{
 l->data = (DataType *)malloc(sizeof(DataType) * SIZE);
 if (NULL == l->data)
 { 
  return FAILURE;
 }

 l->length = 0;

 return SUCCESS;
}

int EmptySequence(List l)
{
 //return (l.length == 0) ? SUCCESS : FAILURE;

 if (0 == l.length)
 {
  return SUCCESS;
 }
 else
 {
  return FAILURE;
 }
}

int InsertSequence(List *l, int p, DataType e)
{
 int i;

 if (NULL == l->data || NULL == l || p <= 0 || p > l->length + 1 || l->length >= SIZE)
 {
  return FAILURE;
 }

 for (i = 0; i < l->length - p + 1; i++)
 {
  l->data[l->length - i] = l->data[l->length - i - 1];
 }

 l->data[p - 1] = e;
 l->length++;

 return SUCCESS;
}

int TraverseSequence(List l, void(*p)(DataType))
{
 int i;

 for (i = 0 ; i < l.length; i++)
 {
  p(l.data[i]);
 }

 return SUCCESS;
}

DataType GetElem(List l, int p, DataType *e)
{
 if (p <= 0 || p > l.length)
 {
  return FAILURE;
 }

 //*e = l.data[p - 1];
 *e = *(l.data + p - 1);

 return SUCCESS;
}

int LocateElem(List l, DataType e, int(*p)(DataType, DataType))
{
 int i;

 for (i = 0; i < l.length; i++)
 {
  if (p(e, l.data[i]))
  {
   return i + 1;
  }
 }

 return FAILURE;
}

DataType PriorElem(List l, DataType e)
{
 int i;

 for (i = 1; i < l.length; i++)
 {
  if (e == l.data[i])
  {
   return l.data[i - 1];
  }
 }

 return FAILURE;
}

DataType NextElem(List l, DataType e)
{
 int i;

 for (i = 0; i < l.length - 1; i++)
 {
  if (e == l.data[i])
  {
   return l.data[i + 1];
  }
 }

 return FAILURE;
 
}

   
int DeleteSequence(List *l, int p, DataType *e)
{
 int i;
 if (NULL == l || p <= 0 || p > l->length)
 {
  return FAILURE;
 }

 *e = l->data[p - 1];
 for (i = 0; i < l->length - p; i++)
 {
  l->data[p - 1 + i] = l->data[p + i];
 }
 l->length--;

 return SUCCESS;
}

int LengthSequence(List l)
{
 return (l.length);
}

int ClearSequence(List *l)
{
 l->length = 0;

 return SUCCESS;
}

int DestroySequence(List *l)
{
 free(l->data);
 l->data = NULL;

 return SUCCESS;
}

主函数main

#include <stdio.h>
#include "SequenceList.h"

void visit(DataType e)

{                
 printf("%d ", e);
}

int Equal(DataType a, DataType b)
{
 return (a == b) ? 1 : 0;
}

int main()
{
 int ret, i, p;
 List list;                             
 DataType e;

 ret = InitSequence(&list);             
 if (FAILURE == ret)
 {
  printf("Init Failure!\n");
 }
 else
 {
  printf("Init Success!\n");
 }

 ret = EmptySequence(list);
 if (SUCCESS == ret)
 {
  printf("Sequence Empty!\n");
 }
 else
 {
  printf("Sequence not Empty!\n");
 }
 
 for (i = 0; i < 8; i++)
 {
  ret = InsertSequence(&list, i + 1, i + 1);  
  if (FAILURE == ret)
  {
   printf("Insert %d Failure!\n", i + 1);
  }
  else
  {
   printf("Insert %d Success!\n", i + 1);
  }
 }

 ret = EmptySequence(list);                   if (SUCCESS == ret)
 {
  printf("Sequence Empty!\n");
 }
 else
 {
  printf("Sequence not Empty!\n");
 }

 ret = TraverseSequence(list, visit);                 if (FAILURE == ret)
 {
  printf("Traverse Failure!\n");
 }
 else
 {
  printf("\nTraverse Success!\n");
 }

 p = 13;                        
 ret = GetElem(list, p, &e);     if (FAILURE == ret)
 {
  printf("Get %dth Element Failure!\n", p);
 }
 else
 {
  printf("%dth Element is %d\n", p, e);
 }

 e = 14;
 ret = LocateElem(list, e, Equal);     
 if (FAILURE == ret)
 {
  printf("Locate %d Failure!\n", e);
 }
 else
 {
  printf("%d is %dth Element!\n", e, ret);
 }

 e = 12;
 ret = PriorElem(list, e);
 if (FAILURE == ret)
 {
  printf("%d has no prior!\n", e);
 }
 else
 {
  printf("%d Prior is %d\n", e, ret);
 }

 e = 8;
 ret = NextElem(list, e);
 if (FAILURE == ret)
 {
  printf("%d has no next!\n", e);
 }
 else
 {
  printf("%d Next is %d\n", e, ret);
 }

 for (i = 0; i < 3; i++)
 {
  ret = DeleteSequence(&list, 1, &e);
  if (FAILURE == ret)
  {
   printf("Delete Failure!\n");
  }
  else
  {
   printf("Delete %d Success!\n", e);
  }
 }
 
 ret = TraverseSequence(list, visit);                if (FAILURE == ret)
 {
  printf("Traverse Failure!\n");
 }
 else
 {
  printf("\nTraverse Success!\n");
 }

 printf("Sequence Length %d\n", LengthSequence(list));

 ret = ClearSequence(&list);
 if (FAILURE == ret)
 {
  printf("Clear Failure!\n");
 }
 else
 {
  printf("Clear Success!\n");
 }

 ret = DestroySequence(&list);
 if (FAILURE == ret)
 {
  printf("Destroy Failure!\n");
 }
 else
 {
  printf("Destroy Success!\n");
 }

 for (i = 0; i < 8; i++)
 {
  ret = InsertSequence(&list, i + 1, i + 1);  
  if (FAILURE == ret)
  {
   printf("Insert %d Failure!\n", i + 1);
  }
  else
  {
   printf("Insert %d Success!\n", i + 1);
  }
 }

 return 0;
}