c语言实现顺序表的插入，删除和求给定元素在表中的位序等运算

最新推荐文章于 2024-04-01 00:40:59 发布
最新推荐文章于 2024-04-01 00:40:59 发布
阅读量1.7w 收藏 16
点赞数 5
分类专栏： 数据结构 文章标签： 语言 c list struct 扩展 ini
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yuanyuanprince/article/details/7561322
版权 
/*在顺序表中插入与删除数据*/
#include<stdio.h>
#include<malloc.h>
#define LIST_SIZE 100/*初始长度*/
#define LIST_INCREMENT 10/*长度增量*/
typedef char ElemType;

/*定义顺序表类型*/
typedef struct{
        ElemType *elem;
        int length;
        int listsize;
}SqList;

SqList L;

SqList* InitiaList()
{
        L.elem=(ElemType *)malloc(LIST_SIZE*sizeof(ElemType));
        if(!L.elem)
        {
                printf("溢出，扩展空间失败！");
                return 0;
        }
        L.length=0;/*长度为0*/
        L.listsize=LIST_SIZE;/*分配的内存空间为LIST_SIZE*/
        return &L;
}

void DestroyList(SqList *L)
{
        free(L->elem);
}

/*在顺序表L中第i个位置插入元素e*/
int ListInsert(SqList *L,int i,ElemType e)
{
        int j;
        ElemType *newbase;
        if(i<1||i>L->length+1)
        {
                printf("位置不合法");
                return 0;
        }
        if(L->length==L->listsize)
        {
        newbase=(ElemType*)realloc(L->elem,(L->listsize+LIST_INCREMENT)*sizeof(ElemType));
                if(!newbase)
                {
                        printf("溢出，扩展空间失败！");
                        return 0;
                }
  L->elem=newbase;
                L->listsize+=LIST_INCREMENT;
        }
        i--;/*将位序参数转化为数组下标*/
        for(j=L->length-1;j>i;j--)
        {
                L->elem[j+1]=L->elem[j];/*后移元素*/
        }
        L->elem[i]=e;/*插入元素*/
        L->length++;
        return 1;
}

/*在顺序表L中删除第i个元素*/
int ListDelete(SqList *L,int i)
{
        int j;
        if(L->length==0)
        {
                printf("这是一个空表，无法删除！");
                return 0;
       }
        i--;
        for(j=i;j<L->length-1;j++)
        {
                L->elem[j]=L->elem[j+1];
        }
        L->length--;
        return 1;
}

/*输出顺序表L*/
void ListTraverse(SqList *L)
{
        int i;
        if(L->length==0)
                printf("空表！");
        else
        {
            for(i=0;i<L->length;i++)
                        printf("%c ",L->elem[i]);
        }
        printf("\n");
}

/*在线性表L中确定第一个与参数e等于/小于/大于的元素位序，f＝0等于，f＝1小于，f＝2大于*/
void LocatElem(SqList *L,ElemType e,int f)
{
        int i;
        switch(f)
        {
        case 0:
                for(i=0;i<L->length;i++)
                        if(L->elem[i]==e)
                        {
                                i=i+1;
                                break;
                        }
                break;
        case 1:
                for(i=0;i<L->length;i++)
                        if(L->elem[i]<e)
                        {
                                i=i+1;
                                break;
                       }
                break;
        case 2:
                for(i=0;i<L->length;i++)
                        if(L->elem[i]>e)
                        {
                                i=i+1;
                                break;
                        }
                break;
        default:
                printf("参数错误！");
        }
        if(i<L->length)
        {
                printf("所比较元素的关系位于第%d\n",i);
        }
        else
        {
                printf("不能比较！");
        }
}

