C++实现顺序表的基本操作

头文件:

#ifndef List_H
#define List_H

typedef int Elem;
class List{
public:
    List(int size);             //初始化顺序表
    ~List();                    //销毁表,析构函数  
    bool isEmpty();             //是否为空
    int listLength();           //表中元素个数
    void clearList();           //清空表
    bool getElem(int i,Elem *e);     //
    int locateElem(Elem *e);         //返回指定元素的位置
    bool priorElem(Elem *currentElem,Elem *preElem);        //找前驱
    bool nextElem(Elem *currentElem,Elem *nextElem);        //找后继
    void listTraverse();         //遍历顺序表
    bool listInsert(int i,Elem *e);     //在指定位置插入元素
    bool listDelete(int i,Elem *e);     //删除指定位置的元素
private:
    int *m_pList;            //指针
    int m_iSize;             //定义表的大小
    int m_iLength;           //表中元素个数
};
#endif

关键代码:

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

List::List(int size){
    m_iSize=size;
    m_pList=new int[m_iSize];
    m_iLength=0;
}
List::~List(){
    delete []m_pList;
    m_pList=NULL;
}
void List::clearList(){
    m_iLength=0;
}
bool List::isEmpty(){
    return m_iLength==0?true:false;
}
int List::listLength(){
    return m_iLength;
}
bool List::getElem(int i,Elem *e){
    if (i<0||i>=m_iSize)
    {
        return false;
    }else{
    *e=m_pList[i];
    return true;
    }
}
int List::locateElem(Elem *e){
    for (int i=0;i<m_iLength;i++)
    {
        if (m_pList[i]==*e)
        {
            return i;
        }
    }
    return -1;
}
bool List::priorElem(Elem *currentElem,Elem *preElem){
    int curLoc=locateElem(currentElem);
    if (curLoc==-1)
    {
        return false;
    }else if(curLoc==0){
        return false;
    }else{
        *preElem=m_pList[curLoc-1];
        return true;
    }
}
bool List::nextElem(Elem *currentElem,Elem *nextElem){
    int curLoc=locateElem(currentElem);
    if (curLoc==-1)
    {
        return false;
    }else if(curLoc==m_iLength-1){
        return false;
    }else{
        *nextElem=m_pList[curLoc+1];
        return true;
    }
}
void List::listTraverse(){
    for (int i=0;i<m_iLength;i++)
    {
        cout<<m_pList[i]<<" ";
    }
}
bool List::listInsert(int i,Elem *e){
    if (i<0||i>m_iLength)
    {
        return false;
    }else{
    for (int k=m_iLength-1;k>=i;k--)
    {
        m_pList[k+1]=m_pList[k];
    }
    m_pList[i]=*e;
    m_iLength++;
    return true;
    }
}
bool List::listDelete(int i,Elem *e){
    if (i<0||i>=m_iLength)
    {
        return false;
    }
    *e=m_pList[i];

    for (int k=i+1;k<m_iLength;k++)
    {
        m_pList[k-1]=m_pList[k];
    }
    m_iLength--;
    return true;
}

实现:

#include <iostream>
#include "List.h"

using namespace std;
int main(){
    List *p=new List(7);
    int e1=5;
    int e2=9;
    int e3=4;
    int e4=6;
    int e5=8;
    int e6=7;
    int e7=3;
    if(p->isEmpty())
        cout<<"Empty"<<endl;
    p->listInsert(0,&e1);
    p->listInsert(1,&e2);
    p->listInsert(2,&e3);
    p->listInsert(3,&e4);
    p->listInsert(4,&e5);
    p->listInsert(5,&e6);
    p->listInsert(6,&e7);
    p->listTraverse();
    cout<<endl;
    p->locateElem(&e5);
    int e=0;
    p->priorElem(&e2,&e);
    cout<<"第二个元素的前驱"<<e<<endl;
    p->nextElem(&e2,&e);
    cout<<"后继"<<e<<endl;
    p->listDelete(5,&e);
    cout<<"删除元素:"<<e<<endl;
    p->listTraverse();
    cout<<endl;
    p->getElem(7,&e);
    cout<<"最后位置元素:"<<e<<endl;
    e=24;
    p->listInsert(4,&e);
    p->listTraverse();
    cout<<endl;
    cout<<"24在:"<<p->locateElem(&e)+1<<endl;
    p->clearList();
    if(p->isEmpty())
        cout<<"Empty"<<endl;

    return 0;
}

c++顺序表

