精华内容
下载资源
问答
  • 数据结构顺序表的实现
    千次阅读 多人点赞
    2019-01-19 11:47:00

    顺序表是一种简单的数据存储结构,既然把数据存起来就肯定要用,利用顺序表充当集合来实现集合的常用3种运算是一种常见的问题。代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    #define OK 1
    #define FALSE -1
    #define TURE 1
    #define ERROR -1
    #define OVERFLOW -1
    #define INFEASIBLE -1
    #define LIST_INIT_SIZE 100  
    #define LISTINCREMENT 10  
    typedef int Status;
    typedef int ElemType;
    
    typedef struct
    {
    	ElemType *elem;
    	int length;
    	int listsize;
    }Sqlist;
    
    Status InitList(Sqlist &L)//顺序表的创建,把顺序表当集合用
    {
    	L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
    	if (!L.elem) exit(OVERFLOW);
    	L.length = 0;
    	L.listsize = LIST_INIT_SIZE;
    	return OK;
    }
    
    Status LengthList(Sqlist L)
    {
    	return L.length;
    }
    
    Status LocateELem(Sqlist L, ElemType e)//定位函数,找到某个元素的位置
    {
    	int i = 1;
    	bool cmp = 0;
    	while (i <= L.length && !cmp)
    	{
    		if (L.elem[i - 1] == e)
    			cmp = 1;
    		i++;
    	}
    	if (cmp)
    		return i - 1;
    	else return 0;
    }
    
    void TraverList(Sqlist L)//遍历集合
    {
    	int i;
    	if (L.length != 0)
    	{
    		for (i = 0; i < L.length; i++)
    			printf("%5d", L.elem[i]);
    	}
    	else printf("空集\n");
    
    }
    
    void  InsertElem(Sqlist L, int i, ElemType e)//插入元素
    {
    	ElemType *p, *q;
    	if (i<0 || i>L.length + 1)
    	{
    		printf("位置不正常\n");
    		return;
    	}
    	if (L.length == L.listsize)
    	{
    		L.elem = ((ElemType*)realloc(L.elem, (LIST_INIT_SIZE + LISTINCREMENT) * sizeof(ElemType)));
    		L.listsize = LIST_INIT_SIZE + LISTINCREMENT;
    	}
    	q = &L.elem[i - 1];
    	for (p = &L.elem[L.length - 1]; p > q; p--)
    		*(p + 1) = *p;
    	*(q + 1) = e;
    	L.length++;
    }
    
    void Union_Sq(Sqlist La, Sqlist Lb, Sqlist &Lc) {//并集的实现
    	int i;
    	ElemType elem;
    	Lc.length = 0;
    	for (i = 0; i < La.length; i++)
    		Lc.elem[Lc.length++] = La.elem[i];
    	Lc.length = La.length;
    	for (i = 1; i <= Lb.length; i++) {
    		elem = Lb.elem[i - 1];
    		if (!LocateELem(La, elem))
    		{
    			InsertElem(Lc, Lc.length, elem);
    			Lc.length++;
    		}
    	}
    }
    
    void Mix_Sq(Sqlist La, Sqlist Lb, Sqlist &Lc) {//交集的实现
    	int i;
    	ElemType elem;
    	Lc.length = 0;
    	for (i = 1; i <= La.length; i++) {
    		elem = La.elem[i - 1];
    		if (LocateELem(Lb, elem))
    		{
    			InsertElem(Lc, Lc.length, elem);
    			Lc.length++;
    		}
    	}
    }
    
    void Differ_Sq(Sqlist La, Sqlist Lb, Sqlist &Lc) {//差集的实现
    	int i;
    	ElemType elem;
    	Lc.length = 0;
    	for (i = 1; i <= La.length; i++) {
    		elem = La.elem[i - 1];
    		if (!LocateELem(Lb, elem))
    		{
    			InsertElem(Lc, Lc.length, elem);
    			Lc.length++;
    		}
    	}
    }
    
    int main()
    {
    	Sqlist La, Lb, Lc, Ld, Le;
    	InitList(La);
    	InitList(Lb);
    	InitList(Lc);
    	InitList(Ld);
    	InitList(Le);
    	int i;
    	ElemType e = 0;
    	printf("初始顺序表1的长度%d\n\n", LengthList(La));
    	printf("请输入要添加的元素个数:");
    	scanf_s("%d", &La.length);
    	printf("\n当前顺序表的长度%d\n", LengthList(La));
    	printf("\n请输入线性表元素:");
    	for (i = 0; i < La.length; i++)
    		scanf_s("%d", &La.elem[i]);
    	printf("\n您输入的元素为:");
    	TraverList(La);
    	printf("\n");
    	printf("\n初始顺序表2的长度%d\n\n", LengthList(Lb));
    	printf("请输入要添加的元素个数:");
    	scanf_s("%d", &Lb.length);
    	printf("\n当前顺序表的长度%d\n", LengthList(Lb));
    	printf("\n请输入线性表元素:");
    	for (i = 0; i < Lb.length; i++)
    		scanf_s("%d", &Lb.elem[i]);
    	printf("\n您输入的元素为:");
    	TraverList(Lb);
    	printf("\n\n\n");
    	Union_Sq(La, Lb, Lc);
    	printf("1、2集合并集为:");
    	TraverList(Lc);
    	printf("\n1、2集合交集为:");
    	Mix_Sq(La, Lb, Ld);
    	TraverList(Ld);
    	printf("\n1、2集合差集为:");
    	Differ_Sq(La, Lb, Le);
    	TraverList(Le);
    	printf("\n");
    	return 0;
    }
    
    更多相关内容
  • 这是讲解代码中函数关系的Keynote 为了大家方便,已转换为ppt 博客地址blog.csdn.net/u012350104
  • 数据结构基础入门】顺序表的概念、结构和接口实现
                              你们的每个赞和支持都能让我开心好几天!😉
    

    今天起开始编写数据结构中的各种数据结构及算法的实现,说到顺序表,我们首先得了解下线性表。

    1.线性表

    线性表(linear list)是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构,常见的线性表:顺序表、链表、栈、队列、字符串…
    线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不一定是连续的,线性表在物理上存储时,通常以数组链式结构的形式存储。
    线性表的存储

    2.顺序表

    2.1概念及结构

    顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。顺序表一般可分为:

    1.静态顺序表:使用定长数组存储。
    2.动态顺序表:使用动态开辟的数组存储。

    //顺序表的静态存储 
    #define N 100
    struct SeqList
    {
    	int a[N];//定长存储
    	int size;//有效数据的个数
    };
    
    //顺序表的动态存储
    typedef struct SeqList
    {
    	SeqDataType* a;//指向动态开辟的数组
    	int size;	  //有效数据个数
    	int capacity; //容量
    }SeqList;
    

    顺序表本质上是数组,在数组上增加了两个要求:

    1.插入数据的过程中,可以动态增长
    2.并且要求里面存储的数据必须是从左往右,是连续的

    顺序表的缺陷

    1.动态增容有性能消耗
    2.头部插入数据时,需要挪动数据

    2.2 提供接口

    静态顺序表只适用于确定知道需要存多少数据的场景。静态顺序表的定长数组导致N定大了,空间开多了浪费,开少了不够用。所以现实中基本都是使用动态顺序表,根据需要动态的分配空间大小,所以下面我们来实现动态顺序表。

    首先在头文件<SeqList.h>中提供接口:

    typedef int SeqDataType; //需要插入什么类型的数据,就改成对应类型
    
    typedef struct SeqList
    {
    	SeqDataType* a;//指向动态开辟的数组
    	int size;	  //有效数据个数
    	int capacity; //容量
    }SeqList;
    
    //内存中管理数据结构 提供增删查改的接口
    //顺序表初始化
    void SeqListInit(SeqList* pq);
    //顺序表销毁
    void SeqListDestory(SeqList* pq);
    //顺序表打印
    void SeqListPrint(SeqList* pq);//打印数组
    //检查空间,如果满了,进行增容
    void SeqCheckCapacity(SeqList* pq)
    //顺序表尾插
    void SeqListPushBack(SeqList* pq, SeqDataType x);
    //顺序表头插
    void SeqListPushFront(SeqList* pq, SeqDataType x);
    //顺序表尾删
    void SeqListPopBack(SeqList* pq);
    //顺序表头删
    void SeqListPopFront(SeqList* pq);
    //顺序表查找x
    int SeqListFind(SeqList* pq, SeqDataType x);//查找 查到返回下标,没查到返回-1
    //顺序表在指定位置插入数据
    void SeqListInsert(SeqList* pq, int pos, SeqDataType x);//在下标pos位置处插入数据
    //顺序表在指定位置删除数据
    void SeqListErase(SeqList* pq, int pos);//把下标为pos位置处的数据删除
    //顺序表在指定位置替换数据
    void SeqListModify(SeqList* pq, int pos, SeqDataType x);//把小标为pos位置的值改为x
    
    

    2.4 接口实现

    在源文件SeqList.c中实现接口功能
    (1)顺序表初始化

    void SeqListInit(SeqList* pq)
    {
    	assert(pq != NULL);//或者 assert(pq); 断言 防止传入空指针
    	pq->a = NULL;
    	pq->size = 0;
    	pq->capacity = 0;
    }
    

    (2)顺序表销毁

    void SeqListDestory(SeqList* pq)
    {
    	assert(pq);
    	free(pq->a);
    	pq->a = NULL;
    	pq->size = 0;
    	pq->capacity = 0;
    }
    

    (3)顺序表打印

    void SeqListPrint(SeqList* pq)
    {
    	assert(pq);
    	for (int i = 0; i < pq->size; ++i)
    	{
    		printf("%d ", pq->a[i]);
    	}
    	printf("\n");
    }
    

    (4)检查空间,如果满了,进行增容

    //检查是否需要扩容
    void SeqCheckCapacity(SeqList* pq)
    {
    	//满了,需要增容
    	if (pq->size == pq->capacity)
    	{
    		int newcapacity = (pq->capacity == 0 ? 4 : pq->capacity * 2);
    
    		//realloc接收的地址如果为空,将像malloc一样,开辟一块新空间
    		SeqDataType* newA = realloc(pq->a, sizeof(SeqDataType) * newcapacity);//realloc返回 开辟的新空间的地址
    		if (newA == NULL)
    		{
    			printf("realloc fail\n");
    			exit(-1);//失败了就退出
    		}
    		pq->a = newA;
    		pq->capacity = newcapacity;
    	}
    }
    

    (5)顺序表尾插

    void SeqListPushBack(SeqList* pq, SeqDataType x)//尾插
    {
    	assert(pq);
    
    	SeqCheckCapacity(pq);
    
    	pq->a[pq->size] = x;
    	pq->size++;
    }
    

    (6)顺序表头插

    void SeqListPushFront(SeqList* pq, SeqDataType x)
    {
    	assert(pq);
    
    	SeqCheckCapacity(pq);
    
    	int end = pq->size - 1;
    	while (end >= 0)
    	{
    		pq->a[end + 1] = pq->a[end];
    		end--;
    	}
    	pq->a[0] = x;
    	pq->size++;
    }
    

    (7)顺序表尾删

    void SeqListPopBack(SeqList* pq)
    {
    	assert(pq);
    	assert(pq->size > 0);
    	pq->size--;
    }
    

    (8)顺序表头删

    void SeqListPopFront(SeqList* pq)
    {
    	assert(pq);
    	assert(pq->size > 0);
    
    	int begin = 0;
    	while (begin < pq->size - 1)
    	{
    		pq->a[begin] = pq->a[begin + 1];
    		begin++;
    	}
    	pq->size--;
    }
    

    (9)顺序表查找x

    int SeqListFind(SeqList* pq, SeqDataType x)
    {
    	assert(pq);
    	for (int i = 0; i < pq->size; ++i)
    	{
    		if (pq->a[i] == x)
    		{
    			return x;
    		}
    	}
    	return -1;//没找到
    }
    

    (10)顺序表在指定位置插入数据

    void SeqListInsert(SeqList* pq, int pos, SeqDataType x)
    {
    	assert(pq);
    	assert(pos >= 0 && pos < pq->size);
    
    	SeqCheckCapacity(pq);//检查是否需要扩容
    
    	int end = pq->size - 1;
    	while (end >= pos)
    	{
    		pq->a[end + 1] = pq->a[end];
    		end--;
    	}
    	pq->a[pos] = x;
    	pq->size++;
    }
    

    (11)顺序表在指定位置删除数据

    void SeqListErase(SeqList* pq, int pos)
    {
    	assert(pq);
    	assert(pos >= 0 && pos < pq->size);
    	int begin = pos;
    	while (begin <= pq->size - 1)
    	{
    		pq->a[begin] = pq->a[begin + 1];
    		begin++;
    	}
    	pq->size--;
    }
    

    (12)顺序表在指定位置替换数据

    void SeqListModify(SeqList* pq, int pos, SeqDataType x)
    {
    	assert(pq);
    	assert(pos >= 0 && pos < pq->size);
    
    	pq->a[pos] = x;
    }
    

    主函数的设计大家可以自由发挥,做个简单的测试功能调用函数或是创建菜单栏实现交互都可以。我水平有限,请朋友们谅解!写的不好的地方还请大佬们指出。最后,如果这篇文章对你有帮助,就点个赞或者收藏评论一下吧,谢谢大家支持😁。

    下期预告——单链表

    展开全文
  • #include <iostream> using namespace std; #define MAXSIZE 100 //顺序表的最大长度 typedef struct { int key; char *otherinfo; }ElemType;...//顺序表的存储结构 typedef st...
    
    #include <iostream>
    using namespace std;
    #define  MAXSIZE  100          						//顺序表的最大长度
    typedef struct
    {
    	int key;
    	char *otherinfo;
    }ElemType;
    //顺序表的存储结构  
    
                           
    typedef struct
    {
        ElemType *r;	         						//存储空间的基地址
        int  length;            						//顺序表长度
    }SqList;											//顺序表类型
    	
    												// SelectSort	
    void BubbleSort(SqList L)
    {
    	//对顺序表L做冒泡排序
    	int m,j,flag;
    	ElemType t;
        m=L.length-1; flag=1; 				//flag用来标记某一趟排序是否发生交换
        while((m>0)&&(flag==1))
    	{
    		flag=0;           				//flag置为0,如果本趟排序没有发生交换,则不会执行下一趟排序
            for(j=1;j<=m;j++)
    			if(L.r[j].key>L.r[j+1].key) 
    			{
    				flag=1;					//flag置为1,表示本趟排序发生了交换
    				t=L.r[j];L.r[j]=L.r[j+1];L.r[j+1]=t;	//交换前后两个记录
    			}							//if
    		--m;
        }									//while
    }										//BubbleSort
    	
    	
    	
    void SelectSort(SqList L) 
    { 
       //对顺序表L做简单选择排序
    	int i,j,k;
    	ElemType t;
        for(i=1;i<L.length;++i) 
    	{  												//在L.r[i..L.length] 中选择关键字最小的记录
    		k=i;                 
            for(j=i+1;j<=L.length;++j)
    			if(L.r[j].key<L.r[k].key)  k=j;			//k指向此趟排序中关键字最小的记录
    		if(k!=i) {t=L.r[i];L.r[i]=L.r[k];L.r[k]=t;} //交换r[i]与r[k]        
         }												//for  
    }		
    
    
    
    void InsertSort(SqList L)
    {
       //对顺序表L做直接插入排序
    	int i,j;
    	for(i=2;i<=L.length;++i)
    		if(L.r[i].key<L.r[i-1].key)
    		{   										//"<",需将r[i]插入有序子表
    			L.r[0]=L.r[i];				 			//将待插入的记录暂存到监视哨中
                L.r[i]=L.r[i-1];	            		//r[i-1]后移
                for(j=i-2; L.r[0].key<L.r[j].key;--j)			//从后向前寻找插入位置
    				L.r[j+1]=L.r[j];					//记录逐个后移,直到找到插入位置
                L.r[j+1]=L.r[0];						//将r[0]即原r[i],插入到正确位置
    		}											//if
    }													//InsertSort
    
    
    
    
    int Partition(SqList L,int low,int high)
    { 
    	//对顺序表L中的子表r[low..high]进行一趟排序,返回枢轴位置
    	int pivotkey;
    	L.r[0]=L.r[low];                    	//用子表的第一个记录做枢轴记录
    	pivotkey=L.r[low].key;		   			//枢轴记录关键字保存在pivotkey中
    	while(low<high)
    	{										//从表的两端交替地向中间扫描
    		while(low<high&&L.r[high].key>=pivotkey) --high;
    		L.r[low]=L.r[high];					//将比枢轴记录小的记录移到低端
    		while(low<high&&L.r[low].key<=pivotkey) ++low;
    		L.r[high]=L.r[low];					//将比枢轴记录大的记录移到高端
    	}//while
    	L.r[low]=L.r[0];						//枢轴记录到位
    	return  low;							//返回枢轴位置
    }//Partition
    
    
    
    void QSort(SqList L,int low,int high)
    {	//调用前置初值:low=1; high=L.length;
        //对顺序表L中的子序列L.r[low..high]做快速排序
    	int pivotloc;
        if(low<high)
    	{										//长度大于1
           pivotloc=Partition(L,low,high); 		//将L.r[low..high]一分为二,pivotloc是枢轴位置
           QSort(L,low,pivotloc-1);				//对左子表递归排序
           QSort(L,pivotloc+1,high);        	//对右子表递归排序
    	}
    }											//QSort
    
    
    
    
    void QuickSort(SqList L)
    {
       //对顺序表L做快速排序
       QSort(L,1,L.length);
    }								
    void Create_Sq(SqList &L)
    {
    	int i,n;
    	cout<<"请输入数据个数,不超过"<<MAXSIZE<<"个。"<<endl;
    	cin>>n;											//输入个数
    	cout<<"请输入待排序的数据:\n";
    	while(n>MAXSIZE)
    	{
    		cout<<"个数超过上限,不能超过"<<MAXSIZE<<",请重新输入"<<endl;
    		cin>>n;
    	}
    	for(i=1;i<=n;i++)
    	{
    		cin>>L.r[i].key;
    		L.length++;
    	}
    }
    void show(SqList &L)
    {
    	int i;
    	for(i=1;i<=L.length;i++)
    		cout<<L.r[i].key;
    }
    int main()
    {
    	int j; 
    	SqList L;
    	L.r=new ElemType[MAXSIZE+1];
    	L.length=0;
    	Create_Sq(L);	
    	printf("                    排序                            \n");
    printf("********************************************************\n");
    printf("*                1-----冒泡排序                        *\n");
    printf("*                2-----简单选择                        *\n");
    printf("*                3-----直接插入                        *\n");
    printf("*                4-----快速排序                        *\n");
        printf("\n");		
         while(1){
    		cout<<"\n请选择:\n";
    		cin>>j; 
    		switch(j)
             {
                 case 1:	SelectSort(L);
    			 cout<<"冒泡排序:"<<endl;
    	show(L);
    				   break;
                 case 2:BubbleSort(L);
    	cout<<"简单选择:"<<endl;
    	show(L);
    					break;
                 case 3:InsertSort(L);
    	cout<<"直接插入:"<<endl;
    	show(L);
    					break;
    			 case 4:	QuickSort(L);
    	cout<<"快速排序:"<<endl;
    	show(L);
    					break; 
            }
            }
    }
    

    代码参考《人民邮电出版社数据结构C语言版》
    楼主整合调试

    展开全文
  • 本学期数据结构第一次实验-顺序表C++实现
  • 顺序表存储结构实现——学生信息管理 一、实验目的 (1) 掌握顺序表的概念及实现方式。 (2) 掌握顺序表的存储结构及主要运算:建立、查找、插入、删除等。 二、实验环境 Windows 10,Microsoft Visual C++ 2010 ...

    顺序表存储结构及实现——学生信息管理

    一、实验目的
    (1) 掌握顺序表的概念及实现方式。
    (2) 掌握顺序表的存储结构及主要运算:建立、查找、插入、删除等。
    二、实验环境
    Windows 10,Microsoft Visual C++ 2010 Express
    三、实验内容
    1、内容描述
    定义一个包含学生信息(学号,姓名,成绩)的顺序表,使其具有如下功能:
    (1) 逐个输入学生信息,建立信息表;
    (2) 显示信息表中所有学生的相关信息;
    (3) 根据姓名进行查找,返回此学生的学号和成绩;
    (4) 给定一个学生信息,插入到表中指定的位置;
    (5) 删除指定位置的学生记录;
    (6) 统计表中学生人数。
    2、实现代码

    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    typedef struct{
        char no[10];   //学号
        char name[20]; //姓名
        int mark;     //成绩
    }student;
    typedef  struct{
      student *elem;  //存储空间的基地址
      int length;                                                           
     }sqlist;
     
    bool initlist(sqlist &L){
    	int n;
    	printf("输入学生人数:");
    	scanf("%d",&n);
    	L.elem=(student *)malloc(50*sizeof(student));
    	if(L.elem==NULL)
    		return false;
    	L.length=0;
    	printf("输入学生信息,按“学号 姓名 成绩”输入\n");
    	for(int i=0;i<n;i++){
    		printf("输入第%d位学生信息:",i+1);
            scanf("%s %s %d",&L.elem[i].no,&L.elem[i].name,&L.elem[i].mark);
    	}
    	L.length=n;
    	return true;
    }
    
    bool displist(sqlist L){
    	if(L.elem==NULL){
    		printf("请建立学生信息表!");
    		return false;
    	}
    	for(int i=0;i<L.length;i++){
    		printf("学号:%s  姓名:%s  成绩:%d\n",L.elem[i].no,L.elem[i].name,L.elem[i].mark);
    	}
    	return true;
    }
    
    bool deletelist(sqlist &L){
    	if(L.elem==NULL){
    		printf("请建立学生信息表!");
    		return false;
    	}
    	int i;
    	printf("输入删除的位置序号:");
    	scanf("%d",&i);
    	if(i<=0||i>L.length+1){
    		printf("请输入正确的序号!");
    		return false;
    	}
    	for(int j=i;j<L.length;j++){
    		L.elem[j-1]=L.elem[j];
    	}
    	L.length--;
    	return true;
    }
    
    bool countlist(sqlist L){
    	if(L.elem==NULL){
    		printf("请建立学生信息表!");
    		return false;
    	}
    	printf("学生人数为:%d\n",L.length);
    	return true;
    }
    
    bool inserlist(sqlist &L){
    	if(L.elem==NULL){
    		printf("请建立学生信息表!");
    		return false;
    	}
    	int i;
    	printf("输入插入的位置序号:");
    	scanf("%d",&i);
    	if(L.length>=50){
    		printf("顺序表已满!");
    		return false;
    	}
    	if(i<=0||i>L.length+1){
    		printf("请输入正确的序号!");
    		return false;
    	}
    	for(int j=L.length-1;j>=i-1;j--){
    		L.elem[j+1]=L.elem[j];
    	}
    	printf("输入插入的学生信息,按“学号 姓名 成绩”输入\n");
    	scanf("%s %s %d",&L.elem[i-1].no,&L.elem[i-1].name,&L.elem[i-1].mark);
    	L.length++;
    	return true;
    }
    
    bool seeklist(sqlist L){
    	int flag=0;
    	char na[20];
    	if(L.elem==NULL){
    		printf("请建立学生信息表!");
    		return false;
    	}
    	printf("输入查找的姓名:");
    	scanf("%s",na);
    	for(int i=0;i<L.length;i++){
    		if(strcmp(L.elem[i].name,na)==0){
    			flag=1;
    			printf("学号:%s  成绩:%d\n",L.elem[i].no,L.elem[i].mark);
    		}
    	}
    	if(!flag)
    		printf("未找到相关信息!\n");
    	return true;
    }
    
    void main(){
    	int choose=0;
    	sqlist L;
    	L.elem=NULL;
    	L.length=0;
    	printf("欢迎进入学生信息管理系统!\n"
    		 "1.建立\n"
    		 "2.显示\n"
    		 "3.查找\n"
    		 "4.插入\n"
    		 "5.删除\n"
    		 "6.计数\n"
    		 "7.退出\n"
    		);
    	while (choose!=7)
    	 {
    		 printf("\n选择序号:");
    		 scanf("%d",&choose);
    		 switch(choose)
    		 {
    		 case 1:
    			 if(!initlist(L))
    				 printf("建立失败!\n");
    			 else printf("建立成功!\n");
    			 break;
    		 case 2:
    			 if(!displist(L))
    				 printf("显示失败!\n");
    			 else printf("显示成功!\n");
    			 break;
    		 case 3:
    			 if(!seeklist(L))
    				 printf("查找失败!\n");
    			 else printf("查找成功!\n");
    			 break;
    		 case 4:
    			 if(!inserlist(L))
    				 printf("插入失败!\n");
    			 else printf("插入成功!\n");
    			 break;
    		 case 5:
    			 if(!deletelist(L))
    				 printf("删除失败!\n");
    			 else printf("删除成功!\n");
    			 break;
    		 case 6:
    			if(!countlist(L))
    				 printf("计数失败!\n");
    			 else printf("计数成功!\n");
    			break;
    		 case 7:
    			 free(L.elem);
    			 break;
    		 }
    	 }
     }
    

    四、实验体会
    通过本次实验,掌握了定义线性表的顺序存储类型,加深了对顺序存储结构的理解,进一步巩固和理解了顺序表的基本操作,如建立、查找、插入和删除等。同时,也体会到顺序存储结构的缺点:在插入或删除操作时,需要移动大量的元素,且长度相对固定,当表中数据元素个数较多且变化较大时,操作复杂。

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

    千次阅读 多人点赞 2022-03-10 00:30:28
    一、顺序表介绍 二、准备工作 1、创建顺序表 2、初始化顺序表 3、检测是否需要扩容 4、销毁顺序表 5、打印顺序表 三、四大功能 1、增加数据 头插 尾插 指定下标插入 2、删除数据 头删 ...
  • C语言实现顺序表数据结构

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

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。 今天是线性表中的顺序表实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。...
  • 数据结构课程顺序表的基本功能实现,包括顺序表的创建、插入、删除元素等。
  • 2. 将所学数据结构方面的知识与具体的语言来进行实现,感受数据结构的强大作用,加深理解。 二、实验内容: 编写一个简单的学生信息管理程序,能实现对学生信息的简单管理。建立一个学生的信息登记,每个学生的...
  • 数据结构——图书信息管理系统的顺序表实现

    万次阅读 多人点赞 2019-05-04 10:16:17
    大部分代码来自严蔚敏老师的《数据结构》教材,但对于书上的伪代码,有编译运行不了的地方,我进行了修改,使得程序可以正常运行,功能正常使用。 代码利用顺序表制作了一个图书信息管理系统,可以进行增、删、查...
  • 以下代码为使用C++完成顺序表的静态实现 后面会尝试顺序表的动态实现 #include<iostream> using namespace std; #define maxSize 10 struct sqlList { int data[maxSize]; //静态的“数组”存放数据 int...
  • 数据结构顺序表的构建

    千次阅读 2022-03-02 15:55:14
    实现顺序表的定义并创建顺序表实现线性表顺序存储结构下元素的插入操作。 实现线性表顺序存储结构下元素的删除操作。 实现线性表顺序存储结构下取元素操作。 //数据结构构建一个线性表 #include <...
  • 数据结构顺序表实现 - 详解(C语言版)

    千次阅读 多人点赞 2022-03-13 17:00:47
    目录 前言 线性表: ​ 顺序表: 概念及结构: ...顺序表实现: ...具体函数的实现:SeqList.c ...顺序表的初始化: ...顺序表的打印: ...顺序表的尾插: ...顺序表的尾删: ...简单用C语言来描述数据结构中的顺序表......
  • 顺序表实现多项式相加

    千次阅读 2019-10-30 14:06:39
    数据结构——顺序表 #include <stdio.h> #include <stdlib.h> /** =====================存储结构定义 开始======================= */ #define MAX_SIZE 128 /*顺序表中元素的类型,描述多项式中每一项...
  • 顺序表各种接口实现
  • python数据结构-顺序表

    千次阅读 2022-01-29 10:48:07
    顺序表 线性表的顺序表示指的是用一组地址连续的存储单元依次存储线性表的数据元素,这种表示也称作线性表的...通常,称这种存储结构的线性表为顺序表。其特点是,逻辑上相邻的数据元素,其物理次序也是相邻的。 ...
  • 线性表是n个具有相同特性的数据元素的有限序列线性表是一种在实际中广泛使用的数据结构,常见的线性表顺序表、链表、栈、队列、字符串…线性表在逻辑上是线性结构,也就说是连续的一条直线。但是在物理结构上并不...
  • 数据结构顺序表基本操作(C/C++实现

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

    千次阅读 2021-04-11 21:52:05
    数据结构之python实现顺序表 顺序表是指采用顺序存储的方式来存储数据元素的线性表。 初始化以及创建顺序表 class SequenceList(object): def __init__(self): self.seq_list = [] def create_sequence_list...
  • 顺序存储结构实现一元多项式的加法、减法和乘法。具体要求为:用五个函数分别实现一元多项式的创建、输出、加法、减法和乘法;然后在主函数中调用这些函数实现这些功能的展示。 代码内容 #include<iostream>...
  • 数据结构--顺序表实现(c语言实现)

    千次阅读 2021-05-25 18:22:12
    最近终于开始学数据结构了,开个坑记录一下 首先,顺序表是一段物理地址连续的存储单元依次存储数据元素的线性结构,一般情况下采用数组存储。在数组上完成数据的增删查改。 顺序表一般可以分为: 1.静态顺序表:...
  • 数据结构初阶——顺序表

    千次阅读 多人点赞 2022-04-29 10:17:19
    博客写到这里,关于C语言的相关内容就告一段落了,从这篇开始,跟我一起进入一个全新的领域吧。把顺序表的代码放到了结尾。击鼓进军数据结构!!!
  • 数据结构顺序表的指针(C语言)简单实现 思来想去决定向嵌入式系统方向靠拢。虽然本科是电子信息科学与技术,但是从未学过数据结构、操作系统等计算机方面的专业课。故最近开始学习数据结构,使用严蔚敏老师的第二版...
  • 数据结构---顺序表实验(C语言实现

    千次阅读 多人点赞 2020-10-29 00:36:40
    在给出一组初始数据的情况下,实现顺序表的定义、创建、查找、插入、删除。 算法 顺序表的定义:一维数组、最大长度、实际长度 顺序表的创建:初始化顺序表 顺序表的查找:给出位置 i 的数据 顺序表的插入:位置 i ...
  • 超详细讲解数据结构顺序表

    千次阅读 多人点赞 2022-03-14 19:32:42
    超详细讲解数据结构顺序表顺序表概念静态顺序表动态顺序表动态循序表的概念及构造动态顺序表接口的实现检查顺序表的容量尾插与尾删头插与头删 顺序表 概念 顺序表是用一段物理地址连续的存储单元依次存储数据元素...
  • 数据结构——顺序表(定义详解及创立顺序表并操作) 顺序表定义:顺序表是在计算机内存中以数组的形式保存的线性表,线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑...
  • Java数据结构——代码实现顺序表的操作

    万次阅读 多人点赞 2022-09-16 15:53:17
    一文速学顺序表的代码实现

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 661,089
精华内容 264,435
关键字:

数据结构顺序表的实现

数据结构 订阅
友情链接: Qt_labs.tar.gz