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

    2017-12-22 09:43:15
    顺序表操作基本代码。帮助顺序表的学习和代码的编写等。
  • 数据结构-顺序表基本操作的实现(含全部代码

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天起开始编写数据结构中的各种数据结构及其算法的实现。 主要依据严蔚敏版数据结构教材以及王道数据结构...L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n) InitList(SqList &...

    今天起开始编写数据结构中的各种数据结构及其算法的实现。

    主要依据严蔚敏版数据结构教材以及王道数据结构考研辅导书。

    今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。

    • CreateList(SqList &L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n)
    • InitList(SqList &L) 参数:顺序表L 功能:初始化 时间复杂度:O(1)
    • InsertList(SqList &L,int i,ElemType e) 参数:顺序表L,位置i,元素e 功能:位置i处插入元素e 时间复杂度:O(n)
    • ListDelete(SqList &L,int i) 参数:顺序表L,位置i 功能:删除位置i处元素 时间复杂度:O(n)
    • LocateElem(SqList L,ElemType e) 参数:顺序表L,元素e 功能:返回第一个等于e的元素的位置 时间复杂度:O(n)
    • Reverse(SqList &L) 参数:顺序表L 倒置函数 将原顺序表直接倒置
    • PrintList(SqList L) 参数:顺序表L 功能:遍历L,并输出
    • SplitSort(SqList &L) 参数:顺序表L 功能:分开奇偶,并分开排序
    • ClearList(SqList &L) 参数:顺序表L 功能:清空顺序表

    代码如下:

    /*
    Project: sequence_list(数据结构-顺序表)
    Date:    2018/09/12  20191012修改 添加Reverse  20200819修改 添加ClearList
    Author:  Frank Yu
    CreateList(SqList &L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n)
    InitList(SqList &L) 参数:顺序表L 功能:初始化 时间复杂度:O(1)
    InsertList(SqList &L,int i,ElemType e) 参数:顺序表L,位置i,元素e 功能:位置i处插入元素e 时间复杂度:O(n)
    ListDelete(SqList &L,int i) 参数:顺序表L,位置i 功能:删除位置i处元素 时间复杂度:O(n)
    LocateElem(SqList L,ElemType e) 参数:顺序表L,元素e 功能:返回第一个等于e的元素的位置 时间复杂度:O(n)
    Reverse(SqList &L) 参数:顺序表L 倒置函数 将原顺序表直接倒置
    PrintList(SqList L) 参数:顺序表L 功能:遍历L,并输出
    SplitSort(SqList &L) 参数:顺序表L 功能:分开奇偶,并分开排序
    ClearList(SqList &L) 参数:顺序表L 功能:清空顺序表
    */
    #include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cmath>
    #include<algorithm>
    #include<iostream>
    #define MaxSize 100
    #define ElemType int
    #define Status int
    using namespace std;
    //顺序表数据结构
    typedef struct
    {
    	ElemType data[MaxSize];//顺序表元素
    	int length;            //顺序表当前长度
    }SqList;
    //***************************基本操作函数*******************************//
    //初始化顺序表函数,构造一个空的顺序表 
    Status InitList(SqList &L)
    {
    	memset(L.data, 0, sizeof(L));//初始化数据为0
    	L.length = 0;                //初始化长度为0
    	return 0;
    }
    //创建顺序表函数 初始化前n个数据
    bool CreateList(SqList &L, int n)
    {
    	if (n<0 || n>MaxSize)false;//n非法
    	for (int i = 0; i<n; i++)
    	{
    		scanf("%d", &L.data[i]);
    		L.length++;
    	}
    	return true;
    }
    //插入函数 位置i插入数据 i及之后元素后移  1=<i<=length+1 
    bool InsertList(SqList &L, int i, ElemType e)
    {
    	if (i<1 || i>L.length + 1) //判断位置是否有效
    	{
    		printf("位置无效!!!\n");
    		return false;
    	}
    	if (L.length >= MaxSize)//判断存储空间是否已满
    	{
    		printf("当前存储空间已满!!!\n");
    		return false;
    	}
    	for (int j = L.length; j >= i; j--)//位置i及之后元素后移
    	{
    		L.data[j] = L.data[j - 1];
    	}
    	L.data[i - 1] = e;
    	L.length++;
    	return true;
    }
    //删除函数 删除位置i的元素 i之后的元素依次前移
    bool  ListDelete(SqList &L, int i)
    {
    	if (i<1 || i>L.length)
    	{
    		printf("位置无效!!!\n");
    		return false;
    	}
    	for (int j = i; j <= L.length - 1; j++)//位置i之后元素依次前移覆盖
    	{
    		L.data[j - 1] = L.data[j];
    	}
    	L.length--;
    	return true;
    }
    //查找函数 按位置从小到大查找第一个值等于e的元素 并返回位置
    int LocateElem(SqList L, ElemType e)
    {
    	for (int i = 0; i<L.length; i++)//从低位置查找
    	{
    		if (L.data[i] == e)
    			return i + 1;
    	}
    	return 0;
    }
    //倒置函数 将原顺序表直接倒置
    void Reverse(SqList &L)
    {
    	if (L.length)
    		for (int i = 0; i<L.length - 1 - i; i++)
    		{
    			int t = L.data[i];
    			L.data[i] = L.data[L.length - 1 - i];
    			L.data[L.length - 1 - i] = t;
    		}
    }
    //奇偶分开并排序
    void SplitSort(SqList &L)
    {
    	int Even = 0;
    	int Odd = L.length - 1;
    	int i = 0;
    	int j = L.length - 1;
    	bool flag = false;
    	if (L.length)
    		for (; i < j; i++, j--)
    		{
    			while (L.data[i] % 2 != 0)i++;
    			while (L.data[j] % 2 == 0)j--;
    			if (L.data[i] % 2 == 0 && L.data[j] % 2 != 0&&i<j)
    			{
    				int temp = L.data[i];
    				L.data[i] = L.data[j];
    				L.data[j] = temp;
    				flag = true;
    			}
    			if(!flag) //没有交换
    			{
    				Even = L.length - 1;//全奇数
    				Odd = 0; //全偶数
    			}
    		}
    	if (flag)
    	{
    		for(int i=0;i<L.length;i++)
    			if (L.data[i] % 2 == 0) 
    			{
    				Odd = i;
    				Even = i - 1;
    				break;
    			}
    	}
    	sort(L.data, L.data + Even + 1);
    	sort(L.data + Odd, L.data + L.length);
    }
    //清空顺序表
    void ClearList(SqList &L) {
    	L.length = 0;
    }
    //********************************功能函数*****************************************//
    //输出功能函数 按位置从小到大输出顺序表所有元素
    void PrintList(SqList L)
    {
    	printf("当前顺序表所有元素:");
    	for (int i = 0; i<L.length; i++)
    	{
    		printf("%d ", L.data[i]);
    	}
    	printf("\n");
    }
    //创建顺序表函数
    void Create(SqList &L)
    {
    	int n; bool flag;
    	L.length = 0;
    	printf("请输入要创建的顺序表长度(>1):");
    	scanf("%d", &n);
    	printf("请输入%d个数(空格隔开):", n);
    	flag = CreateList(L, n);
    	if (flag) {
    		printf("创建成功!\n");
    		PrintList(L);
    	}
    	else printf("输入长度非法!\n");
    
    }
    //插入功能函数 调用InsertList完成顺序表元素插入 调用PrintList函数显示插入成功后的结果
    void Insert(SqList &L)
    {
    	int place; ElemType e; bool flag;
    	printf("请输入要插入的位置(从1开始)及元素:\n");
    	scanf("%d%d", &place, &e);
    	flag = InsertList(L, place, e);
    	if (flag)
    	{
    		printf("插入成功!!!\n");
    		PrintList(L);
    	}
    }
    //删除功能函数 调用ListDelete函数完成顺序表的删除 调用PrintList函数显示插入成功后的结果
    void Delete(SqList &L)
    {
    	int place; bool flag;
    	printf("请输入要删除的位置(从1开始):\n");
    	scanf("%d", &place);
    	flag = ListDelete(L, place);
    	if (flag)
    	{
    		printf("删除成功!!!\n");
    		PrintList(L);
    	}
    }
    //查找功能函数 调用LocateElem查找元素
    void Search(SqList L)
    {
    	ElemType e; int flag;
    	printf("请输入要查找的值:\n");
    	scanf("%d", &e);
    	flag = LocateElem(L, e);
    	if (flag)
    	{
    		printf("该元素位置为:%d\n", flag);
    	}
    	else
    		printf("未找到该元素!\n");
    }
    //菜单
    void menu()
    {
    	printf("********1.创建                        2.插入*********\n");
    	printf("********3.删除                        4.查找*********\n");
    	printf("********5.倒置                        6.分奇偶排序***\n");
    	printf("********7.输出                        8.清空*********\n");
    	printf("********9.退出                              *********\n");
    }
    int main()
    {
    	SqList L; int choice;
    	InitList(L);
    	while (1)
    	{
    		menu();
    		printf("请输入菜单序号:\n");
    		scanf("%d", &choice);
    		if (9 == choice) break;
    		switch (choice)
    		{
    		case 1:Create(L); break;
    		case 2:Insert(L); break;
    		case 3:Delete(L); break;
    		case 4:Search(L); break;
    		case 5:Reverse(L); break;
    		case 6:SplitSort(L); break;
    		case 7:PrintList(L); break;
    		case 8:ClearList(L); break;
    		default:printf("输入错误!!!\n");
    		}
    	}
    	return 0;
    }

    结果截图:

    插入结果截图
    删除结果截图
    查找结果截图
    输出结果截图

    ---------------------------------------------2018-09-18更新 添加创建函数 菜单有改动-----------------------------------------

                                                                     

     

    ---------------------------------------------20191012更新 添加Reverse函数--------------------------------------------

    根据下方评论,添加了倒置函数,参考stl的Reverse写法

    template <class _RandomAccessIter>
    _STLP_INLINE_LOOP void
    __reverse(_RandomAccessIter __first, _RandomAccessIter __last, const random_access_iterator_tag &) {
      for (; __first < __last; ++__first)
        _STLP_STD::iter_swap(__first, --__last);
    }
    倒置展示

    2019年10月23日更新,应评论区小伙伴的要求,添加了奇偶分开,并排序的函数

    //奇偶分开并排序
    void SplitSort(SqList &L)
    {
    	int Even = 0;
    	int Odd = L.length - 1;
    	int i = 0;
    	int j = L.length - 1;
    	bool flag = false;
    	if (L.length)
    		for (; i < j; i++, j--)
    		{
    			while (L.data[i] % 2 != 0)i++;
    			while (L.data[j] % 2 == 0)j--;
    			if (L.data[i] % 2 == 0 && L.data[j] % 2 != 0&&i<j)
    			{
    				int temp = L.data[i];
    				L.data[i] = L.data[j];
    				L.data[j] = temp;
    				flag = true;
    			}
    			if(!flag) //没有交换
    			{
    				Even = L.length - 1;//全奇数
    				Odd = 0; //全偶数
    			}
    		}
    	if (flag)
    	{
    		for(int i=0;i<L.length;i++)
    			if (L.data[i] % 2 == 0) 
    			{
    				Odd = i;
    				Even = i - 1;
    				break;
    			}
    	}
    	sort(L.data, L.data + Even + 1);
    	sort(L.data + Odd, L.data + L.length);
    }
    测试全奇偶

     

    有奇偶

    代码已更新至上方全部代码!!!

    -------------------------20200819修改 添加ClearList-------------------------------------

    代码由评论区用户__BlackHole提供,已更新至上方全部代码。

    至于销毁,我是使用的静态分配,如果是new(delete释放)或malloc(free释放)的话,需要释放空间,其实就是堆和栈的区别。

    堆和栈的区别就是申请方式不同:栈是系统自动分配空间,而堆则是程序员根据需要申请空间。由于栈上的空间是自动分配自动回收的,所以,栈内数据的生存周期只是在函数的运行过程中,运行后就释放掉。而堆上的数据只要程序员不释放空间,就一直可以访问到,缺点是一旦忘记释放会造成内存泄露。

    综上,我写的顺序表不需要进行销毁,当然,顺序表最大长度也固定了,各有利弊,如果是动态分配的话记得释放空间呀!

    更多数据结构与算法的实现:数据结构(严蔚敏版)与算法的实现(含全部代码)

    本人b站账号:lady_killer9

    有问题请下方评论,转载请注明出处,并附有原文链接,谢谢!如有侵权,请及时联系。如果您感觉有所收获,自愿打赏,可选择支付宝18833895206(小于),您的支持是我不断更新的动力。

    展开全文
  • 顺序表基本操作代码实现 初始化 静态分配方式 #include <stdio.h> #define MaxSize 10 //定义最大长度 typedef struct{ int data[MaxSize]; //存放数据元素 int length; //当前长度 }SqList; //顺序表...

    顺序表基本操作的代码实现

    初始化

    静态分配方式
    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    /**
    * 初始化函数 
    *
    * @param L 顺序表指针 
    */
    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++)
    		printf("%d ", L.data[i]);
    	
    	printf("length=%d", L.length);
    	
    	return 0;
    }
    

    输出

    0 0 0 0 0 0 0 0 0 0 length=0
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    
    动态分配方式
    #include <stdio.h>
    #include <stdlib.h>
    #define InitSize 10 //默认最大长度
    
    typedef struct{
    	int *data;	//指示动态分配数组的指针 
    	int MaxSize; //最大容量 
    	int length; //顺序表的当前长度 
    }SeqList; 
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针 
    */
    void InitList(SeqList &L){
    	//用 malloc 函数申请一片连续的存储空间 
    	L.data=(int *)malloc(InitSize*sizeof(int));
    	L.length=0;
    	L.MaxSize=InitSize;
    	
    	for(int i=0; i<InitSize; i++)
    		L.data[i]=0; //初始化为0 
    }
    
    /**
    * 动态增加数组长度 
    *
    * @param L 顺序表指针 
    * @param len 增加的长度
    */
    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; //扩大长度 
    	free(p); //释放原来的内存空间 
    } 
    
    int main(){
    	SeqList L;
    	InitList(L);
    	
    	for(int i=0; i<L.MaxSize; i++)
    		printf("%d ", L.data[i]);
    	printf("\n原来size=%d", L.MaxSize);
    	
    	IncreaseSize(L, 5);
    	printf("\n当前size=%d\n", L.MaxSize);
    	
    	return 0;
    }
    
    

    输出

    0 0 0 0 0 0 0 0 0 0
    原来size=10
    当前size=15
    
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    

    插入

    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素后移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素后移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	return 0;
    }
    
    

    效果:

    2 3 0 0 0 0 0 0 0 0
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    

    删除

    /**
    * 删除
    *
    * @param L 顺序表指针
    * @param i 输出的位置,即位序i 
    * @param e 删除的值 
    * @return 是否插入成功 
    */
    bool ListDelete(SqList &L, int i, int &e){
    	if(i<1 || i>L.length)
    		return false;
    		
    	e=L.data[i-1]; //将被删除的元素赋值给e 
    	
    	for(int j=i; j<L.length; j++) //将第i个位置后的元素前移 
    		L.data[j-1]=L.data[j];
    	L.length--;  //线性表长度减1 
    	
    	return true;
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素前移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    /**
    * 删除
    *
    * @param L 顺序表指针
    * @param i 输出的位置,即位序i 
    * @param e 删除的值 
    * @return 是否插入成功 
    */
    bool ListDelete(SqList &L, int i, int &e){
    	if(i<1 || i>L.length)
    		return false;
    		
    	e=L.data[i-1]; //将被删除的元素赋值给e 
    	
    	for(int j=i; j<L.length; j++) //将第i个位置后的元素前移 
    		L.data[j-1]=L.data[j];
    	L.length--;  //线性表长度减1 
    	
    	return true;
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	int e=-1;
    	ListDelete(L, 1, e);
    	printf("\nres=%d\n", e);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    	
    	return 0;
    }
    
    

    效果

    2 3 0 0 0 0 0 0 0 0
    res=2
    3 3 0 0 0 0 0 0 0 0
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    

    查找

    按位查找
    /**
    * 按位查找
    *
    * @param L 顺序表指针
    * @param i 位序i  
    * @return 该位置的值
    */
    int GetElem(SqList L, int i){
    	return L.data[i-1];
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素前移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    /**
    * 按位查找
    *
    * @param L 顺序表指针
    * @param i 位序i 
    * @return 该位置的值
    */
    int GetElem(SqList L, int i){
    	return L.data[i-1];
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    
    	printf("\n第一个值为:%d", GetElem(L, 1)); 
    	
    	return 0;
    }
    
    

    效果

    2 3 0 0 0 0 0 0 0 0
    第一个值为:2
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    
    按值查找
    /**
    * 按值查找
    *
    * @param L 顺序表指针
    * @param e 获取的值 
    * @return 该值的位序 
    */
    int LocateElem(SqList L, int e){
    	for(int i=0; i<L.length; i++)
    		if(L.data[i]==e)
    			return i+1;	//数组下标为i的元素值等于e,返回其位序i+1 
    	
    	return 0; //退出循环,说明查找失败 
    }
    
    操作小记

    代码

    #include <stdio.h>
    #define MaxSize 10 	//定义最大长度
    
    typedef struct{
    	int data[MaxSize];	//存放数据元素 
    	int length;	//当前长度 
    }SqList;	//顺序表的类型定义 
    
    
    
    /**
    * 初始化 
    *
    * @param L 顺序表指针
    */
    void InitList(SqList &L){
    	for(int i=0; i<MaxSize; i++)
    		L.data[i]=0; //初始化为0 
    	L.length=0; //初始长度为0 
    }
    
    /**
    * 插入
    *
    * @param L 顺序表指针
    * @param i 插入的位置,即位序i 
    * @param e 插入值 
    * @return 是否插入成功 
    */
    bool ListInsert(SqList &L, int i, int e){
    	if(i<1 || i>L.length+1)
    		return false;
    	if(L.length>=MaxSize)
    		return false;
    	
    	for(int j=L.length; j>=i; j--)//将第i个元素及之后的元素前移 
    		L.data[j]=L.data[j-1];
    	L.data[i-1]=e; //在位置i处放入e 
    	L.length++; //长度加1 
    	return true;
    }
    
    /**
    * 按值查找
    *
    * @param L 顺序表指针
    * @param e 获取的值 
    * @return 该值的位序 
    */
    int LocateElem(SqList L, int e){
    	for(int i=0; i<L.length; i++)
    		if(L.data[i]==e)
    			return i+1;	//数组下标为i的元素值等于e,返回其位序i+1 
    	
    	return 0; //退出循环,说明查找失败 
    }
    
    int main(){
    	SqList L;
    	InitList(L);
    	
    	ListInsert(L, 1, 3);
    	ListInsert(L, 1, 2);
    	
    	for(int i=0; i<MaxSize; i++)
    		printf("%d ", L.data[i]);
    
    	printf("\n元素值为3的位序:%d", LocateElem(L, 3)); 
    	
    	return 0;
    }
    
    

    效果

    2 3 0 0 0 0 0 0 0 0
    元素值为3的位序:2
    --------------------------------
    Process exited with return value 0
    Press any key to continue . . .
    
    
    展开全文
  • 顺序表基本操作代码实现

    顺序表基本操作的代码实现:C++实现

    #include<iostream>
    
    using namespace std;
    
    int maxSize = 100;
    
    // 定义
    template <class T>
    class SqListClass
    {
        private:
            T *data; // 存放顺序表中的元素
            int length; // 存放顺序表的长度
    
        public:
            SqListClass(); // 构造函数
            ~SqListClass(); // 析构函数
            void CreateList(T a[], int n); // 由a数组中的元素建造顺序表
            void DispList(); // 输出顺序表L中的所有元素
            int ListLength(); // 求顺序表的长度
            bool GetElem(int i, T &e); // 求顺序表中某序列号的元素值
            int LocateElem(T e); // 按元素查找其第一个序号位置
            bool ListInsert(int i, T e); // 在位置i插入数据元素e
            bool ListDelete(int i); // 在位置i删除数据元素
            void ReverseList(SqListClass<T> &L); // 翻转顺序表
    };
    
    // 线性表的初始化
    template<class T>
    SqListClass<T>::SqListClass() // 构造函数
    {
        data = new T[maxSize];
        length = 0;
    }
    
    // 线性表的销毁
    template<class T>
    SqListClass<T>::~SqListClass() // 析构函数
    {
        delete [] data;
    }
    
    // 实现
    
    // 线性表的创建,时间复杂度为O(n)
    template<class T>
    void SqListClass<T>::CreateList(T a[], int n)
    {
        int i;
        for(i=0; i<n; i++){
            data[i] = a[i];
        }
        length = i;
    }
    
    // 输出线性表的所有元素,时间复杂度为O(n)
    template<class T>
    void SqListClass<T>::DispList(){
        cout << "Out:" << endl;
        for(int i=0; i<length; i++){
            cout << data[i] << " ";
        }
        cout << endl;
    }
    
    // 求线性表的长度,时间复杂度为O(1)
    template<class T>
    int SqListClass<T>::ListLength(){
        return length;
    }
    
    // 求顺序表中某序列号的元素值,,时间复杂度为O(1)
    template<class T>
    bool SqListClass<T>::GetElem(int i, T &e){
        if(i<0 || i>length) return false;
        e = data[i-1];
        return true;
    }
    
    // 按元素查找其第一个序号位置,时间复杂度为O(n)
    template<class T>
    int SqListClass<T>::LocateElem(T e){
        int i = 0;
        while(i<length && data[i]!=e) i++;
        if(i>=length) return 0;
        else return i+1;
    }
    
    // 在位置i插入数据元素e,时间复杂度为O(n)
    template<class T>
    bool SqListClass<T>::ListInsert(int i, T e){
        if(i<0 || i>length) return false;
        for(int j=length; j>=i; j--){
            data[j]=data[j-1];
        }
        data[i-1] = e;
        length++;
        return true;
    }
    
    // 在位置i删除数据元素,时间复杂度为O(n)
    template<class T>
    bool SqListClass<T>::ListDelete(int i){
        if(i<0 || i>length) return false;
        for(int j=i-1; j< length; j++){
            data[j] = data[j+1];
        }
        length--;
        return true;
    }
    
    // 翻转顺序表
    template<class T>
    void SqListClass<T>::ReverseList(SqListClass<T> &L){
        T temp;
        for(int j=0; j<L.length/2; j++){
            temp = L.data[j];
            L.data[j] = L.data[length-j-1];
            L.data[length-j-1] = temp;
        }
    }
    
    // 主函数
    int main(){
        SqListClass<int> sqList;
        int arr[3] = {3,4,5};
        // 创建线性表
        sqList.CreateList(arr, 3);
        // 输出线性表
        sqList.DispList();
        // 输出线性表的长度
        cout << "sqList length is " << sqList.ListLength() << endl;
        // 求第二个位置的元素
        int a;
        sqList.GetElem(2, a);
        cout <<"The 2 local is elem " << a << endl;
        // 查找元素5的位置
        cout << "The elem 5 local is " << sqList.LocateElem(5) << endl;
        // 在位置4插入元素6
        sqList.ListInsert(2, 6);
        sqList.DispList();
        // 在位置1删除数据元素
        sqList.ListDelete(1);
        sqList.DispList();
        // 翻转顺序表
        sqList.ReverseList(sqList);
        sqList.DispList();
        return 0;
    }
    
    展开全文
  • 顺序的基本操作代码实现(初始化、插入、删除、销毁等等) 1.标头.h #pragma once #include<stdio.h> #include<stdlib.h> /* @author:W.yu @Data:2020-04-27 */ #define INITSIZE 10 //定义顺序表的...

    顺序的基本操作代码实现(初始化、插入、删除、销毁等等)


    1.标头.h

    #pragma once
    #include<stdio.h>
    #include<stdlib.h>
    /*
     @author:W.yu
     @Data:2020-04-27
    */
    
    #define INITSIZE 10  //定义顺序表的初始最大长度
    
    typedef struct {
    	int* data;  //顺序表的数据元素
    	int MaxSize;  //顺序表的最大容量
    	int length;  //顺序表的当前长度
    }SqList;
    
    //初始化顺序表L
    void InitList(SqList& L);  
    //给顺序表L增加len个长度容量
    void IncreaseList(SqList& L, int len);
    //求表长,返回顺序表L的长度
    int Length(SqList L);
    //安值查找。在表L中查找具有e的元素,返回元素位置
    int LocateElem(SqList L, int e);
    //按位查找。获取L中第i个位置的元素
    void GetElem(SqList L, int i);
    //插入操作。在L中的第i个位置插入元素e
    bool InsertList(SqList& L, int i, int e);
    //删除操作。删除L中的第i个位置的元素,并用e返回删除的元素
    bool DeleteList(SqList& L, int i, int& e);
    //输出操作。按前后顺序输出L的所有元素值
    void PrintList(SqList L);
    //销毁操作。销毁L,并释放空间
    void DestroyList(SqList& L);
    

    2.源.cpp

    #include "标头.h"
    /*
     @author:W.yu
     @Data:2020-04-28 17:07
    */
    
    int main() {
    	SqList L;
    	InitList(L);
    	printf("初始化线性表表长为:%d\n", Length(L));
    	PrintList(L);
    
    	InsertList(L, 1, 1);
    	InsertList(L, 2, 2);
    	InsertList(L, 3, 3);
    	InsertList(L, 4, 4);
    	InsertList(L, 5, 5);
    	InsertList(L, 6, 6);
    	InsertList(L, 7, 7);
    	InsertList(L, 8, 8);
    	printf("线性表表长为:%d\n", Length(L));
    	PrintList(L);
    
    	int e = -1;
    	DeleteList(L, 3, e);
    	printf("线性表表长为:%d\n", Length(L));
    	PrintList(L);
    
    	DestroyList(L);
    
    	getchar();
    	return 0;
    }
    
    void InitList(SqList& L) {
    	L.data = (int*)malloc(sizeof(int) * INITSIZE);
    	L.MaxSize = INITSIZE;
    	L.length = 0;
    }
    
    void IncreaseList(SqList& L, int len) {
    	int* temp = L.data;
    	L.data = (int*)malloc(sizeof(int) * (INITSIZE + len));
    	for (int i = 0; i < L.length; i++) {
    		L.data[i] = temp[i];
    	}
    	L.MaxSize = L.MaxSize + len;
    
    	free(temp);
    }
    
    int Length(SqList L)
    {
    
    	return L.length;
    }
    
    int LocateElem(SqList L, int e)
    {
    	for (int i = 0; i < L.length; i++) {
    		if (e == L.data[i])
    			return i+1;
    	}
    	return 0;
    }
    
    void GetElem(SqList L, int i)
    {
    	printf("%d 个位置的元素为:%d\n", i, L.data[i - 1]);
    }
    
    bool InsertList(SqList& L, int i, int e)
    {
    	if (i<1 || i>L.length+1)
    		return false;
    	if (L.length + 1 > L.MaxSize)
    		return false;
    	for (int j = L.length; j >= i; j--)
    		L.data[j] = L.data[j - 1];
    	L.data[i - 1] = e;
    	L.length++;
    	printf("第%d个位置插入元素:%d成功!\n", i, e);
    	return true;
    }
    
    bool DeleteList(SqList& L, int i, int& e)
    {
    	if (i<1 || i>L.length)
    		return false;
    	e = L.data[i - 1];
    	for (int j = i; j < L.length; j++)
    		L.data[j - 1] = L.data[j];
    	L.length--;
    	printf("第%d 个位置的元素删除成功:%d\n", i, e);
    	return false;
    }
    
    void PrintList(SqList L)
    {
    	printf("顺序表的元素依次为:");
    	for (int i = 0; i < L.length; i++)
    		printf("%d ,", L.data[i]);
    	printf("\n");
    }
    
    void DestroyList(SqList& L)
    {
    	L.length = 0;
    	L.MaxSize = INITSIZE;
    	free(L.data);
    	printf("销毁成功!");		 
    }
    

    调试截图
    在这里插入图片描述

    展开全文
  • 顺序表的基础操作代码 #include<iostream> #include<stdlib.h> #include<conio.h> using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREAMENT 10 #define TRUE 0 #define FALSE ...
  • 创建一个顺序表 //2.遍历顺序表 //3.通过下标获取元素 //4.查找要查询的元素的下标 //5.通过下标插入元素 //6.通过下标删除一个元素 //7.获取顺序表的长度 //8.删除所有元素 //9.判断顺序表是否为空 //10.判断...
  • #顺序表-初始化 #include<stdio.h> #include<stdlib.h> #define maxSize 100 //顺序表的结构体定义 typedef struct { int *data; //存放顺序表元素的数组 int length; //存放顺序表的长度 }...
  • 一个数据结构的基本操作是指其最核心,最基本的操作。其他较复杂的操作可t通过调用其基本操作来实现。首先我们来了解一下线性表的基本操作:1.InitList(&L):初始化。构造一个空的线性表。2.Length(L):求长,...
  • 预命令部分 #include<iostream> using namespace std; constexpr auto maxSize = ...顺序表 往往使用一维数组来充当顺序存储的操作 (往往和查找一起使用) typedef struct SqList { int data[maxSize...
  • 数据结构—顺序表基本操作(c语言代码

    万次阅读 多人点赞 2018-04-21 17:23:31
    创建一个静态的顺序表存放整数,大小为10,完成以下的操作 1.输入6个整数,打印出顺序表的内容,并显示表中剩余空间的个数 2.在顺序表的第三个位置处插入元素0,打印出表中的内容,并显示空间中剩余的个数 3.再试图...
  • 1,顺序表的定义及基本操作代码
  • 基本操作代码2.主函数测试总结 前言 用C语言实现顺序表的基本操作。 提示:以下是本篇文章正文内容,下面案例可供参考 一、顺序表 数据结构C语言版的顺序表 二、使用步骤 1.基本操作代码 代码如下(示例): #...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,700
精华内容 680
关键字:

顺序表基本操作代码