精华内容
下载资源
问答
  • 数据结构顺序表的创建
    千次阅读
    2022-03-02 15:55:14
    1. 实现顺序表的定义并创建顺序表。
    2. 实现线性表顺序存储结构下元素的插入操作。
    3. 实现线性表顺序存储结构下元素的删除操作。
    4. 实现线性表顺序存储结构下取元素操作。
      //数据结构构建一个线性表
      #include <iostream>
      using namespace std;
      typedef int ElemType;
      typedef int Status;
      #define M 100 
      #define ok 1
      #define false 0
      typedef struct{
      	ElemType *elem;
      	int length;
      }sqlist;
      sqlist L;
      void Initlist(sqlist &L)
      {
      	L.elem =new ElemType[M];//用new创建一个新的空间
      	if(!L.elem );
      }
      void createlist(sqlist &L)//创建线性表 
      {
      	int i;
      	cout<<"请输入线性表的长度"<<endl;
      	cin>>L.length;
      	cout<<"请输入线性表中的元素"<<endl;
      	for(i=0;i<L.length;i++)
      	cin>>L.elem[i];
      }
      void OutputList(sqlist L)//输出线性表中的元素 
      {
      	int i;
      	cout<<"线性表中的元素为:"<<endl;
      	for(i=0;i<L.length;i++)
      	cout<<L.elem[i]<<"\t";
      }
      Status ListInsert_Sq(sqlist &L, int i, ElemType e)//表示在线性表L中的第i个位置插入元素e 
      {	//先判断插入的位置是否合理
      	if(i<1||i>L.length+1)
      	{
      	cout<<"插入失败,请重新输入位置插入"<<endl;	
      	return false;
      	}
      	else
      	cout<<"插入成功,插入后的元素为"<<endl;
      	//判断表的长度是否大于限定值
      	if(L.length==M)
      	{
      		cout<<"线性表的存储空间已存满"<<endl;
      		return false;
      	}
      	/*由于插入了新元素,原来线性表中的元素位置发生了改变,所以此时需要引入变量j来控制位置的移动*/
      	int j;
      	/*线性表插入时元素位置从后面先开始移动,因此j要从L.length-1的位置往前移动,直到第i个位置,即最终j的取值范围为j>=i-1*/
      	for(j=L.length-1;j>=i-1;j--)
      	L.elem[j+1]=L.elem[j];//插入元素后长度变长,因此要把第i个元素之后的位置加1
      	/*此时第i个位置已经腾出来,因此需要在第i个位置上插入元素e,注意第i个位置下标为i-1*/
      	L.elem[i-1]=e;//此时线性表的长度相应增加
      	L.length++;
      	return ok;		
      } 
      Status ListDelete_Sq(sqlist &L, int i) 
      {
      	//先判断删除的位置是否符合要求
      	int j;
      	if(i<1||i>L.length)
      	{
      		cout<<"删除失败,请重新输入位置删除"<<endl;
      		return false;
      	 }
      	 else
      	 cout<<endl<<"删除成功,删除后剩余的元素为"<<endl ;
      	 for(j=i;j<=L.length;j++)
      	 L.elem[j-1]=L.elem[j];
      	 int e= L.elem[j-1];
      	 L.length--;
      	 for(j=0;j<L.length;j++)
      	 cout<<L.elem[j]<<"\t";
      	 return e;
      }
      Status GetElem(sqlist L, int i, ElemType &e) //取值 
      {
      	int j;
      	if(i<1||i>L.length)
      	{
      		cout<<"取出失败,请重新输入位置取出"<<endl;
      		return false;
      	 }
      	 else
      	 cout<<"取出成功,取出的元素为" <<endl;
      	 e=L.elem[i-1];
      	 cout<<e<<endl;
      	 return ok;
      }
      int LocateElem_Sq(sqlist L, ElemType e)//查找 
      {
      	int i;
      	for(i=0;i<L.length;i++)
      	{
      		if(L.length=e)
      		return i+1;
      	 } 
      	 return false;
      }
      int main(){
      	int i;
      	int e;
      	Initlist(L);
      	createlist(L);
      	OutputList(L);
      	ListInsert_Sq(L,9,10);
      	if(	ListInsert_Sq(L,3,67))
      	{
      		for(i=0;i<L.length;i++)
      		cout<<L.elem[i]<<"\t"; 
      	}
      	ListDelete_Sq(L,6);
      	ListDelete_Sq(L,8);
      	GetElem(L,6,e);
      	LocateElem_Sq(L,35);
      	LocateElem_Sq(L,42);
      	return 0;
      }
       
      

    更多相关内容
  • 数据结构 创建顺序表

    千次阅读 2021-03-25 19:30:03
    3.18数据结构——创建顺序表 运行结果截图: #define _CRT_SECURE_NO_WARNINGS #define MAXSIZE 100 #include<stdio.h> #include<string.h> #include<iostream> typedef int ElemType; ...

    3.18数据结构——创建顺序表

    运行结果截图:在这里插入图片描述
    在这里插入图片描述

    #define _CRT_SECURE_NO_WARNINGS
    #define MAXSIZE 100
    #include<stdio.h>
    #include<string.h>   
    #include<iostream>
    
    typedef int ElemType;
    
    typedef struct  //定义结构
    {
        ElemType* element;
        int length; 
        int listsize;
     
    } SqList;
    
    //初始化顺序表
    int initList(SqList& L) 
    { 
        L.element = new ElemType[MAXSIZE];
        if (!L.element)
            return 0; 
        //内存分配失败,存储空间不够
        L.length = 0;
        return 1;
    }
    
    SqList createList_sq() //创建顺序表
     {  
        SqList* list = (SqList*)malloc(sizeof(SqList));
        return *list;
    }
    SqList L;
    
    
    int Find(SqList& L)//赋值 并查找
    {
        //赋值
        int i;
        for (i = 1; i <= 10; i++)
        {
            L.element[i] = i;
        }
        return L.element[3];
    }
    
    int main()
    {
       
        SqList L;
        initList(L);
        createList_sq();
        int n;
        n = Find(L);        
        printf("该元素为:%d\n", n);
        return 0;
    }
    
    展开全文
  • 数据结构学习:顺序表创建

    千次阅读 2021-07-23 10:05:22
    数据结构学习:顺序表创建 如何使用代码创建一个静态顺序表,并初始化 #include <iostream> using namespace std; #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //采用静态数组...

    数据结构学习:顺序表的创建
    在这里插入图片描述
    如何使用代码创建一个静态顺序表,并初始化

    #include <iostream>
    using namespace std;
    #define MaxSize 10 //定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//采用静态数组来存放数据元素
    	int length;			//顺序表的当前长度
    }SqList;				//定义结构体顺序表的名称为SqList
    
    void InitList(SqList &L)
    {
    	for(int i = 0; i < MaxSize; i++)
    		L.data[i] = 0;	//将表里的所有元素设为0初始值	
    	L.length = 0;		//顺序表的初始长度为0
    }
    
    int main()
    {
    	SqList L;	//声明一个顺序表
    	InitList(L);	//初始化顺序表
    	for(int i = 0; i < MaxSize; i++)
    	cout<<"data["<<i<<"] = "<<L.data[i]<<endl;
       return 0;
    }
    

    运行结果为:

    data[0] = 0
    data[1] = 0
    data[2] = 0
    data[3] = 0
    data[4] = 0
    data[5] = 0
    data[6] = 0
    data[7] = 0
    data[8] = 0
    data[9] = 0
    

    如果不初始化的话,

    #include <iostream>
    using namespace std;
    #define MaxSize 10 //定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//采用静态数组来存放数据元素
    	int length;			//顺序表的当前长度
    }SqList;				//定义结构体顺序表的名称为SqList
    void InitList(SqList &L)
    {
    		
    	L.length = 0;		//顺序表的初始长度为0
    }
    
    int main()
    {
    	SqList L;	//声明一个顺序表
    	InitList(L);	//初始化顺序表
    	for(int i = 0; i < MaxSize; i++)
    	cout<<"data["<<i<<"] = "<<L.data[i]<<endl;
       return 0;
    }
    
    

    打印表中信息为:

    data[0] = 503362864
    data[1] = 32613
    data[2] = 0
    data[3] = 0
    data[4] = 4199024
    data[5] = 0
    data[6] = 4198560
    data[7] = 0
    data[8] = -1926700400
    data[9] = 32765
    

    内存中会有遗留的脏数据
    但是初始化一般是可以省略的,因为本来这种打印顺序表信息的方式就是违规的,因为定义的当前顺序表的长度为0,我们也并没有向表内存储信息,打印时令i < L.length的话,打印为空。
    更好的做法是使用基本操作来访问各个数据表

    静态分配存在一些问题顺序表的表长刚开始确定后就无法更改(存储空间是静态的),存储满了以后是无法扩大的提前声明会导致内存空间的不足或者浪费。
    所以就要用到动态表
    顺序表的实现 —— 动态分配
    可以通过使用malloc函数来申请一片连续的内存空间来存储数据,要增加内存空间时,则申请一片更大的空间来储存,并将原来的空间释放
    要注意malloc函数的头文件#include<stdlib.h>。

    #include <iostream>
    #include<stdlib.h>
    using namespace std;
    #define InitSize 10 //顺序表的初始长度
    
    typedef struct{
    int *data; //指示动态分配数组的指针
    int MaxSize; //顺序表的最大容量
    int length; //顺序表的当前长度
    } SeqList; //顺序表的类型定义(动态分配方式)
    
    void InitList(SeqList &L)
    {//用malloc函数申请一片连续的存储空间来存储数据
    	L.data = (int *)malloc(InitSize*sizeof(int));
    	//(int *)中的int要与结构体中data指针的数据类型保持一致
    	L.length = 0;		//顺序表的初始长度为0
    	L.MaxSize = InitList;
    }
    
    //增加动态数组的长度
    void IncreaseSize(SeqList &L,int len)
    {
    	int *p = L.data;
    	L.data = (int *)malloc((L.MaxSize + len)*sizeof(int));//元素个数乘以元素所占空间
    	//重新申请一片更大连续的内存空间来存储数据
    	for(int i = 0; i < L.length; i++)
    	{
    		L.data[i] = p[i];			//将数据复制到新区域
    	}
    	L.MaxSize = L.MaxSize + len;	//顺序表最大长度增加len
    	free(p);						//释放原来的内存空间	
    }
    
    int main()
    {
    	SeqList L;		//声明一个顺序表
    	InitList(L);	//初始化顺序表
    	IncreaseSize(L,5); 	//顺序表增加5个元素的空间
       return 0;
    }
    
    展开全文
  • 数据结构顺序表创建及操作

    千次阅读 2015-11-06 09:53:39
    数据结构顺序表创建及操作

    数据结构顺序表的创建及操作

    1. 结构体创建(两种结构体定义方式)
      方式一:给结构体Sqlist定义了个别名
        typedef struct Sqlist{
            int elem[MAXSIZE];
            int length;
        }Sqlist_t;

    方式二:定义一个名字为Sqlist的结构体

        struct Sqlist{
            int elem[MAXSIZE];
            int length;
        };

    区别之处在于第一种方式给结构体定义了个别名
    注释:
    int elem[MAXSIZE]:表示定义一个数据类型为int的数组用于存储int型数据(根据你要存储的数据类型可自由修改),MAXSIZE代表数组长度
    int length:表示结构体的另一个属性(用于表示从第几个数据开始为空)

    2.初始化赋值

        void create(Sqlist &L){
            int n;
            printf("要输入数据的个数:");
            scanf("%d",&n);
            fflush(stdin);
            while(n > MAXSIZE){
                printf("越界、请从新输入:");
                scanf("%d",&n);
                fflush(stdin);
            }
            L.length = 0;//表示第几个数据开始为空
            for(int i = 0; i < n; i++){
                L.elem[L.length]=i;
                L.length++;
            }
        }

    3.数据展示

        void show(Sqlist L){
            int i = 0;
            while(i<L.length){
                printf("%d\n",L.elem[i]);
                i++;
            }
        }

    4.数据删除

        void delData(Sqlist &L,int id){
            if(id < 0 || id >= L.length){
                printf("输入有误!");
            }else{
                for(int i = id; i < L.length; i++){
                    L.elem[i-1] = L.elem[i];
                }
                L.elem[L.length]=NULL;
                L.length--;
            }
        }

    注释:
    id:表示要删除的位置(要做判断避免越界);
    从第id个位置开始将后面的数据都往前提一位(for循环的功能);
    L.elem[L.length]=NULL;表示将最后一位设为NULL(空);
    L.length–;表示第几个位置开始为空;

    5.添加数据

        void addData(Sqlist &L,int id,int data){
            if(id < 0 || id > L.length){
                printf("输入有误!");
            }else{
                for(int i = L.length; i >= id; i--){
                    L.elem[i] = L.elem[i-1];
                }
                L.elem[id-1] = data;
                L.length++;
            }
        }

    注释:
    id:表示位置、位置必须连续
    从第id个位置开始将后面的数据都往后一位(for循环的功能);
    L.elem[id-1]=data;表示将第id位设为data;
    L.length++;表示第几个位置开始为空;

    6.取数据(按位置取、并返回值)

        int selectData(Sqlist L,int id){
            if(id < 0 || id >= L.length){
                printf("输入有误!");
                return -1;
            }else{
                int data = L.elem[id-1];
                return data;
            }
        }

    7.数据匹配(按值匹配,返回第一次出现的位置)

        int findId(Sqlist L,int data){
            for(int i = 0; i < L.length; i++){
                if(L.elem[i] == data){
                    return i+1;
                }
            }
            return -1;
        }

    注释:
    遍历每一个位置进行匹配、匹配成功,则返回位置。否则返回-1

    8.主方法

        void main(){
                Sqlist La;//定义一个名字为La的结构体变量
                create(La);//初始化赋值
                show(La);//数据展示
                addData(La,4,20);//在第四个位置添加数据20
                show(La);
                delData(La,7);//删除第七个位置数据
                show(La);
                int data = selectData(La,2);//查找第二位置的数据
                printf("%d\n",data);
                int id = findId(La,8);//匹配数据8的第一个位置
                printf("%d\n",id);
        }

    谢谢大家、欢迎补充!大家一起学习。

    展开全文
  • 数据结构顺序表创建初始化)

    千次阅读 2021-03-30 21:30:17
    数据结构顺序表创建初始化) 顺序表和链表不同,顺序表类似数组,顺序存储就是地址连续,而链表由于指针的存在地址可以不连续。 既然是一个顺序表是一个类似数组的结构,因此在创建时要注意: 1.提前申请足够大...
  • 数据结构(C++版)实现顺序表创建,输入,输出,插入,删除,取值 顺序表 顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得...
  • 顺序表创建

    千次阅读 2022-05-16 13:17:47
    1、数据结构的最简单的顺序表顺序表功能就是插入数据、删除数据、打印数据。 其他函数就是在这几个的基础上修改 第一步:插入数据 首先先创建一个顺序表并且初始化 顺序表就相当于是一个数组。 初始...
  • 顺序表创建与使用

    2019-08-24 10:44:36
    顺序表需要实现的各种功能:创建顺序表、销毁顺序表、访问顺序表中指定下标的元素、在顺序表中查找指定元素、对顺序表排序、遍历打印顺序表、删除顺序表中指定下标的元素、在顺序表中指定下标插入元素等。
  • 作为一名才接触c语言半年的大一学生,在自学数据结构时是非常痛苦的,单是第一章顺序表创建与操作就令我苦不堪言,在经过两天的钻研后,基本才算理顺了顺序表,所以我就想写下这篇人生中第一篇博客记录我对c语言...
  • 数据结构顺序表

    千次阅读 多人点赞 2022-03-10 00:30:28
    目录 一、顺序表介绍 ... 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
  • 博主第一次发布的小程序,是数据结构实验课的第一次实验顺序表创建及其应用。其中包含创建顺序表,输出顺序表,在顺序表中插入元素,在顺序表中删除元素,合并两个顺序表,反转顺序表这几个具体的方法。
  • 1)编写函数,创建一个顺序表;2)编写函数,在顺序表的指定位置插入一个元素;3)编写函数,在顺序表的指定位置删除一个元素;4)编写函数,将两个有序顺序表合并成一个新的有序顺序表
  • 超详细讲解数据结构顺序表

    千次阅读 多人点赞 2022-03-14 19:32:42
    超详细讲解数据结构顺序表顺序表概念静态顺序表动态顺序表动态循序表的概念及构造动态顺序表接口的实现检查顺序表的容量尾插与尾删头插与头删 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素...
  • 数据结构顺序表操作

    2019-11-20 18:21:44
    数据结构顺序表操作
  • python数据结构-顺序表

    千次阅读 2022-01-29 10:48:07
    顺序表 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素,这种表示也称作线性表的...通常,称这种存储结构的线性表为顺序表。其特点是,逻辑上相邻的数据元素,其物理次序也是相邻的。 ...
  • 这是数据结构和算法设计课程设计一个选题。实践了顺序表的基本操作的封装,及实践中的调用。特别的对顺序表上的插入和删除操作做出详细的介绍。课设采用静态存储,按值查找。希望能够对其他同学有所帮助
  • 数据结构初阶——顺序表

    千次阅读 多人点赞 2022-04-29 10:17:19
    博客写到这里,关于C语言的相关内容就告一段落了,从这篇开始,跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构!!!
  • 数据结构——顺序表

    千次阅读 多人点赞 2021-11-25 22:52:15
    线性表是n个具有相同特性的数据元素的有限序列。常见的线性表:顺序表、链表、栈、队列、字符串…
  • 数据结构基础入门】顺序表的概念、结构和接口实现
  • 数据结构实验报告-顺序表创建遍历及有序合并操作 二实验内容与步骤 实现顺序表创建遍历及有序合并操作基本数据结构定义如下 typedef int ElemType; #define MAXSIZE 100 #define FALSE 0 #define TRUE 1 ...
  • 数据结构有序创建与输出

    千次阅读 2017-11-23 17:50:09
    数据结构有序创建与输出 //有序 #include #include typedef int Element; //数据类型 typedef struct node{  Element data; //元素  struct node * next; //节点域 }SortList; /* 创建列表...
  • 数据结构顺序表创建、插入、删除、定位
  • 概述: 顺序表为线性表的顺序存储结构,且这种线性存储结构是一种随机存取的存储结构。 一、创建顺序表 在构造一个顺序表之前,首先我们先要
  • C语言实现顺序表数据结构

    千次阅读 多人点赞 2022-04-22 19:00:54
    以下是我们需要实现的顺序表的功能。 以下是写在SeqList.h中的内容,我们将全部需要声明的内容放在此处 pragma once #include <stdio.h> #include <assert.h> #include <stdlib.h> typedef ...
  • 数据结构-顺序表基本操作的实现(含全部代码)

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构...L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n) InitList(SqList &...
  • 数据结构:(C/C++版)顺序表创建,初始化与,输入,输出,插入,删除,排序,顺序插入等基础操作
  • 数据结构——创建顺序表

    万次阅读 多人点赞 2017-09-18 21:55:58
    一、实验目的1、熟练掌握线性表的结构特点,掌握顺序表的基本操作。 2、巩固 C++相关的程序设计方法与技术。 3、学会使用顺序表解决实际问题。 二、实验内容1、顺序表的建立与操作实现 建立n个元素的顺序表(n ...
  • 数据结构课程顺序表的基本功能实现,包括顺序表创建、插入、删除元素等。
  • 目录一、数据结构1.1 算法与数据结构的区别二、顺序表2.1 顺序表的基本形式【重点】2.2 顺序表的两种基本实现方式【重点】1、一体式结构:2、分离式结构:2.3 元素存储区替换与扩充1. 元素存储区的替换2. 元素存储区...
  • 顺序表,全名顺序存储结构,是线性表的一种。线性表用于存储逻辑关系为“一对一”的数据顺序表自然也不例外。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 518,496
精华内容 207,398
热门标签
关键字:

数据结构顺序表的创建

数据结构 订阅
友情链接: TIDM02002.zip