线性表链式存储结构实现--静态链表

#ifndef _STATICK_LINCKLIST_H_
#define _STATICK_LINCKLIST_H_
#pragma once

/************************************************************************/
/*		线性表链式存储结构实现 --静态链表                       */
/************************************************************************/
typedef struct SLinkNode
{
	ElemType data;
	int Next;
}SLinkNode,StaticLinkList[MaxCapacity];

//typedef SLinkNode[MaxCapacity] ;

/**初始化操作，建立一个空的线性表L。*/
Status InitList(StaticLinkList L);

/**采用头插法初始化链表，建立一个包含n个元素的线性表L。*/
Status CreateListHead(StaticLinkList L , int n);

/**采用尾插法初始化链表，建立一个包含n个元素的线性表L。*/
Status CreateListTail(StaticLinkList L , int n);

/**若线性表为空，返回true，否则返回false*/
bool ListEmpty(StaticLinkList L);

/**将线性表清空*/
Status ClearList(StaticLinkList L);

/**将线性表中第i个位置元素值返回给e*/
Status GetElem(StaticLinkList L,int i,ElemType* e);

/**在线性表中查找与给定值e相等的元素，如果查找成功，返回该元素在线性表中的序号表示成功；否则返回-1表示失败*/
int LocateElem(StaticLinkList L ,ElemType e);

/**在线性表中的第i个位置插入元素e*/
Status ListInsert(StaticLinkList L,int i,ElemType e);

/**删除线性表中第i个位置的元素，并返回这个位置的元素值e*/
Status ListDelete(StaticLinkList L,int i,ElemType* e);

/**返回线性表L的元素个数*/
int ListLength(StaticLinkList L);

/**遍历链表元素*/
Status TraverseList(StaticLinkList L);

/**为新元素分配存储空间*/
int Malloc_SSL(StaticLinkList L);

/**释放第i个元素所占存储空间*/
Status Free_SSL(StaticLinkList L,int i);

#endif//_STATICK_LINCKLIST_H_

#include "stdafx.h"
#include "StaticLinkList.h"

/**初始化操作，建立一个空的线性表L。*/
Status InitList(StaticLinkList L)
{
	for (int i = 0 ; i < MaxCapacity ; i++)
	{
		L[i].Next = i+1;
	}
	L[MaxCapacity -1].Next = 0;
	
	return OK;
}

/**采用头插法初始化链表，建立一个包含n个元素的线性表L。*/
Status CreateListHead(StaticLinkList L , int n)
{
	if(n >= MaxCapacity-2)
		return ERROR;

	InitList(L);
	int next = L[MaxCapacity-1].Next;
	for (int i = 0 ; i < n ; i++)
	{
		int j = Malloc_SSL(L);
		L[j].data = i;
		L[j].Next = next;		
		next = j;
		L[MaxCapacity-1].Next = j;
	}
	return OK;
}

/**采用尾插法初始化链表，建立一个包含n个元素的线性表L。*/
Status CreateListTail(StaticLinkList L , int n)
{
	if(n >= MaxCapacity-2)
		return ERROR;

	InitList(L);
	int firstIndex = L[MaxCapacity-1].Next;
	int index = firstIndex;
	for (int i = 0 ; i < n ; i++)
	{
		int j = Malloc_SSL(L);
		L[j].data = i;
		L[j].Next = firstIndex;
		index = j;
		if(i == 0)
			L[MaxCapacity-1].Next = j;
		else
			L[index].Next = j;
	}
	return OK;
}

/**若线性表为空，返回true，否则返回false*/
bool ListEmpty(StaticLinkList L)
{
	return L[MaxCapacity -1].Next == 0 ?true:false;
}

/**将线性表清空*/
Status ClearList(StaticLinkList L)
{
	if(ListEmpty(L))
		return OK;
	
	int k = L[MaxCapacity-1].Next;
	int count = 0;
	while(k != 0)
	{
		L[MaxCapacity-1].Next = L[k].Next;
		Free_SSL(L,k);
		k = L[k].Next;
	}

	return OK;
}

/**将线性表中第i个位置元素值返回给e*/
Status GetElem(StaticLinkList L,int i,ElemType* e)
{
	if(i >= MaxCapacity || i <=0 ||ListEmpty(L))
		return ERROR;

	int k = L[MaxCapacity-1].Next;
	int count = 0;
	while(k != 0)
	{
		if(count == i)
			break;
		count++;
		k = L[k].Next;
	}
	if(count != i)
		return ERROR;

	*e =  L[k].data;

	return OK;
}

/**在线性表中查找与给定值e相等的元素，如果查找成功，返回该元素在线性表中的序号表示成功；否则返回-1表示失败*/
int LocateElem(StaticLinkList L ,ElemType e)
{
	if(ListEmpty(L))
		return ERROR;

	int k = L[MaxCapacity-1].Next;
	int index = 0;
	while(k != 0)
	{
		if(L[k].data == e)
			break;

		index++;
		k = L[k].Next;
	}
	if(k == 0)
		return -1;

	return index;
}

/**在线性表中的第i个位置插入元素e*/
Status ListInsert(StaticLinkList L,int i,ElemType e)
{
	if(i >= MaxCapacity || i <=0)
		return ERROR;

	int k = L[MaxCapacity-1].Next;
	int count = 0;
	while(k != 0)
	{
		if(count == i)
			break;
		count++;
		k = L[k].Next;
	}
	if(count != i)
		return ERROR;

	int j = Malloc_SSL(L);
	L[j].data = e;
	L[j].Next = L[k].Next;
	L[k].Next = j;

	return OK;
}

/**删除线性表中第i个位置的元素，并返回这个位置的元素值e*/
Status ListDelete(StaticLinkList L,int i,ElemType* e)
{
	if(i >= MaxCapacity || i <=0)
		return ERROR;

	int k = L[MaxCapacity-1].Next;
	int count = 0;
	while(k != 0)
	{
		if(count == i-1)
			break;
		count++;
		k = L[k].Next;
	}
	if(count != i-1)
		return ERROR;

	int next = L[k].Next;
	*e = L[next].data;
	L[k].Next = L[next].Next;
	Free_SSL(L,next);
	
	return OK;
}

/**返回线性表L的元素个数*/
int ListLength(StaticLinkList L)
{
	int i = 0;
	int next = L[MaxCapacity-1].Next;
	while(next != 0)
	{
		i++;
		next = L[next].Next;
	}

	return i;
}

/**遍历链表元素*/
Status TraverseList(StaticLinkList L)
{
	if(ListEmpty(L))
		return ERROR;

	int i = 0;
	int next = L[MaxCapacity-1].Next;
	while(next != 0)
	{
		std::cout<<"第"<<i++<<"个元素为："<<L[next].data<<std::endl;
		next = L[next].Next;
	}

	return OK;
}

/**为新元素分配存储空间*/
int Malloc_SSL(StaticLinkList L)
{
	int newLocation = L[0].Next;
	L[0].Next = L[newLocation].Next;
	return newLocation;
}

/**释放第i个元素所占存储空间*/
Status Free_SSL(StaticLinkList L,int i)
{
	int firstLoc = L[0].Next;
	L[i].Next = firstLoc;
	L[0].Next = i;
	return OK;
}