使用c++实现顺序表:多文件编程,层次清晰,函数有注释 SeqList();//构造函数,存储的元素个数设为0 bool setLength(size_t length);//设置已经存储的元素个数 bool addElement(ElemType element);//把某个元素添加到顺序表末尾 bool addElement(ElemType element , size_t n);//插入一个元素,使其成为第n个元素,其余元素后移 bool delElement();//删除所有的元素 bool delElement(size_t n);//删除第n个元素 bool delElement(string elementDetailType,string elementDetail);//通过某个元素细节找到元素,把这个元素删除 bool replaceElement(ElemType element , size_t n);//使用一个元素,替换掉第n个元素 bool swapElement(size_t n1 , size_t n2);//把第n1个元素和第n2个元素交换 ElemType* getElement();//得到数组头的指针 ElemType* getElement(size_t n);//得到第n个元素的指针 size_t getLength();//得到存储的元素个数 size_t getMaxSize();//得到顺序表容量 bool showElementDetail();//输出所有的元素细节 bool showElementDetail(size_t n);//输出第n个元素的细节 bool showElementDetail(string elementDetailType,string elementDetail);//通过某个元素细节找到元素,输出元素所有细节 size_t findElement(string elementDetailType,string elementDetail);//通过某个元素细节找到元素位置 static int inputAInt(int min = 0,int max = 9,int defaultValue = -1);//从键盘读取,限制为一个min到max间的整数,非法情况返回defaultValue void startControlLoop();//打开控制界面 ~SeqList();//析构函数
用模板方式实现顺序表的合并 #include "stdafx.h" #include #define MaxSize 100 template class SeqList { private: T * Mylist; int ListMaxSize; int Length; public: SeqList(int ListMaxSize=MaxSize); //构造函数 ~SeqList(void);// 析构函数 bool SLIsEmpty(void); // 判断表是否为空 bool SLIsFull(void);//判断表是否满 int ListLength(void){return Length;}//求表长度 T SLGetElem(int i); // 取得第i个元素的值 int SLFind(T & x,int index); //查找值为x的结点 bool SLInsert(int i,T & x); // 在表的第i个位置插入新结点 bool SLDelete(int i); // 删除表的第i个位置的结点 void CreateList(int num);// 创建一个包含num个元素的顺序表 void SLPrint(); //输出全体元素 }; template SeqList ::SeqList(int listMaxSize) //初始化顺序表 { if(listMaxSize>0){ ListMaxSize=listMaxSize; Length=0; Mylist=new T [ListMaxSize]; // 创建连续的表空间 } } template SeqList ::~SeqList(void) { delete [] Mylist;//删除表,释放表空间 } template void SeqList ::CreateList(int num) { T x; Length=0; cout << "请输入"<<num<<"个整数数据元素以创建一个线性表"<<endl; for (int i=0;i>x; Mylist[i]=x; Length++; } } template bool SeqList ::SLIsEmpty(void) // 判断表是否为空 { return (Length<=0)?true:false; //表空则返回真(true),否则返回假(false) } template bool SeqList ::SLIsFull(void)//判断表是否满 { return(Length>=ListMaxSize)?true:false; //表满则返回真(true),否则返回假(false) } template T SeqList ::SLGetElem(int i) // 取得第i个元素的值 { return(iLength-1)?-1:Mylist[i]; } template int SeqList ::SLFind(T & x,int index) //查找值为x的结点 { for(int i=0;i<index;i++) if(Mylist[i]==x) return i+1; return -1;//没有找到给定元素 } template bool SeqList ::SLInsert(int i,T & x) // 在表的第i个位置插入新结点 { if(iLength) {cout <<"参数i不合理!" <<endl; return false;} else if(Length==ListMaxSize) {cout<< "表已满,无法插入!"<i;j--) Mylist[j]=Mylist[j-1]; Mylist[j]=x; Length++; return true; } } template bool SeqList ::SLDelete(int i) // 删除表的第i个位置的结点 { if(iLength) {cout <<"参数i不合理!" <<endl; return false;} else if(Length==0) {cout<< "表已空,无无元素可删除!"<<endl; return false;} else{ for(int j=i;j<Length-1;j++)Mylist[j]=Mylist[j+1]; Length--; cout<<"删除操作成功"<<endl; return true; } } template void SeqList ::SLPrint(void) //输出全体元素 { if (SLIsEmpty()) cout<<"空表! 无元素可输出"<<endl; else{ cout<<"顺序表中的所有元素分别为: "; for (int i=0;i<Length;i++) cout<<Mylist[i]<<" "; } cout <<endl; } void ListUnion(SeqList &ListA;,SeqList &ListB;) { cout<<"两个参数对象的顺序表:"<<endl; ListA.SLPrint(); ListB.SLPrint(); int n,m; int XX,i=0; n=ListA.ListLength(); m=ListB.ListLength(); int j=i; while(i<m){ XX=ListB.SLGetElem(i); int k=ListA.SLFind(XX,n); if(k==-1) { ListA.SLInsert(n+j,XX); j++; } i++; } cout<<"两个顺序表合并后的结果"<<endl; ListA.SLPrint(); cout<<"ListUnion end"<<endl; } int main(int argc, char* argv[]) { SeqList myListA(20),myListB(30); int LenA,LenB; cout<>LenA; cout<<endl; myListA.CreateList(LenA); myListA.SLPrint(); cout<<endl<>LenB; cout<<endl; myListB.CreateList(LenB); myListB.SLPrint(); ListUnion(myListA,myListB); return 0; }
### 回答1: 我可以为你介绍一下用C语言实现顺序表基本操作的方法:首先,你需要编写一个函数来初始化顺序表,这样才能确保顺序表的大小正确;接着,你可以实现插入、删除、查找以及更新操作;最后,你可以创建一个函数来遍历顺序表,以打印出表中的所有元素。 ### 回答2: 顺序表是一种线性数据结构,可以通过数组来实现。在C语言中,可以使用结构体来定义顺序表,并编写相应的基本操作函数。 首先,我们可以定义一个结构体来表示顺序表,其中包含一个指向数组的指针和记录当前线性表长度的变量。例如: ``` #define MAX_SIZE 100 typedef struct{ int* data; int length; } SeqList; ``` 接下来,我们可以实现一些基本操作函数,包括初始化顺序表、插入元素、删除元素、查找元素和打印顺序表等。 1. 初始化顺序表 ```c void init(SeqList* list){ list->data = (int*)malloc(MAX_SIZE * sizeof(int)); list->length = 0; } ``` 2. 插入元素 ```c void insert(SeqList* list, int element, int position){ if(position < 0 || position > list->length){ printf("插入位置错误"); return; } if(list->length == MAX_SIZE){ printf("顺序表已满"); return; } for(int i = list->length; i > position; i--){ list->data[i] = list->data[i - 1]; } list->data[position] = element; list->length++; } ``` 3. 删除元素 ```c void remove(SeqList* list, int position){ if(position < 0 || position >= list->length){ printf("删除位置错误"); return; } for(int i = position + 1; i < list->length; i++){ list->data[i - 1] = list->data[i]; } list->length--; } ``` 4. 查找元素 ```c int search(SeqList* list, int element){ for(int i = 0; i < list->length; i++){ if(list->data[i] == element){ return i; } } return -1; } ``` 5. 打印顺序表 ```c void print(SeqList* list){ for(int i = 0; i < list->length; i++){ printf("%d ", list->data[i]); } printf("\n"); } ``` 通过以上的操作函数,我们就可以使用C语言实现顺序表基本操作了。使用这些操作函数,可以方便地对顺序表进行插入、删除、查找和打印等操作。 ### 回答3: 顺序表是一种线性表的存储结构,它的特点是元素在存储空间中是连续地存放的。以下是用C语言实现顺序表基本操作的步骤: 1. 定义顺序表的结构体 首先要定义一个结构体来表示顺序表,结构体中包括存放元素的数组和当前元素个数等信息。 ```c #define MAX_SIZE 100 // 顺序表的最大容量 typedef struct { int data[MAX_SIZE]; // 存放元素的数组 int length; // 当前元素个数 } SeqList; ``` 2. 初始化顺序表 定义一个初始化顺序表的函数,将顺序表的长度初始化为0。 ```c void initSeqList(SeqList *list) { list->length = 0; } ``` 3. 插入元素 定义一个插入元素的函数,根据位置和元素的值将元素插入到顺序表中。 ```c int insertSeqList(SeqList *list, int pos, int value) { if (pos < 1 || pos > list->length + 1) { return 0; // 插入位置非法 } if (list->length >= MAX_SIZE) { return -1; // 顺序表已满,无法插入新元素 } for (int i = list->length; i >= pos; i--) { list->data[i] = list->data[i-1]; // 元素后移 } list->data[pos-1] = value; // 在指定位置插入元素 list->length++; // 元素个数加1 return 1; // 插入成功 } ``` 4. 删除元素 定义一个删除元素的函数,根据位置删除顺序表中的元素。 ```c int deleteSeqList(SeqList *list, int pos) { if (pos < 1 || pos > list->length) { return 0; // 删除位置非法 } for (int i = pos - 1; i < list->length-1; i++) { list->data[i] = list->data[i+1]; // 元素前移 } list->length--; // 元素个数减1 return 1; // 删除成功 } ``` 5. 查找元素 定义一个查找元素的函数,根据元素的值查找顺序表中是否存在该元素,并返回其位置。 ```c int searchSeqList(SeqList *list, int value) { for (int i = 0; i < list->length; i++) { if (list->data[i] == value) { return i+1; // 返回元素位置 } } return 0; // 未找到该元素 } ``` 以上就是用C语言实现顺序表基本操作的步骤。通过这些函数,我们可以实现顺序表的初始化、插入、删除和查找等操作。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值