精华内容
下载资源
问答
  • 数据结构-顺序表基本操作的实现(含全部代码

    万次阅读 多人点赞 2018-09-13 22:14:57
    今天是线性表中的顺序表的实现,主要实现函数如下,读者有需要可以评论,我可以适当加几个。 CreatList(SqList &L,int n) 参数:顺序表L,顺序表长度n 功能:创建长度为的顺序表 时间复杂度:O(n) InitList...

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

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

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

    • 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<iostream> #include<stdlib.h> #include<conio.h> using namespace std; #define LIST_INIT_SIZE 100 #define LISTINCREAMENT 10 #define TRUE 0 #define FALSE ...

    顺序表的基础操作代码

    #include<iostream>
    #include<stdlib.h>
    #include<conio.h>
    using namespace std;
    
    
    #define LIST_INIT_SIZE  100
    #define LISTINCREAMENT  10
    #define TRUE 0
    #define FALSE 1 
    #define HS 2
    /*这里是后续添加的,并且只在1,2,3中使用到*/
    
    typedef int Status;
    typedef int ElemType;
    typedef struct ListNode{           //定义结构体 
    	ElemType *elem;
    	int length;
    	int listsize;
    }SqList;
    
    Status InitList(SqList &L) {             //1,初始化线性表 
    	L.elem = (ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
    	if(L.elem) 
    		L.length = 0;
    		L.listsize = LIST_INIT_SIZE;
    		return TRUE; 
    		//cout<<"线性表初始化成功"<<endl;
    }
    
    Status DestroyList(SqList &L) {         //2,销毁线性表 
    	if(L.elem) {
    		free(L.elem);
    		L.elem = NULL;
    		L.length = 0;
    		L.listsize = 0; 
    		return TRUE; 
    		//cout<<"线性表已销毁"<<endl; 
    	} else {
    		return FALSE; 
    		//cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status ClearList(SqList &L) {             //3,清空线性表 
    	if(L.elem) {
    		if(L.length == 0) {
    			return TRUE; 
    		//	cout<<"线性表已为空"<<endl; 
    		} else {
    			L.length = 0;
    			return FALSE; 
    		//cout<<"线性表已清空"<<endl;
    		} 
    	} else {
    		return HS;
    		//cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status ListEmpty(SqList &L) {             //4,判断线性表是否为空 
    	if(L.elem) {
    		if(L.length == 0) {
    			cout<<"线性表为空"<<endl;
    		} else {
    			cout<<"线性表不为空"<<endl;
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status GetLength(SqList &L) {             //5,获取线性表长度 
    	if(L.elem) {
    		cout<<"线性表长度为"<<L.length<<endl; 
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status GetElem(SqList &L) {          //6,获取线性表中指定位置元素 
    	if(L.elem) {
    		if(L.length == 0) {
    			cout<<"线性表为空"<<endl;
    		} else {
    			while(true) {
    			int i;
    			cout<<"请输入所查找的位置:"; 
    			cin>>i;
    			if(i>0&&i<=L.length) {
    				
    				cout<<"第"<<i<<"个元素是"<<L.elem[i-1]<<endl;
    				break; 
    				} else {
    					cout<<"输入位置有误!请重新输入"<<endl;
    				} 
    			}
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status GetSite(SqList &L) {            //7,获取线性表元素位置 
    	if(L.elem) {
    		if(L.length == 0) {
    			cout<<"线性表为空"<<endl;
    		} else {
    			int i,flag = 0;
    		cout<<"请输入所要查找的元素:";
    		cin>>i;
    		for (int j = 0;j<L.length;j++) {
    			if (L.elem[j] == i) {
    				int k = j + 1;
    				cout<<"该元素的位置有"<<k<<endl;
    				flag++;
    			}
    		}
    		if (flag == 0) {
    			cout<<"该线性表中无此元素"<<endl;
    		}
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status GetPrior(SqList &L) {               //8,求前驱 
    	if(L.elem) {
    		if(L.length == 0) {
    			cout<<"线性表为空"<<endl;
    		} else {
    			int i,flag = 0;
    		cout<<"请输入元素:"; 
    		cin>>i;
    		for (int j = 0;j<L.length;j++) {
    			if (L.elem[j] == i) {
    				if (j == 0) {
    					cout<<"该元素在第一个位置,没有前驱元素"<<endl;
    					flag++; 
    				} else {
    					cout<<"该元素的前驱元素有:"<<L.elem[j-1]<<endl;
    					flag++;
    				}
    			}
    		}
    		if (flag == 0) {
    			cout<<"该线性表中没有该元素!"<<endl;
    		}
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status GetNext(SqList &L) {               //9,求后继 
    	if(L.elem) {
    		if(L.length == 0) {
    			cout<<"线性表为空"<<endl;
    		} else {
    			int i,flag = 0;
    		cout<<"请输入元素:"; 
    		cin>>i;
    		for (int j = 0;j<L.length;j++) {
    			if (L.elem[j] == i) {
    				if (j == L.length-1) {
    					cout<<"该元素在最后一个位置,没有后继元素"<<endl;
    					flag++;
    				} else {
    					cout<<"该元素的后继元素有:"<<L.elem[j+1]<<endl;
    					flag++;
    				}
    			}
    		}
    		if (flag == 0) {
    			cout<<"该线性表中没有该元素!"<<endl;
    		}
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status InsertElem(SqList &L) {        //10,指定位置插入元素 
    	if(L.elem) {
    		int i,flag = 0;
    		while(true) {
    			while (true) {
    			cout<<"需要插入元素的位置:";
    			cin>>i;
    			cout<<endl;
    			if(i<1||i>L.length+1) {
    				cout<<"表中没有该位置!是否重新进行插入操作?(R/0):";
    				int m;  
    				cin>>m;
    				cout<<endl;
    				if (m == 0) {
    					cout<<"插入操作已停止!"<<endl;
    					flag++;
    					break;
    					
    				} else {
    					continue; 
    				}
    			} else {
    				break;
    			}
    		}
    		if(flag == 1) {
    			break;
    		}
    				if (L.length>=L.listsize) {
    					cout<<"当前存储空间已满!输入1重新分配地址,输入其他则停止插入操作"<<endl;
    					 int k;   cin>>k;
    					 if(k == 1) {
    					 	ElemType *NewElem;
    					 	NewElem = (ElemType*)realloc(L.elem,(L.listsize + LISTINCREAMENT)*sizeof(ElemType));
    					 	if(!NewElem) {
    					 		cout<<"新地址分配失败!程序停止运行!"<<endl;
    					 		break; 
    						 } else {
    						 	L.elem = NewElem;
    						 	L.listsize += LISTINCREAMENT;
    						 }
    					 }
    				}
    					 ElemType e; 
    					 cout<<"请输入需要插入在"<<i<<"位置的元素:";
    					 cin>>e;
    					 cout<<endl;
    					 ElemType *q;
    					 q = &(L.elem[i-1]);
    					 ElemType *p;
    					 for(p = &(L.elem[L.length-1]);p>=q;--p) {
    					 	*(p + 1) = *p;
    					 }
    					 *q = e;
    					 ++L.length;
    					 cout<<"是否继续插入元素?(R/0)"; 
    					 cout<<endl;
    			int d;   
    			cin>>d;
    			if(d == 0) {
    				cout<<"插入操作结束!"<<endl;
    				break; 
    			} 
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status DeleteElem(SqList &L) {               //11,指定位置删除 
    	if(L.elem) {
    		int i,flag = 0;
    		while(true) {
    			while (true) {
    			cout<<"需要删除元素的位置:";
    			cin>>i;
    			if(i<1||i>L.length) {
    				cout<<"表中没有该位置!是否重新进行删除操作?(R/0)"<<endl;
    				int m;  
    				cin>>m;
    				if (m == 0) {
    					cout<<"插入操作已停止!"<<endl;
    					flag++;
    					break;
    			break;
    				} else {
    					continue; 
    				}
    			} else {
    				break;
    			}
    		}
    		if (flag == 1) {
    			break;
    		}
    			ElemType *p,*q; 
    			p = &(L.elem[i-1]);
    			q = L.elem + L.length - 1;
    			for (++p; p <= q;++p) {
    				*(p-1) = *p;
    			} 
    			--L.length;
    			cout<<"是否继续删除元素?(R/0)"<<endl;
    			int d;    cin>>d;
    			if(d == 0) {
    				cout<<"删除操作结束!"<<endl;
    				break; 
    			} 
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status ShowElem(SqList &L) {       //12,遍历线性表 
    		if(L.elem) {
    		if(L.length == 0) {
    			cout<<"线性表为空"<<endl;
    		} else {
    			for (int i = 0;i<L.length;i++) {
    			cout<<L.elem[i]<<"  "; 
    		}
    		cout<<endl;
    		}
    	} else {
    		cout<<"线性表不存在"<<endl;
    	}
    }
    
    Status MergeList() {             //13,合并两个非递减有序线性表  
    	SqList LA,LB,LC;
    	cout<<"建立第一个线性表:";
    	InitList(LA);
    	cout<<"向第一个线性表中插入元素"<<endl;
    	InsertElem(LA);
    	cout<<"建立第二个线性表:" ; 
    	InitList(LB);
    	cout<<"向第二个线性表中插入元素"<<endl; 
    	InsertElem(LB);
    	cout<<"第一个线性表:";
    	ShowElem(LA); 
    	cout<<endl;
    	cout<<"第二个线性表:";
    	ShowElem(LB);
    	cout<<endl;
    	cout<<"初始化最终线性表:";
    	InitList(LC); 
    	int i = 0;
    	int j = 0;
    	int k = 0;
    	int lalen = LA.length;
    	int lblen = LB.length;
    	while((i < lalen) && (j < lblen)) {
    		if (LA.elem[i] <= LB.elem[j]) {
    			if (LA.elem[i] == LB.elem[j]) {
    				LC.elem[k] = LA.elem[i];
    				i++;  j++; k++;LC.length++;
    			} else {
    				LC.elem[k] = LA.elem[i];
    				i++;   k++; LC.length++;
    			}
    		} else {
    			LC.elem[k] = LB.elem[j];
    			j++;   k++; LC.length++;
    		}
    	}
    	while(i<lalen) {
    		LC.elem[k] == LA.elem[i];
    		i++;  k++;  LC.length++;
    		}
    	while(j<lblen) {
    		LC.elem[k] = LB.elem[j];
    		j++;  k++; LC.length++;
    	}
    	for(int g = 0;g < k;g++) {
    		cout<<LC.elem[g]<<" ";
    	}
    }
    
    menu() {
    		cout<<"1----初始化一个线性表"<<endl;
    	cout<<"2----销毁线性表"<<endl;
    	cout<<"3----清空线性表"<<endl;
    	cout<<"4----判断线性表是否为空"<<endl;
    	cout<<"5----求线性表长度"<<endl;
    	cout<<"6----获取线性表中指定位置的元素"<<endl;
    	cout<<"7----获取线性表元素的位置"<<endl;
    	cout<<"8----求前驱"<<endl;
    	cout<<"9----求后继"<<endl;
    	cout<<"10---在线性表指定位置插入元素"<<endl;
    	cout<<"11---删除线性表指定位置的元素"<<endl;
    	cout<<"12---显示线性表"<<endl;
    	cout<<"13---合并两个非递减有序的线性表"<<endl;
    	cout<<"    退出,输出一个负数!"<<endl;
    }
    int main() {
    	int a;
    	SqList L;
    	L.elem = NULL;
    	menu();
    	while (true) {
    		cout<<"请选择程序:";
    		cin>>a;
    		if (a<0) {
    			cout<<"程序已退出!"<<endl;
    			getch();
    		}
    		if (a == 0 && a > 13) {
    			cout<<"程序选择错误!请重新选择:";
    			getch();
    		}
    		if (a > 0 && a < 14) {
    			switch(a) {
    		case 1:{
    			//InitList(L); 
    			if (InitList(L) == TRUE) {
    				cout<<"线性表初始化成功"<<endl;
    				break;
    			} else {
    				cout<<"程序出现问题,请联系技术人员"<<endl;
    			}
    		}
    		case 2:{
    			DestroyList(L);
    			break;
    		}
    		case 3:{
    			ClearList(L);
    			break;
    		}
    		case 4:{
    			ListEmpty(L);
    			break;
    		}
    		case 5:{
    			GetLength(L);
    			break;
    		}
    		case 6:{
    			GetElem(L);
    			break;
    		}
    		case 7:{
    			GetSite(L);
    			break;
    		}
    		case 8:{
    			GetPrior(L);
    			break;
    		}
    		case 9:{
    			GetNext(L);
    			break;
    		}
    		case 10:{
    			InsertElem(L);
    			break;
    		}
    		case 11:{
    			DeleteElem(L);
    			break;
    		}
    		case 12:{
    			ShowElem(L);
    			break;
    		}
    		case 13:{
    			MergeList();
    			break;
    		}
    	}
    		}
    	}
    }
    
    

    第一次写代码,还望大佬给些建议优化程序

    展开全文
  • 一个数据结构的基本操作是指其最核心,最基本的操作。其他较复杂的操作可t通过调用其基本操作来实现。首先我们来了解一下线性表的基本操作:1.InitList(&L):初始化。构造一个空的线性表。2.Length(L):求长,...

    一个数据结构的基本操作是指其最核心,最基本的操作。其他较复杂的操作可t通过调用其基本操作来实现。首先我们来了解一下线性表的基本操作:

    1.InitList(&L):初始化表。构造一个空的线性表。

    2.Length(L):求表长,返回线性表的长度。

    3.LocateElement(L,e):按值查找。查找e在L中的位置。

    4.GetElement(L,i):按位置查找。返回下标为i的元素。

    5.ListInsert(&L,i,e):插入操作。在表中I位置插入元素e。

    6.ListDElete(&L,i,&e):删除操作。删除i位置的元素,并用e返回删除的值。

    7.PringList(L):输出操作。

    8.Empty(L):判空操作。判断线性表是否为空。

    9.DestroyLIst(&L):销毁操作。销毁线性表,并释放线性表L的所有元素值。

    69d04e1c19be66e96ff6e98eff182cd9.png

    注:

    1.具体的实现取决于采用哪种存储结构,存出结构也不同,算法的实现也不同。

    2.&表示C++中的引用。若传入的变量是指针型变量,且在函数体内要对传入的指针进行改变,则会用到指针变量的引用型。

    3.后边我会用C++来实现一下关于顺序表的几种基本操作,

    欢迎关注,留言,讨论,指正,共同学习呀。

    展开全文
  • 数据结构入门----顺序表的基本操作 顺序表及其基本操作的实现 顺序表----12个基本操作实现 我的代码: //实验二、顺序表的基本操作 #include<iostream> #include<cstdlib> using namespace std; #...

    参考:
    数据结构入门----顺序表的基本操作
    顺序表及其基本操作的实现
    顺序表----12个基本操作实现
    我的代码:

    //实验二、顺序表的基本操作
    #include<iostream>
    #include<cstdlib>
    using namespace std;
    
    #define InitSize 100
    
    typedef struct
    {
        int *data;
        int MaxSize;
        int length;
    } SeqList;
    
    //1.初始化顺序表
    int InitList( SeqList &L )
    {
        L.data = (int *) malloc (sizeof (int) * InitSize);
    
        if( !L.data )
        {
            return 0;
        }
        L.length = 0;
        L.MaxSize = InitSize;
        return 1;
    }
    
    //2.顺序表的销毁
    void DestroyList( SeqList &L )
    {
        if( L.data )
        {
            free( L.data );
        }
        L.length = 0;
    }
    
    //3.清空顺序表
    bool ClearList( SeqList &L )
    {
        L.length = 0;
        cout << "线性表清空成功!" << endl;
        return true;
    }
    
    //4.顺序表的判空
    bool Empty( SeqList L )
    {
        if( L.length == 0 )
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    //5.顺序表的长度
    int Length( SeqList L )
    {
        return L.length;
    }
    
    //6.顺序表的按位查找
    bool GetElem( SeqList L, int i )
    {
        //判断查找位置是否合法
        if ( i<1 || i > L.length )
        {
            cout << "查找位置不合法!" << endl;
            return false;
        }
    
        cout << "该位置上的元素是:" <<  L.data[i - 1] << endl;
    
        return false;
    }
    
    //7.顺序表的按值查找
    bool LocateElem( SeqList L, int e )
    {
        for( int i=0; i<L.length; i++ )
        {
            if( L.data[i] == e )
            {
                cout << "该元素的位置是:" <<  i+1 << endl;
                return true;
            }
        }
        cout << "输入元素不存在!" << endl;
        return false;
    }
    
    //8.返回前驱
    int PriorElem( SeqList L, int cur_e )
    {
    
        int *pt = L.data;
        if( cur_e == 1 )
        {
            cout << "该位置上的元素是" << L.data[cur_e-1] << ",它没有前驱!" << endl;
            return false;
        }
        else if ( cur_e > L.length )
        {
            cout << "该位置不合法!" << endl;
            return false;
        }
        else
        {
            int i=1;
            do
            {
                i++;
                pt++;
    
            }
            while( i == cur_e-1 );
    
            cout << "该位置上的元素是" << L.data[cur_e-1] << ",它的前驱是:" <<  *(--pt) << endl;
            return true;
        }
    }
    
    //9.返回后继
    bool NextElem( SeqList L, int cur_e )
    {
    
    
        int *pt = L.data;
    
        if( cur_e == L.length )
        {
            cout << "该位置上的元素是" << L.data[cur_e-1] << ",它没有后继!" << endl;
            return false;
        }
        else if ( cur_e > L.length )
        {
            cout << "该位置不合法!" << endl;
            return false;
        }
        else
        {
            int i=0;
            do
            {
                i++;
                pt++;
    
            }
            while( i == cur_e-1 );
    
            cout << "该位置上的元素是" << L.data[cur_e-1] << ",它的后继是:" <<  *(pt) << endl;
            return true;
        }
    }
    
    
    //10.插入操作
    bool ListInsert( SeqList &L, int i, int e )
    {
        //判断插入位置是否合法
        if ( i<1 || i > L.length+1 )
        {
            cout << "插入位置不合法!" << endl;
            return false;
        }
    
        //判断当前存储空间是否已满
        if( L.length == L.MaxSize )
        {
            cout << "当前存储空间已满!无法插入!" << endl;
            return false;
        }
    
        //将该插入位置之后的元素向后移动一位
        for( int j=L.length; j>=i; j-- )
        {
            L.data[j] = L.data[j - 1];
        }
        //插入新元素
        L.data[i - 1] = e;
        L.length++;
        return true;
    }
    
    //11.顺序表删除元素
    bool ListDelete( SeqList &L, int i )
    {
        //判断位置是否合法
        if( i<1 || i>L.length )
        {
            cout << "删除位置不合法!" << endl;
            return false;
        }
    
        int j;
        for( j = i-1; j<L.length; j++ )
        {
            L.data[j] = L.data[j+1];
        }
        L.length--;
        i--;
        cout << "删除元素成功!" << endl;
        return true;
    
    }
    
    //12.顺序表的打印
    void PrintList( SeqList L )
    {
        if( Empty(L) )
        {
            cout << "顺序表为空!" << endl;
            return ;
        }
    
        for( int i=0; i<L.length; i++ )
        {
            cout << L.data[i] << ' ';
        }
        cout << endl;
    }
    
    //格式化输出菜单
    void xianshi( int i, string text )
    {
        if( i < 10 )
        {
            cout << i << "----" << text << endl;
        }
        if( i >= 10 )
        {
            cout << i << "---" << text << endl;
        }
    }
    
    int main()
    {
        int n, i=1, place_i;
        SeqList a[1000];
    
        xianshi(1,"初始化一个线性表");
        xianshi(2,"销毁线性表");
        xianshi(3,"清空线性表");
        xianshi(4,"判断线性表是否为空");
        xianshi(5,"求取线性表长度");
        xianshi(6,"获取线性表中指定位置的元素");
        xianshi(7,"获取线性表元素的位置");
        xianshi(8,"求前驱");
        xianshi(9,"求后继");
        xianshi(10,"在线性表指定位置插入元素");
        xianshi(11,"删除线性表指定位置的元素");
        xianshi(12,"显示线性表");
        cout<<"    退出输入一个负数"<<endl;
        cout<<"请输入操作代码:"<<endl;
    
        //定义一个波尔函数,用来控制未初始化一个线性表无法执行操作
        bool continuedo=false;
    
        do
        {
            cin >> n;
            if( n < 0 )
            {
                return 0;
            }
            else
            {
                switch( n )
                {
                case 1 :
                {
                    if( InitList( a[i] ) )
                    {
                        cout<<"初始化线性表成功!线性表序号为:"<<i<<endl;
                        place_i = i;
                        i++;
                        continuedo = true;
                    }
                    else
                    {
                        cout << "线性表初始化失败!" << endl;
                    }
                    break;
                }
                case 2 :
                {
                    if( continuedo == true )
                    {
                        int m=0;
                        cout << "请输入要销毁的线性表的序号:" << endl;
                        cin >> m;
                        if( m > place_i )
                        {
                            cout << "要销毁的线性表不存在!" << endl;
                        }
                        else
                        {
                            DestroyList( a[m] );
                            cout << "线性表" << m << "销毁成功!" << endl;
                        }
                    }
                    else
                    {
                        cout << "线性表未初始化,无法销毁!" << endl;
                    }
                    break;
                }
                case 3 :
                {
                    if( continuedo == true )
                    {
                        int m=0;
    
                        cout << "请输入要清空的线性表序号:" << endl;
                        cin >> m;
    
                        if( m > place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            ClearList( a[m] );
                        }
                    }
                    else
                    {
                        cout << "线性表未初始化,无法清空!" << endl;
                    }
                    break;
                }
                case 4 :
                {
                    if( continuedo == true )
                    {
                        int m=0;
    
                        cout << "请输入要判空的线性表序号:" << endl;
                        cin >> m;
    
                        if( m > place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            if( Empty( a[m] ))
                            {
                                cout << "线性表为空!" << endl;
                            }
                            else
                            {
                                cout << "线性表非空!" << endl;
                            }
                        }
                    }
                    else
                    {
                        cout << "线性表未初始化,无法判空!" << endl;
                    }
                    break;
                }
                case 5 :
                {
                    if(continuedo==true)
                    {
                        cout<<"请输入要测量的线性表的序号:"<<endl;
                        int m=0;
                        cin>>m;
                        if(m>place_i)
                        {
                            cout<<"线性表不存在!"<<endl;
                        }
                        else
                        {
                            cout<<Length(a[m])<<endl;
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法测量长度!"<<endl;
                    }
                    break;
                }
                case 6 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要查找的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            int q=0;
                            cout << "请输入要查找的元素位置:" << endl;
                            cin >> q;
                            GetElem(a[m], q);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法查找!"<<endl;
                    }
                    break;
                }
    
                case 7 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要查找的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            int q=0;
                            cout << "请输入要查找的元素:" << endl;
                            cin >> q;
                            LocateElem(a[m], q);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法查找!"<<endl;
                    }
                    break;
                }
                case 8 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要查找的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            int q=0;
                            cout << "请输入要查找的位置:" << endl;
                            cin >> q;
                            PriorElem(a[m], q);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法查找!"<<endl;
                    }
                    break;
                }
                case 9 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要查找的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            int q=0;
                            cout << "请输入要查找的位置:" << endl;
                            cin >> q;
                            NextElem(a[m], q);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法查找!"<<endl;
                    }
                    break;
                }
                case 10 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要插入的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            int q=0;
                            cout << "请输入要插入的位置:" << endl;
                            cin >> q;
                            int p=0;
                            cout << "请输入要插入的元素:" << endl;
                            cin >> p;
                            ListInsert(a[m], q, p);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法插入!"<<endl;
                    }
                    break;
                }
                case 11 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要删除的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            int q=0;
                            cout << "请输入要删除的位置:" << endl;
                            cin >> q;
    
                            ListDelete(a[m], q);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法删除!"<<endl;
                    }
                    break;
                }
                case 12 :
                {
                    if( continuedo == true )
                    {
                        cout << "请输入要打印的线性表的序号:" << endl;
                        int m=0;
                        cin >> m;
    
                        if( m> place_i )
                        {
                            cout << "线性表不存在!" << endl;
                        }
                        else
                        {
                            PrintList(a[m]);
                        }
                    }
                    else
                    {
                        cout<<"线性表未初始化,无法打印!"<<endl;
                    }
                    break;
                }
                default:
                    cout << "操作码输入有误!" << endl;
                    break;
                }
            }
        }
        while( 1 );
    
        return 0;
    }
    
    
    展开全文
  • 学渣代码都不认识,...</strong></strong><strong><strong>顺序表的基本操作实现</strong></strong></strong></p> 要求:数据元素类型ElemType取整型int。按照顺序存储结构实现如下算法: ...
  • #include<malloc.h> #include<stdlib.h> //函数返回状态代码 #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define INFEASIBLE -1 #define OVERFLOW -2 //运用动态分配的顺序存储结构 #define
  • 实验六 查找 //顺序查找和二分查找 #include "stdio.h" #include "stdlib.h" #define N 20 typedef struct { int Key; }ElemType; typedef struct SSTable { ElemType *elem; int length; }SSTable; int Search_Seq...
  • 数据结构实验一的源代码,实现了顺序表的插入、删除、排序。。。是一个不错的代码
  • //输出顺序表的元素 int Print(Sqlist L) { if(L.length) { printf("\n输出顺序表中的元素:"); for(int i=0;i;i++) { printf("%d ",L.elem[i]); } printf("\n"); } else printf("\n存储错误!!!"); ...
  • #顺序表-初始化 #include<...//顺序表的结构体定义 typedef struct { int *data; //存放顺序表元素的数组 int length; //存放顺序表的长度 }Sqlist; //顺序表类型的定义 //初始化顺序表 Sql...
  • 要想灵活使用数据结构,你需要先弄清楚数据在代码中被处理、加工的最小单位动作,也就是数据结构的基本操作,有了这些动作之后,你就可以基于此去选择更合适的数据结构了。1. 举个栗子:代码对数据处理例1:查找出一...
  • 顺序表的基本操作有初始化、插入、删除、查找(按值、按序)、打印 等。 下面的代码是对于最基本的数据类型的数据元素进行的操作,而对于自定义的数据类型的操作可以看这个:用顺序表实现学生的信息管理 #include...
  • 由于经常使用链表,导致对于顺序表的基本操作有点不熟悉,今天就写一篇文章来回顾一下顺序表的基本操作代码实现: #include<stdio.h> #include<stdlib.h> #define ElemType int #define InitSize 100...
  • //头文件#include<stdio>#include<malloc>#include<stdlib>//函数返回状态代码#define OK 1#define ERROR 0#defi
  • 数据结构-顺序表基本操作的实现(含全部代码) 版权声明:转载请注明出处,并附有原文链接。谢谢:) https://blog.csdn.net/lady_killer9/article/details/82695770 今天起开始编写数据结构各种...
  • 数据结构顺序表基本操作(c语言代码

    万次阅读 多人点赞 2018-04-21 17:23:31
    /******************************...1.输入6个整数,打印出顺序表的内容,并显示表中剩余空间的个数 2.在顺序表的第三个位置处插入元素0,打印出表中的内容,并显示空间中剩余的个数 3.再试图插入表中第11个位置整数...
  • PAGE PAGE 1 实验1顺序表的基本操作 一实验目的 1掌握使用VC++6.0上机...3练习顺序表的基本操作 三实验前的准备 1复习相关课程内容 2理解并掌握顺序表的存储结构基本操作 3准备相关的程序清单 四实验要求 1建立个人的工
  • 数据结构顺序表的基本操作

    千次阅读 2018-07-02 22:03:29
    可以说顺序表是最简单,最容易学习的数据结构基本操作代码如下:#include &lt;iostream&gt; #include &lt;stdlib.h&gt; using namespace std; /** * 线性表顺序存储表示(顺序表 Sequential ...
  • 本篇文章实现了数据结构严蔚敏版上顺序表的基本操作,以及简单应用比如说实现两个有序顺序表的合并(归并)。 文章目录数据结构之顺序表基本功能实现前言一、顺序表的定义2.顺序表的特点二、顺序表上基本操作的实现...
  • 最近有点偷懒,加上期末考试临近,已经有半个多月没发过博客了,这几天学习了一点数据结构顺序表的东西,就整理一些顺序表的基本操作吧。先写一个包含需要进行的操作的头文件,在测试代码和执行代码中就可以引入这个...
  • 顺序表的基本操作代码实现

    千次阅读 2021-02-05 19:34:56
    顺序表顺序表是在计算机内存中以数组形式保存线性表,是指用一组地址连续存储单元依次存储数据元素线性结构。即线性表采用顺序存储方式存储就称之为顺序表。 下面直接上代码: //SeqList.h #include&...
  • 顺序表的基本操作 1.插入元素 2.删除元素 3.查找元素 4.更改元素 插入操作 插入操作根据插入的位置不同分三种情况: 1.插入表头。 2.插入表的的中间位置。 3.插入表的尾部作为表的最后一个元素。 虽然插入顺序表的...
  • c++实现数据结构顺序表: 初始化顺序表, 创建顺序表,增加顺序表的空间,取值,查找操作-按值查找,插入,删除,求表长,判空,合并有序(递增)顺序表,输出顺序表 顺序表优点: 随机存取,只要O(1)的时间就可以...
  • 数据结构顺序表基本操作(C/C++实现)

    千次阅读 多人点赞 2019-10-22 23:23:01
    数据结构顺序表基本操作(C/C++实现) 涉及基本运算 初始化顺序表L 依次插入abcde元素 输出顺序表L 输出顺序表L长度 判断顺序表L是否为空 输出顺序表L第3个元素 输出元素a位置 在第4个元素位置上插入f元素 ...
  • 预命令部分 #include<iostream> using namespace std; constexpr auto maxSize = ...顺序表 往往使用一维数组来充当顺序存储的操作 (往往和查找一起使用) typedef struct SqList { int data[maxSize...
  • 数据结构顺序表的增删改查基本操作代码如下: #include <stdio.h> #include <stdlib.h> typedef struct Table{ int * head; int length; int size; }table; //初始化 void initTable...
  • 小武老师布置题,让...该程序包括顺序表结构类型定义以及对顺序表操作的具体函数定义和主函数。 此题我使用了一些对于界面好看点程序代码,这还是gyy以前教,在此表以感谢。 用顺序表实现 ...
  • 分为三部分: SeqList.h负责函数声明 ...下列为源代码: SeqList.h #pragma once typedef int DataType; typedef struct SeqList { DataType *arr; int size;//有效元素个数 int Capacity;//容量 }SeqList, *P...

空空如也

空空如也

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

数据结构顺序表的基本操作代码

数据结构 订阅