/*根据参数a的值选择子函数执行*/
void chose(int a)
{
      int n,i,m;
        ElemType e;
        switch(a)
        {
        case 1:
                InitiaList();
                ListTraverse(&L);
                break;
        case 2:
                printf("请输入插入元素个数：");
                scanf("%d",&n);
                getchar();
                for(i=0;i<n;i++)
                {
                        printf("请输入插入的元素：");
                        scanf("%c",&e);
                        printf("请输入插入元素的位置：");
                        scanf("%d",&m);
                        getchar();
                        ListInsert(&L,m,e);
                }
                ListTraverse(&L);
                break;
        case 3:
                printf("请输入删除元素个数：");
                scanf("%d",&n);
                for(i=0;i<n;i++)
                {
                        printf("请输入删除的元素的位置：");
                        scanf("%d",&m);
                        ListDelete(&L,m);
                }
                ListTraverse(&L);
                break;
        case 4:
                printf("请输入需要比较的元素：");
                getchar();          
				scanf("%c",&e);
                printf("请输入需要比较元素的关系（0等于，1小于，2大于）");
                scanf("%d",&m);
				printf("%c %d\n",e,m);
                LocatElem(&L,e,m);
                ListTraverse(&L);
                break;
        case 5:
                DestroyList(&L);
                ListTraverse(&L);
                break;
        default:
                printf("参数错误\n");
        }

}

int main(){
        int a;
        printf("1.建立新表\n");
        printf("2.插入元素\n");
        printf("3.删除元素\n");
        printf("4.找出表中与元素e满足大于／等于／小于关系的第一个元素位置\n");
        printf("5.释放顺序表\n");
        printf("0.结束程序\n");
        for(a=1;a!=0;)
        {
                chose(a);
                scanf("%d",&a);
        }
        return 0;
}

 

#include<iostream>
#include<malloc.h>
using namespace std;

typedef int ElemType;
#define OK 1
#define ERROR 0
typedef int Status;

#define LIST_INIT_SIZE 20
#define LISTINCREMENT 10
typedef struct{
	ElemType *elem;
	int length;
	int listsize;
}SqList;

/*顺序表的初始化*/
Status InitList_Sq(SqList &L)
{
	L.elem=(ElemType *)malloc(sizeof(ElemType)*LIST_INIT_SIZE);
	if(!L.elem)
	{
		cout<<"存储空间分配失败！"<<endl;
		return ERROR;
	}
	L.length=0;
	L.listsize=LIST_INIT_SIZE;
	return OK;	
}

/*顺序表的插入*/
Status ListInsert_Sq(SqList &L,int i,ElemType e)
{
	if(i<1||i>L.length+1)
	{
		cout<<"插入位置不合适！"<<endl;
		return ERROR;
	}
	if(L.length+1>L.listsize)
	{
		ElemType* newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
		if(!newbase)
		{
			cout<<"重新分配内存错误!"<<endl;
			return ERROR;
		}
		L.elem=newbase;
		L.listsize+=LISTINCREMENT;
	}
	ElemType *q=&(L.elem[i-1]);//数组从0开始
	for(ElemType *p=&(L.elem[L.length-1]);p>=q;p--)
		*(p+1)=*p;
	*q=e;
	++L.length;
	return OK;
}

/*删除线性表中第i个位置的元素，并用e返回该元素*/
Status ListDelete_Sq(SqList &L,int i,ElemType &e)
{
	if(i<1||i>L.length)
	{
		cout<<"删除位置不合适！"<<endl;
		return ERROR;
	}
	ElemType *q=&(L.elem[i-1]);
	e=*q;
	for(ElemType *p=q;p!=&L.elem[L.length-1];p++)
		*p=*(p+1);
	--L.length;
	return OK;
}

/*在顺序表中L中找到第1个值与e满足compare()的元素的位序*/
Status Equal(ElemType t1,ElemType t2)
{
	if(t1==t2)
		return OK;
	return ERROR;
}

int LocateElem_Sq(SqList L,ElemType e,Status (*compare)(ElemType t1,ElemType t2))
{
	for(int i=1;i!=L.length+1;i++)
		if((*compare)(L.elem[i-1],e))//函数指针的用法
			return i;
	return 0;
}

