顺序表

一、线性表的定义       
        定义n个数据元素的有限序列，记作（a1, a2, …, an）ai 是表中数据元素，n 是表长度
        线性表的特点
        除第一个元素外，其他每一个元素有一个且仅有一个直接前驱。

        除最后一个元素外其他每一个元素有一个且仅有一个直接后继。

二、顺序表的定义和特点
        定义  将线性表中的元素相继存放在一个连续的存储空间中。           
        可利用一维数组描述存储结构
        特点   线性表的顺序存储方式

        遍历   顺序访问, 可以随机存取  

三、下面整理一些顺序表的程序

        1、第一个是头文件SequenceList.h

         

#ifndef  _SEQUENCE_H_
#define  _SEQUENCE_H_    （防止重新定义）

#define  MAXSIZE   10

#define  FAILURE    1000000
#define  SUCCESS    1000001
#define  TRUE       1000002
#define  FALSE      1000003

typedef  int  Elemtype;

struct  sequence    (创建结构体)
{
    Elemtype *data;
    int length;
    int size;
}；
typedef struct sequence SeList;（换成新类型名）

int ListInit(SeList *s);
int InsertList(SeLsit *s,int i, Elemtype e);
int ListLength(SeList s);
int EmptyList(SeList s);
int GetElem(SeList s);
int ListTraverse(SeList s, void(*look)(Elemtype));
int LocateElem(SeList s,Elemtype e, int(*compare)(Elemtype,Elemtype));
int ListDelete(SeList *s,int delete,Elemtype *e);

#end if

2、第二个是main.c文件

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

void visit(Elemtype e)

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

int equal(Elemtype a, Elemtype b)
{
	return (a == b) ? TRUE:FALSE;
}

int main()
{
	int ret;
	int i;
	int place;
        Elemtype e;
	SeList SList;
        int delete;

	ret = ListInit(&SList);

	if(SUCCESS == ret)
	{
		printf("Init Sucess!\n");
	}
	else
	{
		printf("Init Failure!\n");
	}

	for(i = 0; i < MAXSIZE; i++)
	{
	    ret = InsertList(&SList, i, i+1);
	    if(SUCCESS == ret)
	    {
	        printf("Insert %d Success\n",i);
	    }
	    else 
	        printf("Insert %d Failure\n",i);
	}

	ret = ListLength(SList);
	printf("%d\n",ret);

	ret = EmptyList(SList);
	if(ret == TRUE)
	{
		printf("empty!\n");
	}

	else if(ret == FALSE)
	{

	printf("List is not empty!\n");
	}

        place = 3;
	ret = GetElem(SList, place);
	if(ret == FALSE)
	{

	 printf("Get %d place failure!\n",place);
	}

	else
        printf("%d element is %d\n",place,ret);

        ret = ListTraverse(SList,visit);
        if(SUCCESS == ret)
   	{
	   printf("Traverse Success!\n");
   	}
  	 else
   	{
	   printf("Traverse Failure!\n");
  	 }


  	 e = 3;
  	 ret = LocateElem(SList, e,equal);
	 if(FAILURE == ret)
	   {
		   printf("Not Found!\n");
	   }
	   else
	   {
		   printf("%d is %dth element!\n",e,ret);
	   }

	   delete = 3;
	   ret = ListDelete(&SList,delete,&e);
	   
	   if(SUCCESS == ret)
	   {
		   printf("%d element is delete %d\n",delete,e);
	   }
	   else
	   {
		   printf("delete %d element failure!\n",delete);
	   }

	return 0;
}

3、第三个是接口函数文件

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

int ListInit(SeList *s)         （构造空表）
{
	s->data = (Elemtype *)malloc(sizeof(Elemtype)*MAXSIZE);
	if(NULL == s->data)
	{
	  return FAILURE;
	}
	s->size = MAXSIZE;              （初始化）
	s->length = 0;

	return SUCCESS;
}

int InsertList(SeList *s,int i,Elemtype e)   （向表中插入元素）
{
	int k;
	if((i < 0 || i >= MAXSIZE) || s->length > MAXSIZE)
	{
	    return FAILURE;
	}

	for(k = 0; k < s->length-i; k++)
	{
	    s->data[s->length-k] = s->data[s->length -k -1]; （向后移一位）
	}

	    s->data[i] = e;
            s->length++;
	    return SUCCESS;
}

int ListLength(SeList s)         （获取长度）
{
	return s.length;
}
int EmptyList(SeList s)           （判断是否为空）
{
    return (s.length == 0) ? TRUE : FALSE;
}

int GetElem(SeList s,int p)        （返回某个元素值）
{
	int m = 0;
	if(p < 0 || p >= MAXSIZE)
	{
	    return FALSE;
	}
	m = s.data[p];
	return m;
}
int ListTraverse(SeList s, void (*look)(Elemtype))     （遍历表中的值）
{
	int i;
	for(i = 0; i < s.length; i++)
	{
	    look(s.data[i]);
	}
	return SUCCESS;

	
}

int LocateElem(SeList s,Elemtype e,int (*compare)(Elemtype,Elemtype))   （返回表中第一个与e满足关系compare()的数据元素的位序）
{
	int i;

	for(i = 0; i < s.length; i++)
	{
		if(compare(e,s.data[i]) == TRUE)
		{
		    return i;
		}
	}
	return FAILURE;
}

int ListDelete(SeList *s,int delete ,Elemtype *e )          （删除表中的第i个元素）
{
	int i;
	
	*e = s->data[delete];
	for(i = 0; i < s->length-delete-1; i++) 
	{ 
	    s->data[delete+i] = s->data[delete+i+1];         （后一位移到前一位）      
	}
	s->length--;
	return SUCCESS;
}