数据结构-线性表顺序存储（C/C++）

线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素。

这里分别通过C语言和C++分别实现了线性表顺序存储的如下功能：

        bool ListEmpty();//检测是否为空
void ClearList();//清空线性表
bool GetElem(int i,int *e);//查询第几个元素
int LocateElem(int e);//查找与e相等的元素
bool ListInset(int i,int e);//插入
bool ListDelete(int i,int *e);//删除
int ListLength();//计算长度
void traverseList();//遍历       

C语言实现如下：

#include<stdlib.h>
#include<stdio.h>
#define MAXSIZE 20

typedef struct
{
  int data[MAXSIZE];
  int length;
}List;

void InitList(List *L)
{
  L->length=0;
}

bool ListEmpty(List L)
{
  if(L.length==0)
    return true;
  else 
    return false;
}
void ClearList(List *L)
{
   L->length=0;
}
bool GetElem(List L,int i,int *e)
{
	if(L.length==0 || i<0 || i>L.length)
		return false;
	else
	{
     	*e=L.data[i-1];
        return true;
	}
   
}
int LocateElem(List L,int e)
{
   int i;
   if(L.length==0)
	   return 0;
   for(i=0;i<L.length;i++)
   {
	if(e==L.data[i])
         break;	
   }
   if(i>L.length-1)
	   return 0;
   else 
	   return i+1;
}
bool ListInset(List *L,int i,int e)
{
   int j;
   if(L->length==MAXSIZE)
        return false;
   if(i<1 || i>L->length+1)
	return false;
   if(i<=L->length)
   {
 	for(j=L->length;j>=i;j--)
	{
           L->data[j]=L->data[j-1];
	}
   }
   L->data[i-1]=e;
   L->length++;
   return true;
}
bool ListDelete(List *L,int i,int *e)
{
   int k;
   if(L->length==0)
   	return false;
   if(i<1 || i>L->length)
	return false;
   if(i<=L->length)
   {
 	*e=L->data[i-1];
	for(k=i;k<=L->length;k++)
	{
	    L->data[k-1]=L->data[k];
	}
   }
   L->length--;
   return true;
}
int ListLength(List L)
{
    return L.length;
}

void traverseList(List *L)
{
	int i;
	for(i=0;i<L->length;i++)
		printf("%d ",L->data[i]);
	printf("\n");
}

int main()
{
   List L;
   int e;
   int tmp;
   InitList(&L);
   ListInset(&L,1,1);
   ListInset(&L,2,2);
   ListInset(&L,3,3);
   traverseList(&L);
   tmp=LocateElem(L,3);
   printf("%d\n",tmp);
   ListDelete(&L,2,&e);
   traverseList(&L);
   printf("%d\n",e);
   return 0;
}

  C++实现如下如下：

       首先是List.h

#pragma once
class List
{
public:
	List(int size);
	~List();
	bool ListEmpty();//检测是否为空
	void ClearList();//清空线性表
	bool GetElem(int i,int *e);//查询第几个元素
	int LocateElem(int e);//查找与e相等的元素
	bool ListInset(int i,int e);//插入
	bool ListDelete(int i,int *e);//删除
	int ListLength();//计算长度
	void traverseList();//遍历

private:
	int m_length;
	int m_Size;
	int *m_data;	
};

   List.cpp

#include "List.h"
#include<iostream>
using namespace std;

List::List(int size)
{
   m_Size = size;  
   m_data = new int[m_Size];//分配内存  
   m_length = 0;  
}

List::~List()
{
    delete []m_data;
	m_data=NULL;
}

bool List::ListEmpty()
{
	if(m_length==0)
		return true;
	else 
		return false;
}

void List::ClearList()
{
	m_length=0;
}

bool List::GetElem(int i,int *e)//用指针传参
{
	if(m_length==0 || i<0 ||i>m_length)
		return false;
	else
	{
		*e=m_data[i-1];
        return true;
	}
   
}
int List::LocateElem(int e)
{
	int i;
	if(m_length==0)
		return 0;
	for(i=0;i<m_length;i++)
	{
		if(e==m_data[i])
			break;
	}
	if(i>m_length-1)   //注意边界
		return 0;
	else 
		return i+1;
}

bool List::ListInset(int i,int e)
{
	if(m_Size==m_length)
		return false;
	if(i<0 || i>m_length+1)//注意边界
		return false;
	if(i<=m_length)
   {
	 for(int j=m_length;j>=i;j--)
	 {
		m_data[j]=m_data[j-1];
	 }
	}
	m_data[i-1]=e;
	m_length++;
	return true;
}

bool List::ListDelete(int i,int *e)
{
	if(m_length==0)
		return false;
	if(i<1 || i>m_length)
		return false;
	*e=m_data[i-1];
	if(i<m_length)
	{
      for(int j=i;j<m_length;j++)
		m_data[j-1]=m_data[j];
	}	
	m_length--;
	return true;
}

int List::ListLength()
{
	return m_length;
}

void List::traverseList()
{
	for(int i=0;i<m_length;i++)
		cout<<m_data[i]<<" ";
	cout<<endl;
}

    main.cpp

#include<iostream>
#include"List.h"
using namespace std;

void main()
{
	List *L=new List(6);
	int tmp=0;
	bool OK;
	L->ListInset(1,1);
	L->ListInset(2,3);
	L->ListInset(3,5);
	L->ListInset(4,7);
	L->ListInset(5,9);
	L->ListInset(6,11);

	L->traverseList();

	L->ListDelete(3,&tmp);
	L->traverseList();
	cout<<tmp<<endl;

	int length=L->ListLength();
    cout<<length<<endl;

	L->GetElem(2,&tmp);
	cout<<tmp<<endl;

	int num=L->LocateElem(10);
	cout<<num<<endl;

	bool b=L->ListEmpty();
	cout<<b<<endl;

	L->ClearList();
	L->traverseList();
	system("pause");
}

          编译后的结果如下：