/*顺序表的合并*/
/*已知La，Lb的元素按值非递减排列
归并La和Lb得到新的顺序表Lc，Lc按值非递减排列
*/

void MergeList_Sq(SqList La,SqList Lb,SqList &Lc)
{
	int i=0,j=0,k=0;

	while(i<La.length && j<Lb.length)
	{
		if(La.elem[i]>Lb.elem[j])
		{
			Lc.elem[k]=Lb.elem[j];
			j++;
		}
		else if(La.elem[i]==Lb.elem[j])
		{
			Lc.elem[k]=Lb.elem[j];
			j++;
			i++;
		}
		else
		{
			Lc.elem[k]=La.elem[i];
			i++;
		}
		k++;
		Lc.length++;
	}
	while(i<La.length)
	{
		Lc.elem[k++]=La.elem[i++];
		Lc.length++;
	}
	while(j<Lb.length)
	{
		Lc.elem[k++]=Lb.elem[j++];
		Lc.length++;
	}
}

/*顺序表的输出*/
void print_Sq(SqList L)
{
	for(int i=0;i!=L.length;i++)
		cout<<L.elem[i]<<"\t";
	cout<<endl;
}

int main()
{
	SqList L;
	InitList_Sq(L);	
	ListInsert_Sq(L,1,1);/*按顺序插入*/
	ListInsert_Sq(L,2,2);
	ListInsert_Sq(L,3,3);
	ListInsert_Sq(L,4,4);
	int e;
	ListDelete_Sq(L,2,e);
	cout<<e<<endl;
	cout<<LocateElem_Sq(L,3,Equal)<<endl;
	print_Sq(L);
	SqList L1;
	SqList L2;
	InitList_Sq(L1);
	InitList_Sq(L2);
	ListInsert_Sq(L1,1,1);/*按顺序插入*/
	ListInsert_Sq(L1,2,2);
	ListInsert_Sq(L1,3,5);
	ListInsert_Sq(L1,4,6);
	ListInsert_Sq(L1,5,7);
	print_Sq(L1);
	MergeList_Sq(L,L1,L2);
	print_Sq(L2);
	return 0;
}



 

