精华内容
下载资源
问答
  • 顺序表代码

    2017-12-26 13:09:14
    顺序表代码的文件 顺序表代码的文件 顺序表代码的文件 顺序表代码的文件顺序表代码的文件
  • C语言实现顺序表代码
  • 此为C++程序结构中的顺序表代码,掌握线性表的顺序存储结构;验证顺序表及其基本操作的实现;
  • 王道408顺序表代码1

    2021-04-09 21:40:35
    王道408顺序表代码1 自己学习课件里的代码,仅供学习使用 静态分配 #include<stdio.h> #define MaxSize 10 //默认最大长度 typedef struct { int data[MaxSize]; //用静态的数组存放数据 int length; //...

    王道408顺序表代码1

    自己学习课件里的代码,仅供学习使用

    静态分配

    #include<stdio.h>
    #define MaxSize 10        //默认最大长度
    
    typedef struct {
    	int data[MaxSize];   //用静态的数组存放数据
    	int length;          //顺序表的最大容量
    } SqList;                //顺序表的类型定义
    
    //基本操作——初始化一个顺序表
    void InitList(SqList &L) {
    	L.length=0; //顺序表初始长度为0
    	for(int i=0; i<MaxSize; i++) {
    		L.data[i]=0;     //将所有数据元素的初始值设置为默认值
    		L.length++;
    	}
    }
    
    int main() {
    	int i;
    	SqList L;            //声明一个顺序表
    	InitList(L);         //初始化顺序表
    	//尝试打印整个data数组
    	for(i=0; i<L.length; i++) {
    		printf("data[%d]=%d\n",i,L.data[i]);
    	}
    	return 0;
    }
    

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

    动态分配

    #include<stdio.h>
    #include<stdlib.h>
    #define InitSize 10        //默认最大长度
    
    typedef struct {
    	int *data;           //动态分配的指针
    	int MaxSize;        // 顺序表的最大容量
    	int length;          //顺序表的当前长度
    } SeqList;                //顺序表的类型定义
    
    
    void InitList(SeqList &L) {
    	//用malloc函数申请一片连续的储存空间
    	L.data=(int *)malloc(InitSize*sizeof(int));
    	L.length=0;            //初始化长度
    	L.MaxSize=InitSize;   //设定最大值
    }
    
    //增加动态数组的长度
    void IncreaseSize(SeqList&L, int len) {               //len为增加的数量
    	int *p=L.data;
    	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));//加上len需增加的字节数
    	for(int i=0; i<L.MaxSize; i++) {
    		L.data[i]=p[i];         //将数据复制到新区域
    	}
    	L.MaxSize=L.MaxSize+len;   // 顺序表最大长度增加
    	free(p);                   //释放原来的内存
    }
    
    int main() {
    	int i,k=0;
    	SeqList L;                   //声明一个顺序表
    	InitList(L);                 //初始化顺序表
    	//尝试打印整个data数组
    	for(i=0; i<L.MaxSize; i++) { //给顺序表赋值
    		L.data[i]=k;
    		k++;
    		printf("1.data[%d]=%d\n",i,L.data[i]);
    	}
    	IncreaseSize(L,5);           //增加长度函数 
    	for(i=0; i<L.MaxSize; i++) {
    		printf("2.data[%d]=%d\n",i,L.data[i]);
    	}
    	return 0;
    }
    

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

    展开全文
  • 顺序表代码和讲解

    2011-09-27 12:53:21
    顺序表代码和讲解,内容详细全面,通俗易懂,通过测试,代码可以直接使用,方便大家学习.
  • C语言顺序表代码

    2020-08-23 13:01:09
    顺序表是数据数据结构里链表的内容,同时也是学习数据结构和深入了解以及应用C语言指针的一个好的开头,顺序表顾名思义就是一个有顺序存储结构的表了,这个表在内存中是顺序存储的,如果数据比较短 ...

    顺序表就是顺序存储的一张连续表,表的长度和内容由程序员来决定。数据结构都是用到结构体指针的,作为数据结构里最为简单的顺序表,当然也是用结构体指针,开始写代码了,

    创建属于顺序表的seqlist.h文件

     

    #ifndef __seqlist__h
    #define __seqlist__h
    
    #define MAXSIZE 100   //顺序表长度
    typedef int data_t;	  //顺序表存储数据类型
    
    typedef struct {
    	data_t data[MAXSIZE];  /*顺序表个体数据空间大小*/
    	int last;		/*表元素个数*/ 
    }seqlist_t;
    
    #endif

    这里的顺序表的基本构造,大小由 MAXSIZE决定,存储的数据类型重定义为data_t是int类型,以后方便全部转换其他类型,主要的结构体就是很普通的两个参数。data数组负责存储数据,last 负责记录数据长度,下面继续完善代码,加入所需的函数

    #ifndef __seqlist__h
    #define __seqlist__h
    
    #define MAXSIZE 100   //顺序表长度
    typedef int data_t;	  //顺序表存储数据类型
    
    typedef struct {
    	data_t data[MAXSIZE];  /*顺序表个体数据空间大小*/
    	int last;		/*表元素个数*/ 
    }seqlist_t;
    
    seqlist_t *create_seqlist(void);  /*创建表函数*/
    void clear_seqlist(seqlist_t *L); /*清空表*/
    
    int is_empty_seqlist(seqlist_t *L); /*判断表是否为空*/
    int is_full_seqlist(seqlist_t *L); /*判断表是是否满*/
    void set_empty_seqlist(seqlist_t *L); /*设置表为空*/
    int get_length_seqlist(seqlist_t *L); /*返回表长度*/
    void  show_seqlist(seqlist_t *L); /*显示表有效内容*/
    
    int insert_seqlist(seqlist_t *L,data_t x); /*插入元素*/
    int delete_seqlist(seqlist_t *L,int pos); /*删除元素*/
    int change_seqlist(seqlist_t *L,data_t x,int pos); /*修改元素*/
    int search_seqlist(seqlist_t *L,data_t x); /*查找元素位置*/
    
    #endif
    

    以上就是我们.h文件所有内容了,接下来实现seqlist.c文件,记得头文件

    #include <stdio.h>   
    #include <stdlib.h>    
    #include "seqlist.h"
    
    seqlist_t *create_seqlist(void) /*创建表函数*/
    {
    	seqlist_t *L = NULL;   /*建立顺序表指针*/
    	L = (seqlist_t *)malloc(sizeof(seqlist_t)); /*分配空间*/
    	if(L == NULL) 		/*判断是否分配成功*/
    	{
    		puts("no memory");
    		return NULL;
    	}
    	else
    	{
    		puts("memory application");   //申请成功
    	}
    	
    	L->last = -1;  //表示还没有一个内容
    	return L;
    }
    
    void clear_seqlist(seqlist_t *L)  /*删除表*/
    {
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return;
    	}
    	free(L);   /*否则不为空释放内存空间*/
    	return;
    }
    
    int is_empty_seqlist(seqlist_t *L) /*判断表是否为空*/
    {	
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	return (L->last == -1);
    }
    int is_full_seqlist(seqlist_t *L) /*判断表是是否满*/
    {
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	return (L->last == MAXSIZE-1);
    }
    void set_empty_seqlist(seqlist_t *L) /*设置表为空*/
    {	
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return;
    	}
    	L->last = -1;
    	return;
    }
    int get_length_seqlist(seqlist_t *L) /*返回表长度*/
    {
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	return (L->last+1);
    }
    void show_seqlist(seqlist_t *L) /*显示表有效内容*/
    {
    	int i = 0;
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return ;
    	}
    	for(i=0;i<=L->last;i++)
    	{
    		printf("L-data[%d]= %d \n",i,L->data[i]);
    	}
    	return;
    }
    
    int insert_seqlist(seqlist_t *L,data_t x) /*添加元素*/
    {
    	//int i  = 0;
    	if((is_full_seqlist(L)))
    	{
    		puts("input argv is invalid");
    		return -1;
    	}
    /* 	for(i=L->last;i>=0;i--)   
    	{
    		L->data[i+1] = L->data[i];
    	} */
    	L->data[L->last+1] = x;
    	L->last++;
    	return 0;
    
    }
    int delete_seqlist(seqlist_t *L,int pos) /*删除元素*/
    {
    	int i = 0,y=0;
    	y = get_length_seqlist(L);
    	if((pos<0)||(pos>L->last))
    	{
    		puts("input pos is invaild");
    		return -1;
    	}
    	for(i = pos;i<y;i++)
    	{
    		L->data[i] = L->data[i+1];
    	}
    	L->last--;
    	return 0;
    }
    int change_seqlist(seqlist_t *L,data_t x,int pos) /*修改元素*/
    {
    	if((pos<0)||(pos>L->last))
    	{
    		puts("input pos is invaild");
    		return -1;	
    	}
    	L->data[pos] = x;
    	return 0;
    }
    int search_seqlist(seqlist_t *L,data_t x) /*查找元素位置*/
    {
    	int i = 0,y=0;
    	y = get_length_seqlist(L);
    	if(L == NULL)
    	{
    		puts("seqlist_t *L is NULL");
    		return -1;
    	}
    	printf("find %d ",x);
    	for(i=0;i<y;i++)
    	{
    		if(L->data[i]==x)
    		{
    			printf("the %d in L->data[%d]\n",x,i);
    			return 0;
    		}
    	}		
    	return -1;
    }
    
    
    

    在以上函数中,添加元素这个函数可以分为往后添加或者往前添加,取消注释就是往前添加,否者就是往后添加,

    下面市县main文件来对顺序表进行测试,

    #include <stdio.h>
    #include <stdlib.h>
    #include "seqlist.h"
    
    int main(int argc,const char *argv[])
    {
    	int i=0;
    	seqlist_t * L=NULL;
    
    	L=create_seqlist();  //创建顺序表
    
    	i = is_empty_seqlist(L);  //判断是否为空,是返回1 ,否返回0
    	printf("%d \r\n",i);
    	i = 0;
    
    	for(i=0;i<=4;i++)   	//添加元素
    	{
    	 insert_seqlist(L,i);
    	}
    
    	i = is_full_seqlist(L);  //判断是否满,是返回1 否返回0
    	printf("%d \r\n",i);
    
    	show_seqlist(L);     //显示所有元素
    	
    	delete_seqlist(L,1);    //删除索引为1 的元素
    	show_seqlist(L);		//显示所有元素
    	delete_seqlist(L,6);	//删除索引为6 的元素
    	show_seqlist(L);		//显示所有元素
    	
    	search_seqlist(L,4);   //查找4这个元素的索引值
    	change_seqlist(L,8,3);  //修改索引3 的元素为8
    	show_seqlist(L);		//显示所有元素
    	clear_seqlist(L);  	   //删除表
    	return 0;
    }

    测试结果和预期一致,至此,C语言顺序表建立完成,顺序表相比一维数组并无太大区别,但是顺序表便于管理和移植,

    这些都是鄙人经验所得,大神或者初学者有什么疑问或者指点的欢迎骚扰

    QQ:2278326006

    谢谢

    展开全文
  • 顺序表代码实现 /* 顺序表存储 */ #include&amp;amp;amp;lt;stdio.h&amp;amp;amp;gt; #include&amp;amp;amp;lt;stdlib.h&amp;amp;amp;gt; #define MaxSize 50 struct SeqList { int data[MaxSize]; ...

    顺序表代码实现

    /*
    	顺序表存储 
    */
    #include<stdio.h>
    #include<stdlib.h>
    #define  MaxSize 50
    struct SeqList
    {
    	int data[MaxSize];
    	int length;
    }list;
    //初始化 
    void init(struct SeqList *);
    
    //插入 
    void insert(struct SeqList *,int,int); 
    
    //删除 
    int delete(struct SeqList *,int);
    
    //查找
    int find(struct SeqList *,int); 
    
    //修改 
    void update(struct SeqList *,int,int); 
    
    //打印 
    void show(struct SeqList *);
    
    void main()
    {
    	struct SeqList *fp;
    	int x;
    	fp=&list;
    	init(fp);
    	insert(fp,1,1);
    	insert(fp,2,2);
    	insert(fp,3,3);
    	insert(fp,4,4);
    	insert(fp,5,5);
    	insert(fp,6,6);
    	insert(fp,7,7);
    	insert(fp,8,8);
    	insert(fp,9,9);
    	show(fp);
    	x = delete(fp,1);
    	printf("刪除的数为:%d\n",x);
    	show(fp);
    	x =find(fp,3);
    	printf("表第3个数为%d\n",x); 
    	update(fp,1,6);
    	show(fp);
    } 
    
    void init(struct SeqList *fp)
    {
    	fp->length = 0;
    }
    
    void insert(struct SeqList *fp,int i,int e)
    {
    	int k;
    	for(k=i;k<fp->length;k++)
    	{
    		fp->data[k] = fp->data[k-1];
    	}
    	fp->data[i-1] = e;
    	fp->length++;
    }
    
    int delete(struct SeqList *fp,int i)
    {
    	int k,x;
    	x = fp->data[i-1];
    	for(k=i;k<fp->length;k++)
    	{
    		fp->data[k-1] = fp->data[k];
    	}
    	fp->length--;
    	return x;
    }
    
    int find(struct SeqList *fp,int i)
    {
    	return fp->data[i-1];
    }
    
    void update(struct SeqList *fp,int i,int e)
    {
    	fp->data[i-1] = e;
    }
    
    void show(struct SeqList *fp)
    {
    	int i;
    	if(fp->length==0)
    	{
    		printf("空表!\n");
    	}else
    	{
    		printf("线性表:");
    		for(i=0;i<fp->length-1;i++)
    		{
    			printf("%d->",fp->data[i]);
    		} 
    		printf("%d",fp->data[i]);
    	}
    	printf("\n");
    }
    

    在这里插入图片描述

    展开全文
  • 自己写的王道考研数据结构顺序表例题和习题代码,所有函数运行都没问题。
  • 顺序表代码C++实现

    2020-10-09 20:00:05
    最近学习了《数据结构》这本书,但因为书上的都是些代码片段,各个函数在不同的页面上,让人看的很陌生,下面是顺序表的全部代码,语言是C++,我也搞不懂为啥书的封皮上说的是C语言版,但里面却是C++。下面的代码仅仅...

    C++实现顺序存储结构代码

    最近学习了《数据结构》这本书,但因为书上的都是些代码片段,各个函数在不同的页面上,让人看的很陌生,下面是顺序表的全部代码,语言是C++,我也搞不懂为啥书的封皮上说的是C语言版,但里面却是C++。下面的代码仅仅能够实现相关的功能,并没有简单的界面和用户操作。

    #include<iostream>
    #include<iomanip>
    
    using namespace std;
    /*
    	函数定义:
    	
    	* InitList(*L):初始化操作,建立一个空的线性表L。
    	* IsNull(L):判断链表是否存在
    	* ListEmpty(L):判断线性表是否为空表,若线性表为空,返回true,否则返回false。
    	* ClearList(*L):将线性表清空。
    	* GetElem(L,i,&e):将线性表L中的第i个位置元素值返回给e。
    	* LocationElem(L,e):在线性表中查找与给定值e相等的元素,如果查找成功,返回该元素在表中序号表示成功;否则,返回0表示失败。
    	* ListInsert(*L,i,e):在线性表L中第i个位置插入新元素e。
    	* ListDelete(*L, i *e):删除线性表L中第i个位置元素,并用e返回其值。
    	* ListLength(L):返回线性表L的元素个数。
    
    */
    
    typedef int ElemType;		//宏定义链表的data
    typedef int Status;			//宏定义函数的返回值
    //宏定义链表的最大个数
    #define MAXSIZE 100
    //宏定义返回值Status的类型,OK(1)表示执行成功,ERROR(0)表示执行失败或出错,用于主函数的判断
    #define OK 1	
    #define ERROR 0
    /*
    	注意因为这里用的data用的时int类型的,所以不用单独定义结构体类型的结构体
    */
    typedef struct{	//定于结构体类型的链表
    	ElemType* data;	//int类型的指针,用于操作数组
    	int length;	//链表的长度
    } List;
    
    /*
    	创建一个空链表
    		成功返回OK
    		失败返回ERROR
    */
    Status InitList(List *L) {
    	//在内存中申请一块空间,并返回这块空间的地址
    	L->data = new ElemType[MAXSIZE];
    	L->length = 0;
    	if (!L)	//判断链表现在是否为空
    	{
    		//链表申请失败
    		cout << "申请内存失败" << endl;
    		return ERROR;
    	}
    	else {
    		//链表申请成功
    		cout << "创建成功,可以向链表中添加数据了。" << endl;
    		return OK;
    	}
    }
    /*
    	判断链表是否存在
    		存在返回OK
    		不存在返回ERROR
    	并打印提示信息
    */
    Status IsNull(List L) {
    	List* p = &L;	//将传入的参数变量的地址复制给指针p
    	if (p) {
    		//链表不为空
    		return OK;
    	}
    	else {
    		//链表为空
    		cout << "链表为空,请先创建链表" << endl;
    		return ERROR;
    	}
    }
    /*
    	判断链表是否为空
    		为空返回ERROR
    		不为空返回OK
    */
    Status ListEmpty(List &L) {
    	if (IsNull(L))
    	{
    		//返回OK说明链表存在
    		//对链表进行判断
    		if (L.length == 0)
    		{
    			//为空
    			return ERROR;
    		}
    		else {
    			//不为空
    			return OK;
    		}
    	}
    	else {
    		//返回ERROR说明链表不存在,判断链表是否为空就没必要了,直接返回
    		return ERROR;
    	}
    }
    /*
    	清空顺序表中数据(前提:链表L确定存在)
    		清理成功返回OK
    		清理不失败返回ERROR
    */
    void ClearList(List &L) {
    	//清空就是将顺序表中现有的数据进行清零
    	int i;
    	for(i =0;i<L.length; i++){
    		L.data[i] = 0;
    	}
    }
    /*
    	向顺序表中添加部分数据用于测试
    */
    void AddDatas(List &L) {
    	for (int i = 0; i < 10; i++)
    	{
    		L.data[i] = i+1;
    		L.length++;
    	}
    	
    }
    /*
    	遍历链表(仅用于测试)
    */
    void ShowDatas(List &L) {
    	for (int i = 0; i <L.length ; i++)
    	{
    		cout << L.data[i] << endl;
    	}
    }
    
    //GetElem(L,i,*e):将线性表L中的第i个位置元素值返回给e。
    
    void GetElem(List L,int i,ElemType &e){
    	if(i>L.length){
    		cout<<"您输入的位置有误"<<endl;
    		return;
    	}
    	e = L.data[i-1];
    }
     //LocationElem(L,e):在线性表中查找与给定值e相等的元素,如果查找成功,返回该元素在表中序号表示成功;否则,返回0表示失败。
    int LocationElem(List L,ElemType e){
    	int i = 0;
    	for(i =0 ;i<L.length;i++){
    		if(L.data[i] == e){
    			return ++i;
    		}
    	}
    	return 0;
    }
    //ListInsert(*L, i, e):在线性表L中第i个位置插入新元素e。
    Status ListInsert(List& L, int i, ElemType e) {
    	//判断用户输入的位置是否错误
    	if (i>L.length+1 && i<1)
    	{
    		cout << "您输入的位置有误" << endl;
    		return ERROR;
    	}
    	//判断插入的位置是否在顺序表的末尾
    	if (i <= L.length) {
    		int j;
    		for (j = L.length; j >= i; j--) {
    			//将要插入元素的后面的元素全部向后移
    			L.data[j] = L.data[j-1];
    		}
    	}
    	//无论插入前面或者末尾,都执行
    	L.data[i - 1] = e;
    	L.length++;
    	return OK;
    }
    
    // ListDelete(*L, i *e):删除线性表L中第i个位置元素,并用e返回其值。
    Status ListDelete(List& L, int i, ElemType& e) {
    	//判断用户输入的位置是否有误
    	if (i>=L.length && i<1) {
    		cout << "您输入的有误" << endl;
    		return ERROR;
    	}
    	//判断删除的位置是否在顺序表的末尾
    	if (i<=L.length) {
    		//将删除元素的位置后面的所有元素往前移一位
    		e = L.data[i - 1];
    		int j;
    		for (j = i - 1; j < L.length - 1; j++) {
    			//将后一位元素的值赋值给前一个元素,达到覆盖的效果
    			L.data[j] = L.data[j + 1];
    		}
    	}
    	//无论删除哪一个,都要执行的语句
    	L.length--;
    	return OK;
    }
    
    // ListLength(L):返回线性表L的元素个数。
    int ListLength(List L) {
    	return L.length;
    }
    /*
    	主函数:用于调用各个函数,通过函数功能的拼接实现需求
    			并且用于测试
    */
    int main() {
    
    	List list;	//声明一个链表变量
    	system("color 02");
    	//判断list变量的类型和字节
    	//int size = sizeof(list);
    	//cout << size << endl;
    	if (InitList(&list))
    	{
    		//判断链表是否为空
    		if (!ListEmpty(list))
    		{
    			AddDatas(list);
    			List* p = &list;
    			//ShowDatas(list);
    		/*	//调用清空函数
    			ClearList(list);
    			//展示链表清空后的数据
    			ShowDatas(list);
    			*/
    			//返回顺序表中的第5个元素
    			ElemType e;
    			GetElem(list,5,e);
    			//cout<<e<<endl;
    			//调用LocationElem()函数
    			int a;
    			a = LocationElem(list,2);
    			if(a){
    				//cout<<a<<endl;
    				ListDelete(list,1,a);
    				cout << "删除的元素为:" << a << endl;
    				ShowDatas(list);
    				cout << "链表的个数为:" << ListLength(list) << endl;
    			}
    			else{
    				cout<<"未找到"<<endl;
    			}
    			cout << "测试成功" << endl;
    		}
    	}
    	else {
    		cout << "测试失败" << endl;
    	}
    	return 0;
    }
    
    展开全文
  • /*构造一张新的顺序表*/ int ListLength_Sq(List l); /*求顺序表L的长度*/ void GetElem_Sq(List *L,int i,ElemType e); /*获取顺序表L的第i个元素*/ int EqualList(ElemType e1,ElemType e2); /*判断数据元素e1,e2...
  • C++ 顺序表 代码实现

    2018-11-21 17:38:00
    线性表存储在计算机中可以采用多种方式,以下是按照顺序存储方式实现: 优点:查找很方便 缺点:插入元素、删除元素比较麻烦,时间复杂度 O(n) 1 #ifndef SeqList_h 2 #define SeqList_h 3 #include <...
  • 情况说明: 这是对于本科数据结构重新学习,代码参考本科所学的严蔚敏的数据结构和github...顺序表初始化: //主要代码 //使用结构体对顺序表进行表示 typedef struct { int * elem;//这是指向这个结构体的指针
  • 顺序表初始化 在顺序表中插入数据 删除顺序表中的数据 合并两个升序顺序表 #include <stdio.h> #include <iostream> #define MAXLENGTH 50 #define ElemType int typedef struct { ...
  • Java顺序表代码的实现

    2020-04-02 16:18:01
    } public void display(){ //打印顺序表 for (int i=0; ithis.useSide){ throw new ArrayIndexOutOfBoundsException("pos位置不合法"); } } public void add(int pos, int data){ //在pos位置插入一个新的数据data ...
  • 线性表之顺序表代码

    2016-12-02 16:45:24
    //求顺序表的长度 int isempty(SeqList *list); //判断是否为空,0为假,1为真. void clear(SeqList *list); //清空顺序表 void resver(SeqList *list); //转置顺序表 void show_list(SeqList *...
  • "原顺序表:\n" ) ; displayTable ( t1 ) ; printf ( "删除元素1:\n" ) ; t1 = delTable ( t1 , 1 ) ; displayTable ( t1 ) ; printf ( "在第2的位置插入元素5:\n" ) ; t1 = addTable ( t1 , ...
  • 数据结构上机考试练习代码,置于此以备后用!...//定义顺序表存放的数据类型 typedef int DataType; //定义顺序表的结构 typedef struct{ //用于存放元素的数组 DataType data[ListSize]; ...
  • 输入:顺序表指针,插入位,插入值 输出:状态码 功能:插入数据 **************************/ Status insertList(Sqlist *L, int index,ElemType e){ index --; // 输入index起始为1,而程序起始为0,下面亦...
  • 代码片段如下: <pre name="code" class="cpp">#include using namespace std; #include"SeqList.h" void main() { int r[10]={0,0,0,0,0,0,0,0,0,0}; int N,a,n,m,o; cout请问您想输入多少个学生的成绩?...
  • int Size() const{ return maxSize; } int Length()const{ return last+1; }
  • 顺序表代码

    2011-10-25 17:52:46
    顺序表代码分位h文件和c文件分别c文件用于实现
  • 顺序表代码的实现,其本质就是一个数组和最大容量(也就是数组的长度)以及现有的长度。当我们每存储进一个数据的时候,他的现有长度增加,当增加到最大的容量的时候,我们就需要给顺序表扩容。 我们很难把顺序表的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 12,087
精华内容 4,834
关键字:

顺序表代码