精华内容
下载资源
问答
  • 数据结构顺序表基本操作(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语言)简单实现 思来想去决定向嵌入式系统方向靠拢。虽然本科是电子信息科学与技术,但是从未学过数据结构、操作系统等计算机方面的专业课。故最近开始学习数据结构,使用严蔚敏老师的第二版...

    数据结构顺序表的指针(C语言)简单实现

    思来想去决定向嵌入式系统方向靠拢。虽然本科是电子信息科学与技术,但是从未学过数据结构、操作系统等计算机方面的专业课。故最近开始学习数据结构,使用严蔚敏老师的第二版教材。

    为了更好的理解这门课程,每学一部分就用代码来实现一下。写本文的目的是分享一下代码,并希望大佬能给萌新提出宝贵的建议

    《数据结构(C语言)(第2版)》严蔚敏 李冬梅 吴伟民 编著

    1.顺序表

    1. 线性表的顺序表示
      指的是用一组地址连续的存储单元依次存储线性表的数据元素,也称线性表的顺序存储结构或顺序映像。通常称这种存储结构的线性表为顺序表。

    2. 顺序表特点
      逻辑上相邻的数据元素,其物理次序也相邻。

    3. 顺序表中地址关系
      假设线性表的每个元素占用 L 个存储单元,以第一个单元的存储地址为数据元素的存储起始位置。则线性表中第i+1个数据元素的存储位置LOC(ai+1)和第i个数据元素的存储位置LOC(ai)之间的关系为:
      LOC(ai+1)=LOC(ai)+L
      一般来说,线性表的第i个元素ai的存储位置为:
      LOC(ai)=LOC(a1)+(i-1)*L。
      综上,只要确定了存储线性表的起始位置,线性表中任一数据元素都可随机存取,所以线性表的顺序存储结构是一种随机存取的存储结构。

    1. 顺序表的抽象数据类型定义
    	ADT List{
       		数据对象: D={a~i~|a~i~∈ElemSet,i=1,2,...,n,n≥0}
       		数据关系: R={<a~i-1~,a~i~>|a~i-1~,a~i~∈D,i=1,2..n}
       		基本操作:
    
       		InitList(*L)
       		操作结果: 构造一个空的顺序表。
       		
       		ApeendList(*L,pl)
       		初始条件:顺序表L已存在
       		操作结果: 构造一个空的顺序表。
       		
       		InsertList(*L,index,pl)
       		初始条件:顺序表L已存在且不为空
       		操作结果: 在顺序表L中的index位置插入pl
    
       	    DeleteList(*L,index)
       	    初始条件:顺序表L已存在且不为空
       	    操作结果:删除顺序表L中的index位置元素
    
       	    FindList(*L,pl)
       	    初始条件:顺序表L已存在且不为空
       	    操作结果:在顺序表L中查找数据元素pl,返回当前位置,若不存在则返回ERROR
       
       		PrintList(L)
       		操作结果:打印顺序表
    }ADT List
    

    2.C语言指针的简单实现

    将电压和电流的瞬时值表达式变换成极坐标形式存储在顺序表中。例:U=Um*sqrt(2)sin(wt+α),通过欧拉公式得U=Um/sqrt(2)(cosα+jsinα) —>U=a+bj。
    在这里插入图片描述
    将以上与存储关系相对应,如下图:
    在这里插入图片描述

    1. 预处理阶段
    #define OK 1		//状态值
    #define ERROR -1 
    #define OVERFLOW -2	
    #define MAXSIZE 50 //顺序表长度
    
    1. 构建相关结构体
    typedef int Status;
    
    /*构建复数结构体*/
    typedef struct {
    	float real;			//实部
    	double complex;		//虚部
    }Ploy;
    
    /*构建顺序表结构体*/
    typedef struct {
    	Ploy* elem;		//顺序表地址指针,指向Ploy结构体
    	int lenth;			//顺序表长度
    }SqList;
    
    1. 基本函数

    (1)顺序表的初始化
    ①为顺序表L动态分配一个预定义大小的空间,使elem指向这段空间的基地址。
    ②将表的当前长度设为0。

    Status InitList(SqList* L) {
    	L->elem = (Ploy*)malloc(sizeof(Ploy*)*MAXSIZE);
    	if (L->elem == NULL) {    //若elme为NULL则分配空间失败
    		printf("Init Error");
    		return ERROR;
    	}
    
    	L->lenth = 0;
    	return OK;
    }
    

    (2)追加数据元素
    ①给顺序表追加一个数据元素,若超出设置的最大长度返回OVERFLOW。
    ②将表的当前长度+1。

    Status AppendList(SqList* L, Ploy pl) {
    	if (L->lenth > MAXSIZE) return OVERFLOW;
    	*(L->elem + L->lenth) = pl;   //追加数据元素
    	L->lenth++;
    	return OK;
    }
    

    (3)删除数据元素
    ①删除顺序表中index位置的元素,后续元素向上补位。当index<1或index>当前顺序表长度则返回OVERFLOW。
    ②将表的当前长度-1

    Status DeleteList(SqList* L, int index) {
    index--;   //以1为数据的第一个元素
    	if (index<0 || index > L->lenth) {
    		printf("Over Round");
    		return OVERFLOW;
    	}
    
    	for (int i = index; i < L->lenth; i++) {
    		*(L->elem + i) = *(L->elem + i + 1);
    	}
    
    	L->lenth--;
    	return OK;
    }
    

    (4)插入数据元素
    ①在顺序表中的index位置插入数据元素,index后的数据元素向下依次存入,并将当前顺序表长度+1。
    ②当index<1或index>当前顺序表长度时返回OVERFLOW。当index为最后一个元素位置(等于MAXSIZE)时替换MAXSIZE位置元素,当前顺序表长度不变。

    Status InsertList(SqList* L, int index ,Ploy pl) {
    	--index;
    
    	if (index<0 || index>L->lenth) { 
    		printf("Over Round!");
    		return OVERFLOW; 
    	}
    
    	if (index == L->lenth) {
    		*(L->elem + L->lenth) = pl;
    		if (L->lenth == MAXSIZE )
    			return OK;
    		else{
    			L->lenth++;
    			return OK;
    		}
    	}
    
    	for (int i = L->lenth; i >=index; i--)   
    		*(L->elem + i + 1) = *(L->elem + i);
    		//index后的数据元素向下依次存入
    		
    	*(L->elem + index) = pl;
    
    	L->lenth++;
    	return OK;
    }
    

    (5)查找元素位置
    ①在顺序表中查找元素所在位置,返回值为int型。
    ②元素不存在,则返回ERROR。

    int FindList(SqList L, Ploy pl) {
    	for (int i = 0; i < L.lenth; i++)
    		if (
    			L.elem[i].real == pl.real &&
    			L.elem[i].complex == pl.complex 
    			)
    			return i + 1;
    
    	printf("None");
    	return ERROR;
    }
    

    (6)打印当前顺序表

    void PrintList(SqList* L,const char c) {
    	printf("num\treal\t    complex\n");
    	for (int i = 0; i < L->lenth; i++){
    		printf("%c%d\t%.3f      %.4f\n",c,i+1,(L->elem+i)->real, (L->elem+i)->complex);
    	}
    	return;
    }
    

    (7)函数的实现

    int main()
    {	
    	SqList Volt;	//创建一个电压的顺序表
    	Ploy u1 = { 12.653 , 2.189 };  //仅举例说明电压的极坐标形式 
    	Ploy u2 = { 13.15 , 65.17 };  //U=Um*sin(wt+α) -> u=Um/sqrt(2)*(cosα+sinα*j)  
    	Ploy u3 = { 50.23  , 8.395 };  
    	
    	InitList(&Volt);	//对电压顺序表操作
    
    	AppendList(&Volt, u1);	//追加数据元素
    	AppendList(&Volt, u2);
    	AppendList(&Volt, u3);
    
    	Ploy u4 = { 11.0   ,  15.68 };
    	InsertList(&Volt,3, u4);  //在第三个位置插入数据元素u4
    
    	DeleteList(&Volt, FindList(Volt, u3));   //查找数据元素u3的位置并删除
    
    	PrintList(&Volt,'u');		//打印电压顺序表
    	printf("\n");
    
    	return 0;
    }
    

    (8)调试结果
    调试结果

    3.总结

    本篇文章实现了顺序表的指针简单实现,还未进行对时间复杂的的优化,以后的文章会深入这些问题。

    (初入数据结构,可能会漏掉重要知识点,而且C语言不大熟练,还望大佬给予宝贵的建议。)

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

    千次阅读 2016-04-26 16:52:07
    数据结构顺序表

    数据结构顺序表


    展开全文
  • C语言数据结构顺序表的查找算法

    千次阅读 2019-06-04 11:58:46
    *顺序表结构体里面包含 数据数组 和 数组长度 *采用两种查找方法 哨兵设置 普通查找 *哨兵排序算法的设置的好处是可以降低时间的复杂度 节省 for循环的次数 *程序 的步骤分为 初始化顺序表 创建顺序表 查找 输出 ...

    /*
    *顺序表的查找算法(重点是哨兵的设置)
    *创建一个数据结构体
    *创建一个顺序表的结构体
    *顺序表结构体里面包含 数据数组 和 数组长度
    *采用两种查找方法 哨兵设置 普通查找
    *哨兵排序算法的设置的好处是可以降低时间的复杂度 节省 for循环的次数
    *程序 的步骤分为 初始化顺序表 创建顺序表 查找 输出 测试
    */

    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #define MAX_SIZE 1024//数据的个数
    typedef  int KeyType;//关键字的数据类型
    typedef  char* ValueType;//标识字符串的数据类型
    typedef int Statu;//返回值的数据类型
    
    #define ERROR 0
    #define OK 1
    typedef struct elementtype
    {
        KeyType key;//关键字
        ValueType value;//数据域
    
    }ElementType;//顺序表中的数据结构体
    typedef struct seqlist
    {
        ElementType *datas;//数据数组
        int length;//顺序表长度
    }SeqList;//顺序表点的结构体数据类型
    void InIt(SeqList*s);//顺序表的初始化
    void test();//测试函数
    void print_seqlist(SeqList*s);//打印顺序表
    Statu search_seqlist1(SeqList*s,KeyType key);//顺序表的节点数据的查找
    Statu search_seqlist2(SeqList*s,KeyType key);//顺序表的节点数据的查找(设置哨兵元素)
    
    void main()
    {
        test();//测试函数
    }
    void InIt(SeqList*s)//顺序表的初始化
    {
        s->datas=(ElementType*)malloc(sizeof(ElementType)*MAX_SIZE);//创建顺序表的储存空间
        s->length=0;//初始化顺序表的长度
    }
    void print_seqlist(SeqList*s)//打印顺序表的元素
    {
        int i;
        for(i=1;i<=s->length;i++)//下标为0的位置不放数据
              printf("%d %s\n",s->datas[i].key,s->datas[i].value);
    
    
    
    }
    Statu search_seqlist1(SeqList*s,KeyType key)//顺序表的节点数据的查找
    {
        int i;
       // printf("%d\n",s->length);
        for(i=1;i<=s->length;i++)
        {
            if(s->datas[i].key==key)
                return i;
        }
        return 0;
    }
    Statu search_seqlist2(SeqList*s,KeyType key)//顺序表的节点数据的查找(设置哨兵元素)
    {
        //好处节省了for循环中循环条件的判断
          //设置哨兵和将第一个数组的位置空下来是一样的
         s->datas[0].key=key;
        int i;
        for(i=s->length-1;s->datas[i].key!=key;i--)
               return i;
    
    
    
    
    
    
    }
    
    
    展开全文
  • 数据结构 顺序表的删除操作

    千次阅读 2020-04-20 21:53:58
    本题要求实现一个函数,要求将顺序表的第i个元素删掉,成功删除返回1,否则返回0; 函数接口定义: int ListDelete(SqList &L,int i); 其中SqList结构定义如下: typedef struct{ ElemType *elem; int ...
  • *顺序表的相关操作 *创建顺序表(顺序存储) *创建数组 ...*遍历顺序表数据 */ #include<stdio.h> #include<time.h> #include<stdlib.h> #include<string.h> #define MAXSI...
  • ``` Status LocateElem(SqList L,ElemType e,Status(*compare)(ElemType,ElemType)) { ElemType *p; int i=1; p = L.elem ; while(i!compare(*p++,e)) ++i; if(i) return i; else return Error;...
  • 数据结构 顺序表 时间复杂度

    千次阅读 2019-05-26 15:14:46
    1.顺序表数据逻辑有连续性,物理存储上也具有连续性 (中间不能空,要紧紧相连这点和数组区别) 2.链表: 数据逻辑有连续性,物理存储上不一定具有连续性 3.顺序表: 创建/销毁 增删查改 增:头插/尾插/插入...
  • 数据结构顺序表创建及操作

    千次阅读 2015-11-06 09:53:39
    数据结构顺序表的创建及操作
  • 顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。简单来说,我们将电脑存储空间想象成一个个网格的形状,每个格子都存储一个数据,那么使用顺序表存储数...
  • 数据结构 顺序表(c++实现)

    千次阅读 2015-09-27 20:39:54
    实现了顺序表的基本操作 代码均为原创,转载请注明源地址blog.csdn.net/u012350104 欢迎留言交流 实现的功能: =====开始===== ==增加(1)== ==删除(2)== ==修改(3)== ==查询(4)== ==退出(0...
  • 数据结构顺序表基本流程

    千次阅读 2017-11-13 21:59:19
    生活中很多事物是有顺序关系的,如班级座位从前到后是按排的顺序,从左到右是按列的顺序,可以很方便的定位到某一个位置,但如果座位是散乱的,就很难定位。 在程序中,经常需要将一组(通常是同为某个类型的)数据...
  • //所有数据往后挪一位 { L->data[k+1]=L->data[k]; L->str[k+1]=L->str[k]; } } L->data[i-1]=e; L->str[i-1]=str; L->length++; return OK; } int ListDelete(SqList *L,int i) { int k; ...
  • 数据结构顺序表的c语言实现

    千次阅读 多人点赞 2019-05-18 15:21:55
    文章目录顺序表的c语言实现定义顺序表结构体初始化顺序表操作计算顺序表的长度获取顺序表中元素新元素插入顺序表删除某位置的元素查询某元素的位置打印整个顺序表顺序表的整体源码 线性表的顺序存储是指用一组...
  • 今天完成的是顺序表的简单功能实现 #include #define maxSize 100 using namespace std; typedef struct{  int data[maxSize];//data数组用来放数据  int length;//length是数组的长度 }Sqlist; //建立一个...
  • 顺序表的实现之查找功能 实现文件 更新于2020年4月13日 **************************************************************/ #include <stdio.h> #include <stdlib.h> #include "SeqList.h" void SL_...
  • 数据结构顺序表中 *L 和 *&L

    千次阅读 2019-05-23 17:13:03
    &是引用的意思,要返回到main里面进行操作、改变的顺序表需要带上&,如果只在对应函数操作的顺序表则不用。
  • 数据结构-顺序表的顺序存储

    千次阅读 2019-11-11 09:54:41
    用一组地址连续的存储单元依次存储线性表中每个数据元素,这种存储结构称为线性表的顺序存储结构,用这种结构表示的线性表称为顺序表。 特点: 用数据元素在计算机内物理位置相邻来表示线性表中数据元素之间的...
  • 数据结构顺序表

    千次阅读 2021-02-06 19:23:34
    顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在...通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系...
  • 数据结构-顺序表基本操作的实现(含全部代码)

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。...
  • 目录一、数据结构1.1 算法与数据结构的区别二、顺序表2.1 顺序表的基本形式【重点】2.2 顺序表的两种基本实现方式【重点】1、一体式结构:2、分离式结构:2.3 元素存储区替换与扩充1. 元素存储区的替换2. 元素存储区...
  • 实验一:数据结构顺序表的建立

    千次阅读 2017-09-24 21:07:48
    实验一 线性表的基本操作实现及其应用 ...1、顺序表的建立与操作实现 建立 n 个元素的顺序表(n 的大小和表里数据自己确定)。 2、实现相关的操作:输出,插入,删除,查找等功能。 3、编写完整程
  • 数据结构 - 顺序表

    千次阅读 2020-05-30 16:55:22
    数据结构 - 顺序表基本实现思想
  • Java——数据结构顺序表

    千次阅读 多人点赞 2021-04-26 22:10:54
    Java——数据结构顺序表   在之前的学习中,我们主要了解了很多 Java 的 基本语法,但是 在之后的 Java学习中,了解 基础 数据结构的知识 非常重要,数据结构的思想 可以帮助我们更加清晰 明白的了解 Java 的...
  • 考研笔记 数据结构代码 本人小白一个,考研的科目是数据结构 就用此博客来记录练习的代码。借鉴了别人的很多地方和天勤书上的内容。 顺序表 构建一个顺序表 实现以一下功能 1.找出最大值 2.正序输出 3.插入一个元素 ...
  • 数据结构——顺序表(定义详解及创立顺序表并操作) 顺序表定义:顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑...
  • 数据结构顺序表详解

    千次阅读 多人点赞 2019-04-05 21:03:57
    线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串… 线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常...
  • 数据结构顺序表的操作全集(创建,遍历,插入,删除,排序等等) #include"stdio.h" #include"stdlib.h" #include"malloc.h" #define list_size 100 typedef struct Node { int data[list_size]; int len; }...
  • 数据结构 顺序表的应用——学生信息统计

    万次阅读 多人点赞 2016-09-18 19:09:52
    定义一个包含学生信息(学号,姓名,成绩)的的 顺序表和链表,使其具有如下功能: (1) 根据指定学生个数,逐个输入学生信息; (2) 逐个显示学生表中所有学生的相关信息; (3) 根据姓名进行查找,返回此学生...
  • 2.掌握顺序表的存储结构; 3.掌握顺序表的创建、查找、插入、删除的实现方法; 实验内容 问题描述 在给出一组初始数据的情况下,实现顺序表的定义、创建、查找、插入、删除。 算法 顺序表的定义:一维数组、最大长度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 734,703
精华内容 293,881
关键字:

数据结构顺序表

数据结构 订阅