精华内容
下载资源
问答
  • 顺序表的创建、查找、插入、删除等一些基本操作,使用c++编写的简单例子,适用于初学者,通过学习实例,能更好的掌握顺序表
  • 使用c++实现的顺序表:多文件编程,层次清晰,函数有注释 SeqList();//构造函数,存储的元素个数设为0 bool setLength(size_t length);//设置已经存储的元素个数 bool addElement(ElemType element);//把某个...
  • 这是讲解代码中函数关系的Keynote 为了大家方便,已转换为ppt 博客地址blog.csdn.net/u012350104
  • 不多BB 直接看代码 顺序表就是我们常用的数组 在数据结构中叫做顺序表 是一种基础的线性表结构 #include "pch.h" #include <iostream> using namespace std; #define Maxsize 100//最大空间 typedef struct...

    不多BB 直接看代码 顺序表就是我们常用的数组 在数据结构中叫做顺序表 是一种基础的线性表结构

    #include "pch.h"
    #include <iostream>
    
    using namespace std;
    #define Maxsize 100//最大空间
    typedef struct
    {
    	int *elem;
    	int length;//顺序表长度 
    
    }SequenceTable;
    
    bool InitList(SequenceTable &table) //构造一个空的顺序表table
    {
    	table.elem = new int[Maxsize];
    	if (table.elem==nullptr)
    	{
    		return false;
    	}
    	table.length = 0;
    	return true;
    }
    
    bool CreateList(SequenceTable &table,int a)//创建一个顺序表table
    {
    	int	i = 0;
    	if (table.length == Maxsize)
    	{
    		cout << "顺序表已满! ";
    		return false;
    
    	}
    	table.elem[i++] = a;
    	table.length++;	
    	return true;
    }
    
    bool GetElem(SequenceTable table, int i, int &e)
    {
    	if (i<1 || i>table.length) 
    	{
    		return false;
    	}
    	e = table.elem[i - 1];//第i-1的单元存储着第i个数据
    
    	cout << "第i个元素是:" << e << endl;
    
    	return true;
    
    }
    
    int FindElem(SequenceTable table, int x) 
    {
    	for (int i = 0; i < table.length; i++) 
    	{
    		if (table.elem[i] == x) 
    		{
    			cout << "查找成功!当前位置是" << i + 1<<endl;
    			return i + 1;
    		}
    	}
    	
    	return -1;
    
    }
    
    bool InsertSequenceTable(SequenceTable &table, int i, int e)
    {
    	if (i<1 || i>table.length + 1) 
    	{
    		return false;//i值不合法
    	} 
    	if (table.length == Maxsize)  
    	{
    		return false;//存储空间已满
    	}
    	for (int j = table.length - 1; j >= i - 1; j--) 
    	{
    		table.elem[j + 1] = table.elem[j];//从最后一个元素开始后移,直到第i个元素后移
    	}
    	table.elem[i - 1] = e;//将新元素e放入第i个位置
    	table.length++;//表长加1
    	return true;
    }
    
    bool DeleteSequenceTable(SequenceTable &table, int i, int &e)
    {
    	if ((i < 1) || (i > table.length)) 
    	{
    		return false;//i值不合法
    	} 
    	e = table.elem[i - 1];//将欲删除的元素保留在e中
    	for (int j = i; j <= table.length - 1; j++) 
    	{
    		table.elem[j - 1] = table.elem[j];//被删除元素之后的元素后移 
    	}
    	table.length--;//表长减少1
    	return true;
    }
    
    void print(SequenceTable table)
    {
    	cout << "输出顺序表" << endl;
    	for (int j = 0; j <= table.length - 1; j++)
    		cout << table.elem[j] << " ";
    	cout << endl;
    }
    
    void DestroyList(SequenceTable &table) {
    	if (table.elem) 
    	{
    		delete[]table.elem;//释放存储空间 
    	}
    
    }
    
    int main()
    {
    	SequenceTable myL;
    	int i, e, x;
    	cout << "1.初始化\n";
    	cout << "2.创建\n";
    	cout << "3.取值\n";
    	cout << "4.查找\n";
    	cout << "5.插入\n";
    	cout << "6.删除\n";
    	cout << "7.输出\n";
    	cout << "8.销毁\n";
    	cout << "0.退出\n";
    	int num = 0;
    
    	int choose = -1;
    	while (choose != 0)
    	{
    		cout << "请选择:";
    		cin >> choose;
    		switch (choose)
    		{
    		//初始化顺序表
    		case 1:
    			cout << "顺序表初始化·····" << endl;
    			if (InitList(myL))
    				cout << "顺序表初始化成功!" << endl;
    			else
    				cout << "顺序表初始化失败!" << endl;
    			break;
    		//创建顺序表
    		case 2:
    			cout << "顺序表创建····" << endl;
    			cout << "输入整型数,输入-1结束" << endl;
    			cin >> num;
    			if (CreateList(myL,num))
    				cout << "顺序表创建成功!" << endl;
    			else
    				cout << "顺序表创建失败!" << endl;
    			break;
    			//取值
    		case 3:
    			cout << "输入整型数i,取第i个元素输出" << endl;
    			cin >> i;
    			if (GetElem(myL, i, e)) 
    			{
    				//cout << "第i个元素是:" << e << endl;
    			}
    			else
    				cout << "顺序表取值失败!" << endl;;
    			//cout << "第i个元素是:" << e << endl;
    			break;
    			//查找
    		case 4:
    			cout << "请输入要查找的数x:";
    			cin >> x;
    			if (FindElem(myL, x) == -1)
    				cout << "查找失败!" << endl;
    			else
    				cout << "查找成功!" << endl;
    			break;
    			//插入
    		case 5:
    			cout << "请输入要插入的位置和要插入的数据元素e:";
    			cin >> i >> e;
    			if (InsertSequenceTable(myL, i, e))
    				cout << "插入成功!" << endl;
    			else
    				cout << "插入失败!" << endl;
    			break;
    			//删除
    		case 6:
    			cout << "请输入要删除的位置i:";
    			cin >> i;
    			if (DeleteSequenceTable(myL, i, e))
    				cout << "删除成功!" << endl;
    			else
    				cout << "删除失败!" << endl;
    			break;
    			//输出
    		case 7:
    			print(myL);
    			break;
    			//销毁
    		case 8:
    			cout << "顺序表销毁·····" << endl;
    			DestroyList(myL);
    			break;
    
    
    		}
    
    	}
    	return 0;
    }

     

    展开全文
  • 数据结构C++顺序表

    2018-03-04 20:02:50
    基于C++顺序表数据结构,带主程序,可直接运行,使用时直接带入头文件即可。
  • 数据结构顺序表元素逆置算法,C++实现,算法复杂度为n/2
  • 本人自己编写的代码,相信你下了之后不会后悔的
  • 数据结构顺序表基本操作(C/C++实现)

    千次阅读 多人点赞 2019-10-22 23:23:01
    数据结构顺序表基本操作(C/C++实现) 涉及基本运算 初始化顺序表L 依次插入abcde元素 输出顺序表L 输出顺序表L的长度 判断顺序表L是否为空 输出顺序表L的第3个元素 输出元素a的位置 在第4个元素位置上插入f元素 ...

    数据结构顺序表基本操作(C/C++实现)

    注意:本代码为了测试运行默认含有操作所需数据,如有需要可自己增删改相关数据

    涉及基本运算

    1. 初始化顺序表
    2. 依次插入元素
    3. 输出顺序表
    4. 输出顺序表的长度
    5. 判断顺序表是否为空
    6. 输出顺序表的第n个元素
    7. 输出元素x的位置
    8. 在第n个元素位置上插入x元素
    9. 输出顺序表
    10. 删除顺序表的第n个元素
    11. 输出顺序表
    12. 释放顺序表

    GitHub地址(包含.cpp文件和可执行程序exe)

    我的数据结构GitHub地址

    源代码(经VS2015、devC++编译器运行通过)

    #include "stdio.h"    
    #include "stdlib.h"   
    #include "io.h"  
    #include "math.h"  
    #include "time.h"
    
    #define OK 1
    #define ERROR 0
    #define TRUE 1
    #define FALSE 0
    
    #define MAXSIZE 20 /* 存储空间初始分配量 */
    
    typedef int Status;          /* Status是函数的类型,其值是函数结果状态代码,如OK等 */
    typedef char ElemType;        /* ElemType类型根据实际情况而定,这里假设为int */
    
    
    Status visit(ElemType c)
    {
    	printf("%c ", c);
    	return OK;
    }
    
    typedef struct
    {
    	ElemType data[MAXSIZE];        /* 数组,存储数据元素 */
    	int length;                                /* 线性表当前长度 */
    }SqList;
    
    /* 1.初始化顺序线性表 */
    Status InitList(SqList *L)
    {
    	L->length = 0;
    	return OK;
    }
    
    /* 2.初始条件:顺序线性表L已存在,1≤i≤ListLength(L), */
    /* 操作结果:在L中第i个位置之前插入新的数据元素e,L的长度加1 */
    Status ListInsert(SqList *L, int i, ElemType e)
    {
    	int k;
    	if (L->length == MAXSIZE)  /* 顺序线性表已经满 */
    		return ERROR;
    	if (i<1 || i>L->length + 1)/* 当i比第一位置小或者比最后一位置后一位置还要大时 */
    		return ERROR;
    
    	if (i <= L->length)        /* 若插入数据位置不在表尾 */
    	{
    		for (k = L->length - 1; k >= i - 1; k--)  /* 将要插入位置之后的数据元素向后移动一位 */
    			L->data[k + 1] = L->data[k];
    	}
    	L->data[i - 1] = e;          /* 将新元素插入 */
    	L->length++;
    
    	return OK;
    }
    
    
    /* 3.初始条件:顺序线性表L已存在 */
    /* 操作结果:依次对L的每个数据元素输出 */
    Status ListTraverse(SqList L)
    {
    	int i;
    	for (i = 0; i<L.length; i++)
    		visit(L.data[i]);
    	printf("\n");
    	return OK;
    }
    
    /* 4.初始条件:顺序线性表L已存在。
    操作结果:返回L中数据元素个数 */
    int ListLength(SqList L)
    {
    	return L.length;
    }
    
    /* 5.初始条件:顺序线性表L已存在。
    操作结果:若L为空表,则返回TRUE,否则返回FALSE */
    Status ListEmpty(SqList L)
    {
    	if (L.length == 0)
    		return TRUE;
    	else
    		return FALSE;
    }
    
    /* 6.初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */
    /* 操作结果:用e返回L中第i个数据元素的值,注意i是指位置,第1个位置的数组是从0开始 */
    Status GetElem(SqList L, int i, ElemType *e)
    {
    	if (L.length == 0 || i<1 || i>L.length)
    		return ERROR;
    	*e = L.data[i - 1];
    
    	return OK;
    }
    
    /* 7.初始条件:顺序线性表L已存在 */
    /* 操作结果:返回L中第1个与e满足关系的数据元素的位序。 */
    /* 若这样的数据元素不存在,则返回值为0 */
    int LocateElem(SqList L, ElemType e)
    {
    	int i;
    	if (L.length == 0)
    		return 0;
    	for (i = 0; i<L.length; i++)
    	{
    		if (L.data[i] == e)
    			break;
    	}
    	if (i >= L.length)
    		return 0;
    
    	return i + 1;
    }
    
    
    
    /* 初始条件:顺序线性表L已存在。
    操作结果:将L重置为空表 */
    Status ClearList(SqList *L)
    {
    	L->length = 0;
    	return OK;
    }
    
    
    
    
    
    
    
    /* 10.初始条件:顺序线性表L已存在,1≤i≤ListLength(L) */
    /* 操作结果:删除L的第i个数据元素,并用e返回其值,L的长度减1 */
    Status ListDelete(SqList *L, int i, ElemType *e)
    {
    	int k;
    	if (L->length == 0)               /* 线性表为空 */
    		return ERROR;
    	if (i<1 || i>L->length)         /* 删除位置不正确 */
    		return ERROR;
    	*e = L->data[i - 1];
    	if (i<L->length)                /* 如果删除不是最后位置 */
    	{
    		for (k = i; k<L->length; k++)/* 将删除位置后继元素前移 */
    			L->data[k - 1] = L->data[k];
    	}
    	L->length--;
    	return OK;
    }
    
    void unionL(SqList *La, SqList Lb)
    {
    	int La_len, Lb_len, i;
    	ElemType e;
    	La_len = ListLength(*La);
    	Lb_len = ListLength(Lb);
    	for (i = 1; i <= Lb_len; i++)
    	{
    		GetElem(Lb, i, &e);
    		if (!LocateElem(*La, e))
    			ListInsert(La, ++La_len, e);
    	}
    }
    
    int main()
    {
    
    	SqList L;
    	SqList Lb;
    
    	ElemType e;
    	Status i;
    	int j, k;
    	/*1.初始化*/
    	i = InitList(&L);
    	printf("1.初始化L后:L.length=%d\n", L.length);
    
    	/*2.依次插入abcde*/
    	i = ListInsert(&L, 1, 'e');
    	i = ListInsert(&L, 1, 'd');
    	i = ListInsert(&L, 1, 'c');
    	i = ListInsert(&L, 1, 'b');
    	i = ListInsert(&L, 1, 'a');
    	printf("2.abcde插入执行完毕\n");
    
    	/*3.输出顺序表*/
    	printf("3.在L的表头依次插入a~e后:L.data=\n");
    	ListTraverse(L);
    
    	/*4.顺序表长度*/
    	printf("4.L.length=%d \n", L.length);
    
    	/*5.判空*/
    	i = ListEmpty(L);
    	printf("5.L是否空:i=%d(1:是 0:否)\n", i);
    
    	/*6.输出顺序表L的第三个元素*/
    	GetElem(L, 3, &e);
    	printf("6.第3个元素的值为:%c\n", e);
    
    	/*7.输出顺序表a的位置*/
    	int l = LocateElem(L, 'a');
    	printf("7.返回元素a的位序:%d\n", l);
    
    	/*8.在第4个元素位置上插入f元素*/
    	i = ListInsert(&L, 5, 'f');
    	printf("8.在第4个元素位置上插入f元素执行完毕\n", L.length);
    
    	/*9.输出顺序表*/
    	printf("9.在L的第4个元素位置上插入f元素后:L.data=\n");
    	ListTraverse(L);
    
    	/*10.删除顺序表L的第三个元素*/
    
    	i = ListDelete(&L, 3, &e); /* 删除第j个数据 */
    	if (i == ERROR)
    		printf("删除第%d个数据失败\n", 3);
    	else
    		printf("10.删除第个的元素成功\n");
    
    	/*11.输出顺序表L*/
    	printf("11.输出顺序表\n");
    	ListTraverse(L);
    
    	/*12.释放顺序表*/
    	i = ClearList(&L);
    	printf("释放顺序表执行完毕\n"); 
    	system("pause");
    		return 0;
    }
    
    
    
    
    
    展开全文
  • 数据结构学过了模板之后就开始了线性表的学习,线性表又分为简单的顺序存储和链式存储两种方式。两种方法各有长短,根据不同的实际情况定义使用。 线性表的定义: 是零个或多个具有相同类型的数据元素的有限序列。 ...

    数据结构学过了模板之后就开始了线性表的学习,线性表又分为简单的顺序存储和链式存储两种方式。两种方法各有长短,根据不同的实际情况定义使用。

    线性表的定义:

    是零个或多个具有相同类型的数据元素的有限序列。
    通常的线性表中有两个元素,一个是存储的数据,另一个是表数据的长度。

    顺序存储的特点:

    线性表的顺序存储,是指用一维地址连续的存储单元依次存储线性表中的各个元素。
    在这里插入图片描述



    设顺序表的每个元素占用c个存储单元,则第i个元素的存储地址为:
    在这里插入图片描述

    顺序表的作用:

    线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中,即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系。

    顺序存储的实现:

    一维数组存储顺序表中的数据。


    顺序表定义及相关函数代码:

    #include<iostream>
    using namespace std;
    const int Maxsize = 100;
    template <class T>
    class SeqList {
    private:
    	T data[MaxSize]; // 存放数据元素的数组 
    	int length; // 线性表的长度 
    public:
    	SeqList();// 无参构造函数   
    	SeqList(T a[], int n); // 有参构造函数 
    	~SeqList() { } // 析构函数为空 
    	int Length() { return length; } // 求线性表的长度 
    	T Get(int i); // 按位查找,取线性表的第 i 个元素 
    	int Locate(T x); // 按值查找,求线性表中值为 x 的元素序号 
    	void Insert(int i, T x); // 在线性表中第 i 个位置插入值为 x 的元素 
    	T Delete(int i); // 删除线性表的第 i 个元素 
    	void PrintList(); // 遍历线性表,按序号依次输出各元素 
    };
    int main() { return 0; }
    

    两个构造函数:

    SeqList()  //定义无参的构造函数,需要使length长度为0
    { 
    	length = 0; 
    }
    
    template <class T> //模板
    SeqList<T>::SeqList(T a[], int n)
    {
    	if (n > MaxSize) throw "参数非法";
    	for (int i = 0; i < n; i++)
    		data[i] = a[i];
    	length = n;
    }
    

    插入操作

    为了保证数据的完整,顺序表利用循环将第 i 个位置的数值替换掉,循环只可从数据尾部开始,data[i]=data[i-1]。

    在这里插入图片描述
    线性表的插入运算是指在表的第i (1≤i≤n+1)个位置,插入一个新元素e,使长度为n的线性表 (e1,…,ei-1,ei,…,en) 变成长度为n+1的线性表(e1,…, ei-1,e,ei,…,en)

    template <class T>
    void SeqList<T>::Insert(int i, T x) 
    {
    	int j;
    	if (length >= MaxSize) throw "上溢";
    	if (i<1 || i>length + 1) throw "位置";
    	for (j = length; j >= i; j--) //从末尾开始循环,防止数据丢失
    		data[j] = data[j - 1];
    	data[i - 1] = x;
    	length++; //长度+1
    }
    

    时间复杂度不多做证明,单重循环,时间复杂度为O(n)

    删除操作

    同样,删除操作为了保证数据不丢失,只可以在第 i 个位置开始循环,向后替换数据。

    在这里插入图片描述
    线性表的删除运算是指将表的第i(1≤i≤n)个元素删去,使长度为n的线性表(e1,…, ei-1,ei,ei+1,…,en)变成长度为n-1的线性表(e1,…, ei-1, ei+1,…,en)。

    template <class T>
    T SeqList<T>::Delete(int i) {
    	int j;
    	T  x;
    	if (length == 0) throw "下溢";
    	if (i<1 || i>length) throw "位置";
    	x = data[i - 1];
    	for (j = i; j < length; j++) //从i开始循环,向后替换数据
    		data[j - 1] = data[j];
    	length--; //删除操作,长度-1
    	return x;
    }
    

    时间复杂度为O(n)

    查找操作

    1. 按位置查找
    template <class T>
    T SeqList<T>::Get(int i)
    {
    	if (i<1 && i>length) throw "查找位置非法";
    	else return data[i - 1];
    }
    
    1. 按值查找
    template <class T>
    int SeqList<T>::Locate(T x) {
    	for (int i = 0; i < length; i++)
    		if (data[i] == x)
    			return i + 1;  //下标为i的元素等于x,返回其序号i+1
    	return 0;  //退出循环,说明查找失败
    }
    

    时间复杂度O(n)


    顺序表的特点

    由上面的讨论可知, 线性表顺序表示的优点是:
    (1) 无需为表示结点间的逻辑关系而增加额外的存储空间(因为逻辑上相邻的元素其存储的物理位置也是相邻的);
    (2) 可方便地随机存取表中的任一元素。
    由上面的讨论可知, 线性表顺序表示的缺点:
    (1) 插入或删除运算不方便, 除表尾的位置外,在表的其它位置上进行插入或删除操作都必须移动大量的结点,其效率较低;. (2) 由于顺序表要求占用连续的存储空间,存储分配只能预先进行静态分配,因此当表长变化较大时, 难以确定合适的存储规模




    所以在顺序存储之外,我们可以引入链式存储结构并且实现,链式存储会弥补顺序存储的不足,解决了顺序存储的诸多问题,但其本身也因为较为复杂有一定的局限性,需要好好学习,熟练使用。


    展开全文
  • 数据结构----顺序表C++实现)

    千次阅读 2018-06-17 12:22:20
    顺序表 顾名思义,就是按顺序排列的表。 在顺序表中,各个表象的逻辑顺序和其存放的物理顺序一致。 在对顺序表的访问中,通过下标,既可以顺序访问,又可以随机访问。 顺序表的定义 描述顺序表的存储表示...

    顺序表


    顾名思义,就是按顺序排列的表。

    1. 在顺序表中,各个表象的逻辑顺序和其存放的物理顺序一致。
    2. 在对顺序表的访问中,通过下标,既可以顺序访问,又可以随机访问。
      这里写图片描述

    顺序表的定义

    描述顺序表的存储表示有两种方式:静态方式和动态方式
    静态方式

    #define maxSize 100
    typedef int T;
    typedef struct
    {
        T data[maxSize];
        int n;
    }SeqList;

    动态方式

    typedef int T;
    typedef struct
    {
        T *data;
        int maxSize,n;
    }SeqList;

    动态存储中存储数组的空间在执行程序过程中通过动态分分配语句分配,达到扩充存储数组的目的。所以一般选择动态存储方式。

    代码实现

    #include<iostream>
    #include<stdlib.h>
    using namespace std;
    
    const int defaultSize = 100;
    
    // 定义
    template <class T>
    class SqList
    {
    private:
        T *data; // 存放顺序表中的元素
        int maxsize; // 最大容量
        int last;//当前已经存的最后位置
        void reSize(int newSize);//改变data数组的空间大小
    
    public:
        SqList(int sz = defaultSize)// 构造函数
        {
            if (sz > 0)
            {
                maxsize = sz;
                last = -1;
                data = new T[maxsize];
    
                if (data == NULL)
                {
                    cout << "分配失败" << endl;
                    exit(1);
                }
    
            }
        }
        SqList(SqList<T>& L)// 复制构造函数
        {
            maxsize = L.Size();
            last = L.length() - 1;
            T value;
            data = new T[maxsize];
            if (data == NULL)
                cout << "分配失败" << endl;
            for (int i = 0; i <= last; i++)
                data[i] = L.GetData(i - 1);
        }
        ~SqList()// 析构函数
        {
            delete[] data;
        }
    
        //计算表最大容量
        int Size() const
        {
            return maxSize;
        }
    
        //计算表长度
        int length() const
        {
            return last + 1;
        }
    
        //搜索x在表中的位置
        int Search(T& x) const
        {
            for (int i = 0; i <= last; i++)
            {
                if (data[i] == x)
                    return i + 1
            }
            return 0;
        }
    
        //查看i位置的内容
        bool GetData(T& i,T& x)
        {
            if (i > 0 || i <= last + 1)
            {
                x = data[i - 1];
                return true;
            }   
            return false;
        }
    
        //在第i项插入x的值
        bool SetData(int i, T& x)
        {
            if (last == maxsize - 1)    //如果表满,不能插入
                return false;
            if (i >= 0 && i <= last + 1)    //插入位置之后的所有元素后移一位
            {
                for (int j = last; j >= i; j--)
                {
                    data[j + 1] = data[j];
                }
                data[i] = x;
                last++;
                return true;
            }
            return false;
        }
    
        //删除第i项,并返回
        bool Remove(int i, T& x)
        {
    
            if (i > 0 && i <= last + 1)
            {
                x = data[i - 1];
                for (int j = i - 1; j < last; j++)
                    data[j] == data[j + 1];
                last--;
                return true;
            }
            return false;
        }
    
        //判断表是否为空
        bool IsEmpty()
        {
            return (last == -1) ? true : false;
        }
    
        //判断表是否已满
        bool IsFull()
        {
            return (last == maxsize - 1) ? true : false;
        }
    
        //输入
        void input()
        {
            cout << "开始建立顺序表,请输入表中元素个数:" << endl;
            while (1)
            {
                int length;
                cin >> length;
                last = length - 1;
                if (last <= (maxsize-1))
                    break;
                cout << "超过范围" << endl;
            }
            cout << "输入表中元素" << endl;
            for (int i = 0; i <= last; i++)
            {
                cin >> data[i];
            }
        }
    
        //输出
        void output()
        {
            if (last >= 0)
            {
                for (int i = 0; i <= last; i++)
                    cout << data[i] << " ";
            }
            else
                cout << "顺序表为空" << endl;
        }
    };
    
    int main()
    {
        int i = 0;
        int x = 0;
        SqList<int> L;
        L.input();
        L.output();
        cout << "选择要查看的位置" << endl;
        cin >> i;
        L.GetData(i,x);
        cout << "目标元素:" << x << endl;
        cout << "想要插入的位置和插入的值:" << endl;
        cin >> i >> x;
        L.SetData(i,x);
        L.output();
        return 0;
    }
    

    优缺点分析

    优点

    1. 无需为结点间的逻辑关系分配额外的存储空间,存储利用率高。
    2. 可以方便的随机存取表中的数据,存取速度快。

    缺点

    1. 在表中插入或删除元素时,为了保证物理内存的顺序,需要移动其他的元素位置,平均需要移动一般的元素,运行效率低。
    2. 顺序表占用连续空间,动态分配内存时可能难以找到合适的空间地址。
    展开全文
  • 本学期数据结构第一次实验-顺序表C++实现
  • 1.建立两个顺序表(通过随机函数生成); 2.排序(升序),输出合并前的结果; 3.对这两个顺序表进行合并(保持升序); 4.输出合并结果
  • 采用C++语言实现数据结构顺序表的基本运算与操作
  • C++实现顺序链表类模板及测试
  • 编写一个完整的程序,实现顺序表的生成、插入、删除、输出等基本运算。
  • C++语言实现顺序表数据结构

    千次阅读 2018-05-10 23:38:37
    概念顺序表是最基本的数据结构之一,它属于线性表的一种存储表现形式,在计算机内部表示为一块连续的内存空间。C++实现顺序表代码#include &lt;iostream&gt; using namespace std; template &lt;...
  • c++数据结构顺序表奇数在左偶数在右源码例子c++数据结构顺序表奇数在左偶数在右源码例子
  • 洛阳理工学院实验报告 系别 计算机 班级 学号 姓名 课程名称 数据结构 实验日期 10/23 实验名称 顺序表的基本操作 成绩 实验目的 熟悉掌握线性表顺序存储结构掌握与应用顺序表的查找插入删除等基本操作算法训练和...
  • 顺序表是指采用顺序存储结构的线性表,它利用内存中的一片连续存储区域存放表中的所有元素。可以根据需要对表中的所有数据进行访问,元素的插入和删除可以在表中的任何位置进行。 1. 实现顺序表的基本操作,包括顺序...
  • 本人正在学习中,小小的坐笔记,自己起后备用的哈哈,其实不完整 ,只是小小的实现下功能,认识下顺序表结构
  • 自己写的数据结构顺序表C++实现 自己写的数据结构顺序表C++实现
  • 数据结构顺序表.rar

    2020-04-07 19:15:45
    数据结构顺序表
  • #include using namespace std; #define True 11 #define False 0 #define Ok 111 #define Error -111 #define List_Init_Size 10 #define ListIncrement 10 typedef int Status;... //元素类型
  • 数据结构的顺表表相关算法:C++顺序表,采用结构体的基本运算,采用数组的基本运算,顺序表基本运算。
  • 模拟通讯录,设计相关数据结构,用菜单选择方式实现:通讯录的建立、通讯联系人的插入、删除、修改、查找等功能。
  • 主要为大家详细介绍了C++顺序表的基本操作,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 数据结构顺序表(C/C++版)

    千次阅读 2018-04-05 11:44:42
    本文为CSDN博主coder_gxd原创转载请注明:https://blog.csdn.net/coder_gxd/article/details/79825116本文介绍数据结构顺序表的常用算法(C/C++版),欢迎各位同学讨论指正。#define maxsize 100 //定义顺序表 ...
  • 用数组实现数据结构顺序表的几种功能。包括插入,判断顺序表是否为空,遍历顺序表,获取指定位置元素,查找元素,获取元素的前驱、后继,删除、清空、销毁顺序表。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 129,956
精华内容 51,982
关键字:

数据结构顺序表c++

c++ 订阅
数据结构 订阅