yuanyuanprince
关注
  • 5
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C语言实现逆位序建链表实现插入删除功能
11-11
在数据结构中，利用C语言实现逆位序建链表实现是插入和删除的功能。
顺序表 (数组) 详解
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
10-16 2337
1. 顺序表的`位序`和`元素下标`是两个不同概念，位序从1开始，元素下标从0开始。位置为i的元素，它的下标为i-1 2.当i的值在[1，L->length+1]区间内时，都是有效的插入位置。1表示待插入元素取代第1个元素，L->length+1表示插入到最后一个元素的后面。<font color=blue>记得，i是位序，不是下标，它的有效插入位置是(i < 1 || i > L->length + 1)，不要写成(i < 0 || i > L->length)，i为下标时才是这种写法。
顺序表的插入、删除以及查找等基本操作的实现（C语言）
派拉斯兔子的博客
04-21 2万+
一、顺序表（顺序存储） （一）、定义（如何用代码实现） 线性表是具有相同数据类型的n（n >= 0）个数据元素的有限序列。 顺序表：用顺序存储的方式实现线性表顺序存储。 把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。 C语言 sizeof(ElemType)：知道一个数据元素大小。ElemType 就是你的顺序表中存放的数据元素类型. 基本操作的实现 1. 顺序表的实现——静态分配
数据结构以及应用算法教程参考答案（2）第二章答案上
最新发布
VAN
04-01 5862
第2章 线性表 2.1 描述以下三个概念的区别：头指针，头结点，首元结点（第一个元素结点）。 　　解：头指针是指向链表中第一个结点的指针。首元结点是指链表中存储第一个数据元素的结点。头结点是在首元结点之前附设的一个结点，该结点不存储数据元素，其指针域指向首元结点，其作用主要是为了方便对链表的操作。它可以对空表、非空表以及首元结点的操作进行统一处理。 2.2 填空题。 　　解：(1) 在顺序表中插入或删除一个元素，需要平均移动表中一半元素，具体移动的元素个数与元素在表中的位置有关。 (2) 顺序表中逻辑上相
C语言实现顺序表的插入
Thunder_Rey的博客
06-07 7758
盆友宇飞给我了道题，意识到自学还是干不过本科生。 下面是实现的代码：对循序表只是初相识了，甚至发现结构也运用得不是很熟练（根本不熟）。 #include <stdio.h> /*自定义*/ #define MAX 6 typedef int elemtype; /*自定义一个结构*/ typedef struct { elemtype List[MAX]; int num; }qltype; /*qltype是一个结构名字*/ /*声明用
清晰解读C语言中的位域、字节序、比特序、大小端
qq_34907757的博客
06-07 3720
一、比特序/位序 比特序表示一个字节中8个比特位（bit）之间的顺序问题。分为LSB 0 位序和MSB 0 位序。 LSB(least significant bit)：数据的最低位存放在字节的第0位。 MSB (most significant bit)：数据的最高位存放在字节的第0位。 例如有一个十进制的数为174，对应的二进制数为1010 1110. 1.在LSB 0 位序下，其存储形式如下图： 数据流的顺序为0-1-1-1-0-1-0-1 2.在MSB 0 位序下，其存储形式如下图： 数
顺序表-顺序表的基本操作（插入元素+删除元素）
muyu_muyu的博客
12-25 8744
顺序表的存储结构： typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList; 一.插入元素 分析： 在顺序表中，插入一个元素，跟单链表是不一样的。 顺序表中，无论是插入还是删除，都是通过移动元素的来实现。 这里插入元素，插入位置是自己定的，所以有可能出现参数错误的情况。 因此，我们首先要判断参数是否错误。 其次，还需要注意的是: 这里要输入的参数是：逻辑序号 所以要
实验2.0_顺序表的实现及基本操作_
09-29
创建有若干个元素（可以是整型数值）的顺序表，实现对顺序表的初始化，对已建立的顺序表插入操作、删除操作、遍历输出顺序表。 要求各个操作均以函数的形式实现，在主函数中调用各个函数实现以下操作： （1）创建...
顺序表的实现及基本操作_gas3v5_顺序表的实现及基本操作_
10-02
（ 1 ）创建顺序表 21 、 18 、 30 、 75 、 42 、 56 ，并输出顺序表中的各元素值。（ 2 ）在顺序表的第 3 个位置插入 67 ，并输出此时...（ 4 ）查找顺序表中是否有 75 这个元素，如果有返回该元素在顺序表中的位序。
学生基本信息的顺序表
10-15
⑹ 给定一个学生信息， 将其插入到表中指定的位置； ⑺ 删除指定位置的学生记录； ⑻ 统计表中学生个数（求表长度）； ⑼ 销毁表 L； 以上为必做题， 下面为附加题（选做） 。 ⑽ 建立两个有序（学号） 的学生顺序表...
JS实现线性表的顺序表示方法示例【经典数据结构】
12-12
本文实例讲述了JS实现线性表的顺序表示方法。分享给大家供大家参考，具体如下： 线性表的顺序表示指的是用一组地址连接的存储单元依次存储线性表的数据元素。...下面我们来实现插入和删除的过程 首先是插入
顺序表的基本操作（1）——插入操作
just do something
03-27 2万+
顺序表的插入运算 线性表的插入运算是指在表的第i (1≤i≤n+1)个位置，插入一个新元素x，使长度为n的线性表 ( a1​，…，ai−1​，ai​，…，an​) 变成长度为n+1的线性表( a1​，…，ai−1​，x，ai+1​，…，an​) 。 算法思想：用顺序表作为线性表的存储结构时，由于结点的物理顺序必须和结点的逻辑顺序保持一致，因此我们必须将原表中位置n-1，n-2，…，i-1上的结点，依次后移到位置n，n-1，…，i上，空出第i-1个位置，然后在该位置上插入新结点x。当i=n+1时，是指..
顺序表的基本操作【c语言】【创建、插入、删除、输出】
03-24 1434
作为数据结构初学者，上课时对一些知识点掌握得不是很透彻，所以利用课余时间通过微博平台总结所学知识，加深对知识的见解，记录学习历程便于后需要时参考。 1 #include<stdio.h> 2 #include<malloc.h> 3 #define OK 1 4 #define ERROR 0 5 #define LIST_INIT_SIZE 100...
顺序表插入（c语言实现）
LSP522的博客
11-26 4061
使用环境devC++ 5.11 当出现ID returned 1 exit status （ID返回1退出状态）时关闭运行结果窗口再重新运行就行，或者重启devC++。 代码如下： #include<stdio.h> #include<stdlib.h> //要使用的malloc()函数定义在这个头文件中 ，动态分配内存 #include<process.h> //系统库文件， #define MAX 100 typedef struct Seq {
顺序表的插入与删除（数据结构）
qq_53120038的博客
06-07 321
顺序表的插入与删除 此部分来自数据结构 不墨迹直接上胎教版代码(同学看了都说好) #include<iostream> #include<cstdio> #include<cstdlib> using namespace std; #define Max_size 100 //线性表的动态分配顺序储存结构 typedef struct { int* elem; int length; int listsize; }sqlist; //构造一个空的线性表L int
C语言创建顺序表并插入元素 详细注释
Ibelievesunshine的博客
04-22 2万+
顺序表是用一组地址连续的存储单元依次存储数据元素的数据结构。顺序表是线性表的一种，线性表是最常用且最简单的一种数据结构，一个线性表是 n 个数据元素的有限序列。我们使用 c 语言来创建顺序表并插入元素。IDE : Code::Blocks 17.12Compiler : GNU GCC Compiler/*创建顺序表并插入元素*/ #include &lt;stdio.h&gt; #include...
＜顺序表＞《数据结构(C语言版)》
m0_57859086的博客
03-12 1996
目录 博文内容： 数据结构（C语言版）之顺序表及其功能实现（增删查改） 博文作者： 新晓·故知 注： ★博文转载请注明出处。 ★博文仅供学习交流，禁止用于商业用途。 1.线性表 2.顺序表 2.1概念及结构 传值调用： 传址调用： 顺序表初始化： 顺序表尾插： 顺序表尾删： 报错问题：​ 顺序表头插： 顺序表头删： 顺序表在pos(指定位置)插入：​ 顺序表在pos(指定位置)删除： 2.2 接口实现 后记：●由于作者水平有限，文章难免存在谬误...
在顺序表中插入元素_C语言 一看就懂
weixin_48524820的博客
02-20 9399
一看就懂的数据结构带注释 数据结构_在顺序表中插入元素_C语言版 头文件和定义结构体： #include<stdio.h> #include<stdlib.h> #define Initsize 10 //初始的数组长度 typedef struct{ //定义一个结构体（自己定义一个结构类型） int *data; int Maxsize; int Length; }List_dynamic; //结构类型的名字
c语言:顺序表的实现（一） 创建，插入，删除，查找，输出等基本操作实现
热门推荐
在路上
03-22 2万+
#include #include #define LIST_INIT_SIZE 100 #define LIST_INCREMENT 10 using namespace std; struct Sqlist{ long *elem, *newlist; int Length; int listsize; }; void Error(char *s) { cout << s << end
c语言统计单链表中偶数位序的元素和并输出元素值。
04-01
在主函数中，我们创建了一个包含 10 个节点的链表，并调用 `sumEvenNodes` 函数来统计偶数位序的元素和并输出元素值。 运行程序，输出如下： ``` 2 4 6 8 10 The sum of even nodes is 30 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值