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

    2017-04-14 14:27:12
    顺序表基本操作 顺序表实现 顺序表
  • 顺序表基本操作

    2017-09-18 23:24:03
    本资源是:线性表中的顺序表的一些操作,包括初始化顺序表、建立顺序表、删除顺序表、在顺序表中插入元素,在顺序表中删除元素、判断空的等一些基本操作
  • 主要介绍了C语言实现顺序表基本操作汇总,对学习数据结构的朋友有一定的借鉴价值,需要的朋友可以参考下
  • 数据结构-顺序表基本操作的实现(含全部代码

    万次阅读 多人点赞 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(小于),您的支持是我不断更新的动力。

    展开全文
  • 顺序表基本操作代码实现

    千次阅读 2021-02-05 19:34:56
    顺序表顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。即线性表采用顺序存储的方式存储就称之为顺序表。 下面直接上代码: //SeqList.h #include&...

    顺序表:顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。即线性表采用顺序存储的方式存储就称之为顺序表。

    下面直接上代码:

    
     //SeqList.h
    
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include<assert.h>
    
    typedef int SLdatatype;
    
    typedef struct SeqList
    {
    	SLdatatype *a;//存储数据空间的指针
    	int capacity;//容量空间大小
    	int size;//有效数据个数
    }SeqList;
    
    void SeqListInit(SeqList *psl);//初始化
    void SeqListDestroy(SeqList *psl);//删除
    void SeqListPrint(SeqList *psl);//输出
    void SeqListPushBack(SeqList *psl, SLdatatype x);//尾插
    void SeqListPushFront(SeqList *psl, SLdatatype x);//头插
    void SeqListPopBack(SeqList *psl);//尾删
    void SeqListPopFront(SeqList *psl);//头删
    void SeqListInsert(SeqList *psl, int pos, SLdatatype x);//按位置插入元素
    void SeListErase(SeqList *psl, int pos);//按位置删除元素
    
    
     //SeqList.c
    
    #include"SeqList.h"
    
    void SeqListInit(SeqList *psl)
    {
    	psl->a = (SLdatatype*)malloc(sizeof(SLdatatype)*4);
    	if (psl->a == 0){
    		printf("malloc fail\n");
    		exit(-1);
    	}
    	memset(psl->a, 0, sizeof(SLdatatype) * 4);
    	psl->size = 0;
    	psl->capacity = 4;
    }
    
    void SeqListDestroy(SeqList *psl)
    {
    	free(psl->a);
    	psl->a = NULL;
    	psl->capacity = psl->size = 0;
    }
    
    void SeqListPrint(SeqList *psl)
    {
    	for (int i = 0; i < psl->size; i++){
    		printf("%d ", psl->a[i]);
    	}
    	printf("\n");
    }
    
    void CheckCapacity(SeqList* psl)
    {
    	if (psl->size == psl->capacity){
    		SLdatatype *b = (SLdatatype*)realloc(psl->a, sizeof(SLdatatype)*psl->capacity * 2);
    		if(b == NULL){
    			printf("malloc fail\n");
    			exit(-1);
    		}
    		psl->a = b;
    		psl->capacity = psl->capacity * 2;
    	}
    }
    
    void SeqListPushBack(SeqList *psl, SLdatatype x)
    {
    	    assert(psl);
    		CheckCapacity(psl);
            psl->a[psl->size] = x;
    	    psl->size++;
    
    }
    
    void SeqListPushFront(SeqList *psl, SLdatatype x)
    {
    	assert(psl);
    	CheckCapacity(psl);
    	for (int i = psl->size; i >0; i--){
    		psl->a[i] = psl->a[i - 1];
    	}
    	psl->a[0] = x;
    	psl->size++;
    }
    
    void SeqListPopBack(SeqList *psl)
    {
    	assert(psl);
    	assert(psl->size > 0);
    	psl->size--;
    }
    
    void SeqListPopFront(SeqList *psl)
    {
    	assert(psl);
    	assert(psl->size > 0);
    	for (int i = 0; i < psl->size; i++){
    		psl->a[i] = psl->a[i + 1];
    	}
    	psl->size--;
    }
    
    void SeqListInsert(SeqList *psl, int pos, SLdatatype x)
    {
    	assert(psl);
    	assert(pos >= 0 && pos <= psl->size);
    	CheckCapacity(psl);
    	int i;
    	for (i = psl->size; i>=pos; i--){
    		psl->a[i] = psl->a[i - 1];
    	}
    	psl->a[pos] = x;
    	psl->size++;
    }
    
    void SeListErase(SeqList *psl, int pos)
    {
    	assert(psl);
    	assert(pos >= 0 && pos <= psl->size);
    	for (int i = pos+1; i < psl->size; i++){
    		psl->a[i - 1] = psl->a[i];
    	}
    	psl->size--;
    }
    
    
     //test.c
    
    #include"SeqList.h"
    
    int main()
    {
    	SeqList s1;
    	SeqListInit(&s1);
    	SeqListPushBack(&s1, 1);
    	SeqListPushBack(&s1, 2);
    	SeqListPushBack(&s1, 3);
    	SeqListPushBack(&s1, 4);
    	SeqListPushBack(&s1, 5);
    	SeqListPrint(&s1);
    	SeqListPushFront(&s1, 0);
    	SeqListPrint(&s1);
    	SeqListPopBack(&s1);
    	SeqListPrint(&s1);
    	SeqListPopFront(&s1);
    	SeqListPrint(&s1);
    	SeqListInsert(&s1,2,10);
    	SeqListPrint(&s1);
    	SeListErase(&s1,2);
    	SeqListPrint(&s1);
    }
    
    展开全文
  • 主要为大家详细介绍了C++顺序表基本操作,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 顺序表操作基本代码

    2017-12-22 09:43:15
    顺序表操作基本代码。帮助顺序表的学习和代码的编写等。
  • 顺序表基本操作(完整代码

    千次阅读 2021-07-31 11:00:17
    L):初始化顺序表(动态分配) ListInsert(SqList& L, int i, int a):在顺序表中插入元素 bool ListDelete(SqList& L, int i) :在顺序表中按照位序删除元素 int LocateElem(SqList& L, int e):查找顺序表...

    函数说明😃:

    void InitSqList(SqList &L):初始化顺序表(动态分配)
    ListInsert(SqList& L, int i, int a):在顺序表中插入元素
    bool ListDelete(SqList& L, int i) :在顺序表中按照位序删除元素
    int LocateElem(SqList& L, int e):查找顺序表中第一个元素值等于e的元素,并返回其位序
    int GetElem(SqList& L, int i) :查找顺序表中第i个元素
    bool ListReverse(SqList& L, int a) :顺序表逆置
    void ListShow(SqList L) :打印顺序表中的元素

    代码😃:

    #include<stdio.h>
    #include <stdlib.h>
    #include <iostream>
    using namespace std;
    constexpr auto Maxsize = 10;
    typedef struct {
    	int  *data;
    	int length;
    }SqList;
    
    //初始化顺序表(动态分配)
    void InitSqList(SqList &L) {
    L.data = (int*)malloc(sizeof(int)* Maxsize);
    if (L.data == NULL) {
    
    	printf("分配内存失败");
    	exit(1);
    }
    else {
    
    L.length = 0;
    printf("内存分配成功\n");
    }
    }
    
    //顺序表插入元素
    bool ListInsert(SqList& L, int i, int a) {
    	if (i<1 || i>L.length + 1) {  
    		printf("插入失败\n");
    		return false;
    	}//判断i的范围是否有效
    	if (L.length >= Maxsize) {
    		printf("插入失败\n");
    		return false;
    	}//当前存储空间已满,不能插入
    	for (int j = L.length - 1; j >= i-1; j--) {
    		L.data[j+1] = L.data[j];
    	}
    	L.data[i - 1] = a;
    	L.length++;
    	return true;
    }
    //顺序表按照位序删除元素
    bool ListDelete(SqList& L, int i) {
    	if (i<1 || i>L.length)return false;
    	for (int j = i; j < L.length; j++) {
    		L.data[j - 1] =L .data[j];
    	}
    	L.length--;
    	return true;
    }
    //查找顺序表中第一个元素值等于e的元素,并返回其位序
    int LocateElem(SqList& L, int e) {
    	int i;
    	for (i = 0; i < L.length; i++) if (L.data[i] == e)return i + 1;
    	return 0;
    
    }
    //查找顺序表中第i个元素
    int GetElem(SqList& L, int i) {
    	return L.data[i - 1];
    
    }
    
    //顺序表逆置
    bool ListReverse(SqList& L) {
    	if (L.length<1 || L.length>Maxsize) return false;
    	int i, j;
    	
    	for (i = 0; i < L.length/ 2; i++, L.length--) {
    		j = L.data[i];
    		L.data[i] = L.data[L.length-1];
    		L.data[L.length-1] = j;
    		
    	}
    	
    
    	return  true;
    }
    void ListShow(SqList L) {
    	int i;
    	printf("目前顺序表里的元素:");
    	for (i = 0; i < L.length; i++) {
    	
    		printf("%d", L.data[i]);
    	}
    	printf("\n");
    }
    //主函数
    int main() {
    	SqList L;
        int i,e;
    	while(1){
    	printf("*******************************\n");
    	printf("请输入您要进行的操作:\n");
    	printf("1.顺序表的初始化  2.插入元素\n");
    	printf("3.删除元素        4.按值查找元素\n");
    	printf("5.按位查找元素    6.输出元素\n");
    	printf("7.元素倒置        8.退出\n");
    	printf("*******************************\n");
    	scanf_s("%d", &i);
    	switch (i)
    	{
    	case 1:
    		InitSqList(L);
    		break;
    	case 2:
    		
    		printf("请输入您要插入的位置\n");
    		scanf_s("%d", &i);
    		printf("请输入您要插入的元素\n");
    		scanf_s("%d", &e);
    		ListInsert(L,i,e);
    		break;
    	case 3:
    		printf("请输入您要删除的元素的位置\n");
    		scanf_s("%d", &e);
    		ListDelete(L,e );
    		break;
    	case 4:
    		printf("请输入您要查找的元素的值\n");
    		scanf_s("%d", &i);
    		e =  LocateElem(L, i);
    		printf("该元素的位序为%d\n",e);
    		break;
    	case 5:
    		printf("请输入您要查找的元素的位置\n");
    		scanf_s("%d", &i);
    		e = GetElem(L, i);
    		printf("查找的元素的值为%d\n",e);
    		break;
    	case 6:
    		ListShow(L);
    		break;
    	case 7:
    		ListReverse(L);
    		break;
    	case 8:
    		break;
    	default:
    		printf("输入错误\n");
    		break;
    	}
    	  ListShow(L);
    	}
    	
    	
    	return 0;
    }
    

    效果展示:

    在这里插入图片描述

    初始页面

    在这里插入图片描述

    插入元素

    在这里插入图片描述

    元素倒置

    参考:王道的数据结构以及其他博主文章

    展开全文
  • 1,顺序表的定义及基本操作代码
  • 顺序表的主要操作代码(C语言)

    千次阅读 2018-11-28 13:12:46
    顺序表的主要操作代码(C语言) 顺序表的主要操作代码(C语言) 王道考研数据结构线性表的基本操作: InitList(&amp;L);初始化表 Length(L);求表长 LocateElem(L,e);按值查找操作 GetElem(L,i);按位查找操作 ...

    顺序表的主要操作代码(C语言)

    顺序表的主要操作代码(C语言)

    王道考研数据结构线性表的基本操作:
    InitList(&L);初始化表
    Length(L);求表长
    LocateElem(L,e);按值查找操作
    GetElem(L,i);按位查找操作
    ListInsert(&L,i,e);插入操作
    ListDelete(&L,i,&e);删除操作
    PrintList(L);输出操作
    Empty(L);判空操作
    DestoryList(&L);销毁操作

    // An highlighted block
    #include<stdio.h>
    #include<stdlib.h>
    #define MaxSize 50   //定义线性表的最大长度
    typedef int ElemType;
    typedef struct SqList
    {
    	ElemType data[MaxSize];   //<===>int data[50];
    	int length;   //顺序表的当前长度
    }SqList;   //顺序表的类型定义
    
    
    //初始化表,构建一个空的线性表
    void InitList(SqList *L)
    {
    	L->length=0;
    }
    
    //求表长,返回线性表L的长度,即L中数据元素的个数
    int Length(SqList L)
    {
    	return L.length;
    }
    
    //按值查找操作,在表L中查找具有给定关键字值的元素
    int LocateElem(SqList L,int e)
    {
    	int i;
    	for(i=0;i<L.length;i++)
    		if(L.data[i]==e) return i+1;
    	return 0;
    }
    
    //按位查找操作,获取表L中第i个位置的元素的值
    int GetElem(SqList L,int i)
    {
    	if(i<1||i>L.length) return -1;
    	return L.data[i-1];
    }
    
    //插入操作,在表L中第i个位置上插入指定元素e
    int ListInsert(SqList *L,int i,int e)
    {
    	int j;
    	if(i<1||i>L->length+1) return 0;  //判断i的范围是否有效
    	if(L->length>=MaxSize) return 0;  //当前存储空间已满,不能插入
    	for(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 1;
    }
    
    //删除操作,删除表L中第i个位置的元素,并用e返回删除元素的值
    int ListDelete(SqList *L,int i,int *e)
    {
    	int j;
    	if(i<1||i>L->length) return 0;
    	*e=L->data[i-1];
    	for(j=i;j<L->length;j++)
    		L->data[j-1]=L->data[j];
    	L->length--;
    	return 1;
    }
    
    //输出操作,按前后顺序输出线性表L的所有元素值
    void PrintList(SqList L)
    {
    	int i;
    	printf("输出顺序表:\n");
    	for(i=0;i<L.length;i++)
    		printf("%d	",L.data[i]);
    	printf("\n");
    }
    
    //判空操作,若L为空表,则返回true,否则返回false
    int Empty(SqList L)
    {
    	if(L.length==0) return 1;
    	return 0;
    }
    
    //销毁操作,销毁线性表,并释放线性表L所占用的内存空间
    void DestoryList(SqList *L)
    {
    	free(L);
    }
    
    //创建顺序表
    void CreateList(SqList *L)
    {
    	int n,i=0;
    	printf("请输入元素个数n和n个元素,中间用空格隔开,注意n<=50!!!\n");
    	scanf("%d",&n);
    	while(i<n)
    	{
    		scanf("%d",&L->data[i]);
    		//printf("%d	",L->data[i]);
    		i++;
    	}
    	L->length=n;
    }
    void main()
    {
    	SqList L;   
    	int e;
    	CreateList(&L);  //输入6  9 0 4 7 2 1
    	PrintList(L);
    	ListInsert(&L,3,100);
    	PrintList(L);
    	ListDelete(&L,3,&e);
    	PrintList(L);
    }
    
    
    展开全文
  • 顺序表的十几种基本操作(详细)的代码(经过编译)

    万次阅读 多人点赞 2018-10-12 18:37:38
    通过本次写顺序表基本操作,又提高了我对指针的认知。 *关于在main函数中定义SqList pL;和定义SqList pL;的差别: 定义SqList *pL;//第一次试验时,没有给pL分配存储空间,结果编译没问题,运行就出现了错误,这...
  • C语言实现顺序表基本操作

    千次阅读 2019-07-31 15:42:08
    C语言实现顺序表基本操作
  • 数据结构C语言完成顺序表基本操作,上数据结构课的时候的任务,可以在vs上实现,用switch函数选择
  • 顺序表基本操作C/C++代码实现

    千次阅读 2020-05-31 11:58:48
    顺序表可以随机存取表中任一元素,其存储位置可用一个简单、直观的公式来表示。然而, 从另一方面来看,这个特点也造成了这种存储结构的缺点:在做插入或删除操作时,需移动大最元素。另外由于数组有长度相对固定的...
  • 数据结构顺序表基本操作(C/C++实现)

    千次阅读 多人点赞 2019-10-22 23:23:01
    数据结构顺序表基本操作(C/C++实现) 涉及基本运算 初始化顺序表L 依次插入abcde元素 输出顺序表L 输出顺序表L的长度 判断顺序表L是否为空 输出顺序表L的第3个元素 输出元素a的位置 在第4个元素位置上插入f元素 ...
  • 编写一个完整的程序,实现顺序表的生成、插入、删除、输出等基本运算。
  • 主要为大家详细介绍了顺序表定义及python实现代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • 顺序表基本操作的实现

    千次阅读 2020-02-22 22:52:43
    实验一 顺序表基本操作的实现 一、实验学时: 2学时 二、实验目的 实现顺序表的基本操作 三、实验内容 顺序表的建立、取指定元素、返回指定元素位置 顺序表中插入新元素、删除指定元素操作的实现 四、主要仪器...
  • 数据结构中顺序表基本操作实现C语言代码

    千次阅读 多人点赞 2020-01-08 21:47:10
    printf("\t\t\t********************欢迎来到顺序表存储基本操作*****************************"); printf("\n\t\t\t**************1.创建顺序表-------------------2.插入元素********************\n"); printf...
  • C++数据结构实验资源,源代码也有。顺序表操作
  • 主要介绍了Python数据结构之顺序表的实现代码示例,简单介绍了顺序表的相关内容,然后分享了其代码示例,具有一定参考价值,需要的朋友可以了解下。
  • 顺序表基本操作(C语言实现,简单易懂!)

    千次阅读 多人点赞 2021-01-24 00:25:10
    一、学习内容:1、 创建顺序表 2、 按数值查找 3、 按位置查找 4、 插入一个数值 5、 删除一个数值 6、 销毁顺序表 7、 求前驱算法 8、 求后继算法
  • c语言 顺序表基本操作(创建、初始化、赋值、插入、删除、查询、替换、输出) 1、创建、申请空间 2、初始化、顺序表数据结构大小、长度 3、赋值、顺序表数据结构赋值 4、插入、在指定位置插入数据,后续数据...
  • 数据结构-顺序表基本操作-C语言代码

    千次阅读 多人点赞 2020-01-22 13:37:06
    #顺序表-初始化 #include<stdio.h> #include<stdlib.h> #define maxSize 100 //顺序表的结构体定义 typedef struct { int *data; //存放顺序表元素的数组 int length; //存放顺序表的长度 }...
  • 数据结构—顺序表基本操作(c语言代码

    万次阅读 多人点赞 2018-04-21 17:23:31
    创建一个静态的顺序表存放整数,大小为10,完成以下的操作 1.输入6个整数,打印出顺序表的内容,并显示表中剩余空间的个数 2.在顺序表的第三个位置处插入元素0,打印出表中的内容,并显示空间中剩余的个数 3.再试图...
  • #include using namespace std; #define True 11 #define False 0 #define Ok 111 #define Error -111 #define List_Init_Size 10 #define ListIncrement 10 typedef int Status;... //元素类型
  • 实验报告1.2.2顺序表基本操作应用实验2
  • c语言顺序表基本操作

    万次阅读 多人点赞 2018-06-30 15:18:36
    下面是顺序表基本操作,c语言版的数据结构书上写的操作都实现了因为总体代码太长如果写在一个class中要近500行,阅读和修改都不方便,所以采用分开写,希望大家以后写较长的程序时也采用这种方法,自己运行的所有...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 382,806
精华内容 153,122
关键字:

顺序表的基本操作代码