精华内容
下载资源
问答
  • 严蔚敏数据结构C语言版 线性表的增删改查功能(完全自己敲的) /* 严蔚敏数据结构C语言版 顺序线性表的综合程序(增删改查) */ //头文件 #include<stdio.h> #include<malloc.h> #include<stdlib.h&...

    严蔚敏数据结构C语言版 线性表的增删改查功能(完全自己敲的)

    /*
    严蔚敏数据结构C语言版
    顺序线性表的综合程序(增删改查)
    */
    
    //头文件
    #include<stdio.h>
    #include<malloc.h>
    #include<stdlib.h>
    
    //宏区
    #define List_capacity 100						//线性表L的初始容量
    #define List_appreciation 10					//线性表L的初始容量不足时分配的增量
    
    //结构
    typedef struct									//结构
    {
    	int *elem;									//用于指向动态连续分配的存储空间的首地址
    	int length;									//当前线性表L的长度
    	int list_size;								//当前线性表L的存储容量
    }Sqlist;
    
    //函数区
    void List_initialize(Sqlist *L)											//线性表L的初始化
    {
    	L->elem = (int *)malloc(List_capacity * sizeof(int));				//分配了一段List_capacity动态连续存储的空间并把首地址发送给L->elem
    	if (!L->elem)
    	{
    		printf("初始化分配失败,检查程序!\n");							//输出信息,出问题时候方便查找问题所在地
    		exit(1);														//非正常退出程序,终止程序
    	}
    	else
    		printf("初始化成功,请继续下一步操作:\n");
    
    	L->length = 0;														//未赋值,线性表L的初始化长度为0
    	L->list_size = List_capacity;										//记录已经为线性表L分配了List_capacity长度的存储容量												
    }
    
    void List_The_default_value(Sqlist *L)									//线性表L的默认赋值
    {
    	int i, j;
    
    	L->elem[0] = NULL;													//初始化线性表L的下标为0的元素为0
    	for (i = 1;i <= 10;i++)												//从1开始依次赋值给线性表L的每个元素,到10为止
    	{
    		L->elem[i] = i;													//将i值赋于将下标为i的元素
    		L->length++;													//每赋值一个数将线性表L的长度自增一次
    
    		if (L->length > L->list_size)														//如果线性表L的当前长度大于了线性表L的容量
    		{
    			int * new1;
    
    			new1 = (int *)realloc(L->elem, (L->length + List_appreciation) * sizeof(int));	//重新分配L->elem的存储空间并临时用new1指向
    			if (!new1)																		//如果分配失败
    			{
    				printf("赋值时容量不够,进行增值分配但分配失败请检查程序!\n");				//显示错误,用于方便查找位置
    				exit(1);																	//非正常退出程序,终止程序
    			}
    
    			L->elem = new1;																	//将new1内的地址发送给L->elem使线性表L指向新分配的空间
    			L->list_size = L->length + List_appreciation;									//记录容量
    		}
    	}
    
    	printf("当前线性表L的元素值为:");									//用于提示用户线性表L内的值
    	for (j = 1;j <= L->length;j++)										//依次输出线性表L的值
    		printf("%d ", L->elem[j]);
    	printf("\n赋值成功请进行下一步操作:\n\n\n");						//赋值成功
    }
    
    void List_insert(Sqlist *L)												//线性表的插入(增)
    {
    	int i, j, e, k;
    
    	/*													//这个判断有问题,暂时不清楚!!!!!!!
    	char val;
    	printf("是否需要增添值?(Y/N):");				//判断用户是否需要添加新值
    	scanf("%c", &val);
    	if (val == 'N' || val == 'n')						//如果是'Y'或'y'即继续执行,若是'N'或'n'则返回主函数
    	return 0;
    
    	printf("\n");
    	*/
    
    	printf("请输入你要插入的位置:");
    	scanf("%d", &i);													//输入插入的位置
    	printf("请输入你要插入的值为:");
    	scanf("%d", &j);													//输入插入的值
    
    	while (i < 1 || i > L->length)										//插入的值不合法,就重新输入
    	{
    		printf("你输入的值不合法,请重新输入:\n");
    		printf("请输入你要插入的位置:");
    		scanf("%d", &i);
    	}
    
    	if (L->length >= L->list_size)														//如果线性表L的当前长度大于了线性表L的容量
    	{
    		int * new1;
    
    		new1 = (int *)realloc(L->elem, (L->length + List_appreciation) * sizeof(int));	//重新分配L->elem的存储空间并临时用new1指向
    		if (!new1)																		//如果分配失败
    		{
    			printf("赋值时容量不够,进行增值分配但分配失败请检查程序!\n");				//显示错误,用于方便查找位置
    			exit(1);																	//非正常退出程序,终止程序
    		}
    
    		L->elem = new1;																	//将new1内的地址发送给L->elem使线性表L指向新分配的空间
    		L->list_size = L->length + List_appreciation;									//记录容量
    
    		printf("\n本次插入,已经超过了原有存储容量,现已增加容量\n");					//提示用户增值的操作
    	}
    
    	for (e = L->length;i <= e;e--)										//从线性表L最后一个元素开始依次往后移动,直到i的位置空出来
    		L->elem[e + 1] = L->elem[e];									//将线性表L的最后一个元素向后移动
    
    	L->elem[i] = j;														//将需要插入的值j插入到指定位置i
    	L->length++;														//记录长度
    
    	printf("插入成功,线性表内的元素为:");
    
    	for (k = 1;k <= L->length;k++)										//依次打印插值后的线性表L的各个元素
    		printf("%d ", L->elem[k]);										//打印
    	printf("\n");
    }
    
    void List_drop(Sqlist *L)	 											//线性表的删除(删除)
    {
    	int i = 0, j, t, k;
    
    	/*													//这个判断有问题,暂时不清楚!!!!!!!
    	char val;
    	printf("是否需要删除值?(Y/N):");				//判断用户是否需要添加新值
    	scanf("%c", &val);
    	if (val == 'N' || val == 'n')						//如果是'Y'或'y'即继续执行,若是'N'或'n'则返回主函数
    	return 0;
    
    	printf("\n");
    	*/
    
    	printf("请输入你要删除的值:");
    	scanf("%d", &j);
    
    	printf("删除成功,你删除的值是:%d\n", L->elem[j]);
    
    	for (;i <= L->length;i++)
    		if (L->elem[i] == j)
    		{
    			L->elem[i] = NULL;
    			k = i;
    		}
    	for (;k <= L->length;k++)											//将删除的位置的下一位依次往前移动
    		L->elem[k] = L->elem[k + 1];
    	L->length--;														//记录当前线性表的长度
    
    	printf("删除后的线性表的值为:");
    	for (t = 1;t <= L->length;t++)										//依次输出删除后线性表L的各个元素
    		printf("%d ", L->elem[t]);
    	printf("\n");
    }
    
    void List_change(Sqlist *L)												//线性表的更改(改)
    {
    	int i = 0, j, t, m;
    
    	/*														//这个判断有问题,暂时不清楚!!!!!!!
    	char val;
    	printf("是否需要更改值?(Y/N):");					//判断用户是否需要添加新值
    	scanf("%c", &val);
    	if (val == 'N' || val == 'n')							//如果是'Y'或'y'即继续执行,若是'N'或'n'则返回主函数
    	return 0;
    
    	printf("\n");
    	*/
    
    	printf("输入更改的位置:");
    	scanf("%d", &j);												//输入要改的值
    	printf("输入要更改成的值:");
    	scanf("%d", &t);												//输入要改的位置
    
    	while (j < 0 && j > L->length)									//判断改的位置是否有误
    	{
    		printf("改的位置有误,请重新输入改的位置:");
    		scanf("%d", &j);
    	}
    
    	L->elem[j] = t;													//将需要改的位置上的元素改为j
    
    	for (m = 1;m <= L->length;m++)									//打印输出
    		printf("%d ", L->elem[m]);
    	printf("\n");
    }
    
    void List_examine(Sqlist *L)										//线性表的查找(查)
    {
    	int i, j;
    
    	/*													//这个判断有问题,暂时不清楚!!!!!!!
    	char val;
    	printf("是否需要增添值?(Y/N):");				//判断用户是否需要添加新值
    	scanf("%c", &val);
    	if (val == 'N' || val == 'n')						//如果是'Y'或'y'即继续执行,若是'N'或'n'则返回主函数
    	return 0;
    
    	printf("\n");
    	*/
    
    	printf("请输入你要查找的值:");
    	scanf("%d", &i);
    
    	for (j = 1;j <= L->length;j++)
    		if (i == L->elem[j])
    			printf("查找值为:%d,它的位置是:%d\n", i, j);
    }
    
    int main(void)										//主函数
    {
    	Sqlist L;
    
    	List_initialize(&L);							//线性表L的初始化
    	List_The_default_value(&L);						//线性表L的默认赋值
    
    	printf("完全初始化线性表结束,顺序线性表(增删改查)功能开始:\n\n\n");
    
    	List_insert(&L);								//线性表的插入(增)
    	List_drop(&L);									//线性表的删除(删)(删除在表中符合指定的值)
    	List_examine(&L);								//线性表的查找(查)
    	List_change(&L);								//线性表的更改(改)
    
    	return 0;
    }
    

    我对于一些代码的理解不是很透彻,就像该文章所一样的,被我打上注释的那串代码,我想着用户可以自己选择是否使用该功能,可是很奇怪,会有问题,第一个模块的询问是正常的当第二个模块再次询问时就直接跳过,这个程序是2星期前敲的,我现在也无法理解。

    我能是一名中职生16岁,很遗憾当时没好好学,不过现在是真的很想提升自己了,我想考本考研不仅仅是对我的改变更多是我可以但我不想在把自己葬送在手上,环境,师资,资源等其实我几乎都没有,几乎是自己一个人慢慢的接受和习惯了,我每天的学习时间是14小时左右,以后也不会变,这篇博客是我成长的开始

    我已经正式接触软件编程有8个月了吧,我一开始学习的是HTML/CSS/JavaScript,后来遇见了一个很好的指导老师,于是我转向了后端,

    C语言学习了4个月,我大致算了一下,1360个小时左右因为每天几乎都是除了吃饭睡觉就是学习这一门,学完后老师让我学习数据结构,一开始我看的是大话数据结构,1个月左右,大致300小时,我理解了框架和步骤,但不是很熟练,然后老师让我在学习C语言,我买了谭浩强的第五版C语言学习把书上的代码和习题全敲了一遍,后来又不看书去敲了一遍,查漏补缺了很多。

    花了很长2个月把,然后老师让我休息,我其实觉得提升自己是一件很有激情的事情,我很乐意也很愿意,与其说休息这就是我自己的休息方式。

    放寒假之前一个月我开始学习MYSQL,一直到现在我的计划主要是这样的且一直有条有序的执行着:

    6:00-7:00 是 补习理论知识(计算机组装,计算机网络这些知识一本一本的学)
    7:00-10:00 是 MYSQL;
    10:00-13:00 是 C++;
    14:00 - 16:30 是 C语言的细读理解每一句话
    16:00-18:30 是数据结构严蔚敏的
    一直到0:00是补习我的数学和英语

    链表的一些也打了,有时间就记录发,

    我的目前主要方向是C/C++,学习理解好后,大专开始专攻互联网网站Java web等技术不断扩展,学习前端,后端,数据库,框架,UI设计等等都会涉及且对我有用的会重点学习,我一直坚信T型发展才是我的路。

    但是,我也很迷茫,我不知道我应该怎样的系统的规划和路线去学习Java等后面的路线。但是,我不会停下!我热爱且不止于热爱~

    且剩余时间我学习了吉他,钢琴~
    元月底会有演出,虽然是内部的但也证明我不是空谈

    以下是目前为止记录的学习时间:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    我发这些也许会说我掺水了,但事实胜于雄辩,我每次的记录都会记录我的成长,而如何要达到的程度我想我的一切都在表里了~

    谢谢观看我的第一篇博客~

    再次感谢

    展开全文
  • 数据结构-C语言实现线性表 SqList.h头文件 /*文件名:SqList.h*/ #include <stdio.h> #include <stdlib.h> //函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define ...

    数据结构-C语言实现线性表

    • SqList.h头文件
    /*文件名:SqList.h*/
    #include <stdio.h>
    #include <stdlib.h>
    //函数结果状态代码
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    #define INFEASIBLE -1
    #define OVERFLOW -2
    //定义函数返回的类型
    typedef int Status;
    
    #define LIST_INIT_SIZE 100  //线性表存储空间的初始分配量
    #define LISTINCREMENT 10    //线性表存储空间的分配增量
    typedef char ElemType;   //定义数据元素的类型为字符型
    typedef struct {
    	ElemType *elem;
    	int length;
    	int listsize;
    } SqList;    //定义顺序表的存储结构
    
    Status InitList(SqList &L) {
    	L.elem=(ElemType *)malloc(LIST_INIT_SIZE *sizeof(ElemType ));
    	if(!L.elem ) {
    		exit(OVERFLOW);
    	}
    	L.length = 0;
    	L.listsize = LIST_INIT_SIZE;
    	return OK;
    }
    //销毁顺序表L
    void DestroyList(SqList &L) {
    	free(L.elem);
    }
    //判断顺序表L是否为空,为空返回true,否则返回false
    Status ListEmpty(SqList L) {
    	if(L.length == 0)
    		return TRUE;
    	else
    		return FALSE ;
    }
    //返回顺序表L的长度
    int ListLength(SqList L) {
    	return L.length ;
    }
    //打印顺序表中的元素
    void DispList(SqList L) {
    	for(int g=0; g<L.length; g++) {
    		printf("%c ",L.elem[g]);
    	}
    }
    //从顺序表L中查找第i个元素,由参数e返回其元素的值
    Status GetElem(SqList L,int i,ElemType &e) {
    	if(i<1 || i>L.length ) {
    		return ERROR;
    	}else {
    		return e = L.elem[i-1];
    	}
    	return OK;
    }
    //在顺序表L中查找元素e的位置,不存在则返回0
    int LocateElem(SqList L, ElemType e) {
    	int i;
    	for(i=0; i<(L.length-1); i++) {
    		if(e==L.elem [i]){
    			return i+1;
    		}
    	}
    	return 0;	
    }
    
    
    //在顺序表L的第i个位置之前插入元素e
    Status ListInsert(SqList &L,int i,ElemType e) {
    	ElemType *p,*q;
    	if(i<1||i>L.length+1) {
    		return ERROR;
    	}
    		
    	if(L.length == L.listsize ){
    		L.elem = (ElemType*)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType));	
    		L.listsize += LISTINCREMENT ;
    	}
    	q = &(L.elem[i-1]);
    	for(p = &(L.elem[L.length -1]); p>=q; p--) {
    		*(p+1) = *p;
    	}
    	*(q) = e;
    	L.length++;
    	
    	return OK;
    }
    
    Status ListInsert_test(SqList &L, ElemType e) {
    	
    	if(L.length == L.listsize ){
    		L.elem = (ElemType*)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof(ElemType));	
    		L.listsize += LISTINCREMENT ;
    	}
    	int i;
    	for (i=0; i<L.length;i++) {
    		if (e<L.elem[i]) {
    			break;
    		}
    	}
    	int j = L.length;
    	while (j>=i) {
    		L.elem[j] = L.elem[j-1];
    		j--;
    	}
    	L.elem[i] = e;
    	L.length++;
    	return OK;
    }
    
    
    
    //删除顺序表L中第i个元素,由e返回删除的元素值
    Status ListDelete(SqList &L,int i,ElemType &e) {
    	if((i<1)||(i>L.length)) {
    		return ERROR;
    	}
    	ElemType* p = &(L.elem[i-1]);
    	e = *p;
    	ElemType* q = L.elem+L.length-1;
    	for(;p<=q;p++) {
    		*(p) = *(p+1);
    	}
    	L.length--;
    	return OK;
    }
    
    Status DeleteK(SqList &a,int i,int k) {
    //本过程从顺序表a中删除第i个元素起的k个元素
    	if(i<1 || k<0 || i+k>a.length) 
    		return INFEASIBLE;  //参数不合法
    	else {
    		int t = a.length-i-k+1;
    		for(int count=0; count<k; count++) {
    		//删除一个元素
    			for(int j=t; j>0; j--) {
    				a.elem[a.length-j-1]=a.elem[a.length-j];
    			}
    			a.length--;
    		}
    	}
    	return OK;
    }
    
    
    
    • exp主程序
    #include "SqList.h"
    int main() {
    	SqList L;
    	ElemType e;
    	printf("(1)初始化顺序表L\n");
    	InitList(L);
    	printf("(2)依次采用尾插法插入a,b,c,d,e元素\n");
    	ListInsert(L,1,'a');
    	ListInsert(L,2,'b');
    	ListInsert(L,3,'c');
    	ListInsert(L,4,'d');
    	ListInsert(L,5,'e');
    	ListInsert(L,6,'f');
    	printf("(3)输出顺序表L:");
    	DispList(L);
    	printf("\n");
    	printf("(4)顺序表L长度=%d\n",ListLength(L));
    	printf("(5)顺序表L为%s\n",(ListEmpty(L)?"空":"非空"));
    	GetElem(L,3,e);
    	printf("(6)顺序表L的第3个元素=%c\n",e);
    	printf("(7)元素a的位置=%d\n",LocateElem(L,'a'));
    	printf("(8)在第4个元素位置上插入f元素\n");
    	printf("(9)输出顺序表L:");
    	DispList(L);
    	printf("\n");
    	DispList(L);
    	printf("\n");
    	DeleteK(L, 2, 3);
    	DispList(L);
    	printf("\n");
    	printf("(10)删除L的第3个元素\n");
    	ListDelete(L,3,e);
    	printf("(11)输出顺序表L:");
    	DispList(L);
    	printf("\n");
    	printf("(12)释放顺序表L\n");
    	DestroyList(L);
    	return 0;
    }
    
    • 执行结果

    image-20201215150024205

    展开全文
  • 数据结构C语言版线性表之顺序存储 个人的学习笔记,如有不合理之处欢迎指正,谢谢! 自己写的代码

    数据结构C语言版:线性表之顺序存储

    个人的学习笔记,如有不合理之处欢迎指正,谢谢!

    自己写的代码(我只写了主要的插入、删除、遍历三种操作的代码,其他操作实现起来很简单我就没写)

    #include<stdio.h>
    
    #define MaxSize 10
    
    typedef struct {
    	int data[MaxSize];
    	int length;
    }SqList;
    
    // 初始化顺序表
    SqList* InitList(SqList* L) {
    	printf("此表为顺序表,最大可容纳10个数!\n");
    	L = (SqList*)malloc(sizeof(SqList));
    	L->length = 0;
    	int dat;
    	printf("请输入你的第%d个数据(输入0结束):", L->length + 1);
    	scanf("%d", &dat);
    	while (dat) {
    		if (FullList(L)) {
    			printf("空间不足,已自动退出!\n");
    			break;
    		}
    		L->data[L->length] = dat;
    		L->length++;
    		printf("请输入你的第%d个数据(输入0结束):",L->length + 1);
    		scanf("%d", &dat);
    	}
    	return L;
    }
    
    // 插入元素
    int InsertList(SqList* L, int i, int e) {
    	if (FullList(L)) {
    		printf("空间不足,已自动退出!\n");
    		return;
    	}
    	if (i < 1 || i > L->length + 1) {
    		printf("插入的位置有误!\n");
    		return;
    	}
    	for (int l = L->length - 1; l > i-2; l--) {
    		L->data[l + 1] = L->data[l];
    	}
    	L->data[i - 1] = e;
    	L->length++;
    	return;
    }
    
    // 删除元素
    int DeleteList(SqList* L, int i) {
    	if (EmptyList(L)) {
    		printf("L是空表,不可删除元素!\n");
    		return;
    	}
    	if (i < 1 || i > L->length) {
    		printf("删除的位置有误!\n");
    		return;
    	}
    	for (int l = i - 1; l < L->length -1; l++) {
    		L->data[l] = L->data[l + 1];
    	}
    	L->length--;
    }
    
    // 判断顺序表是否为空
    int EmptyList(SqList* L) {
    	return L->length == 0;
    }
    
    // 判断顺序表是否为满
    int FullList(SqList* L) {
    	return L->length == MaxSize;
    }
    
    // 遍历顺序表
    int TraverseList(SqList* L) {
    	if (EmptyList(L)) {
    		printf("L是空表,不需要遍历!\n");
    		return;
    	}
    	for (int i = 0; i < L->length; i++) {
    		printf("%d ", L->data[i]);
    	}
    	putchar('\n');
    }
    
    int main() {
    	SqList* L = NULL;
    	int select, i, e;
    	L = InitList(L);
    	while (1) {
    		printf("1、插入元素 2、删除元素 3、遍历输出 4、退出程序\n");
    		printf("请输入你要进行的操作:");
    		scanf("%d", &select);
    		if (select == 1) {
    			printf("请输入你要插入的位置:");
    			scanf("%d", &i);
    			printf("请输入你要插入的元素:");
    			scanf("%d", &e);
    			InsertList(L, i, e);
    		}
    		else if (select == 2) {
    			printf("请输入你要删除的位置:");
    			scanf("%d", &i);
    			DeleteList(L, i);
    		}
    		else if (select == 3) {
    			TraverseList(L);
    		}
    		else {
    			break;
    		}
    	}
    }
    

    代码其二

    #include<stdio.h>
    #include<stdlib.h>
    
    // 函数结果状态代码
    #define TRUE 1
    #define FALSE 0
    #define OK 1
    #define ERROR 0
    #define INFEASIBLE -1
    #define OVERFLOW -2 // 溢出时使用
    #define MAXSIZE 100
    
    // Status是函数的类型,其值是函数结果的状态代码
    typedef int Status;
    typedef char ElemType;
    
    typedef struct {
    	ElemType *elem; // 定义指针(数组)类型变量
    	int length;
    }SqList;
    
    // 线性表L的初始化(参数用引用类型,未使用指针)
    Status InitList(SqList &L) {
    	// 使用new关键字为指针动态分配空间
    //	L.elem = new ElemType[MAXSIZE];
    	// 也可以这样
    	L.elem = (ElemType *)malloc(sizeof(ElemType) * MAXSIZE);
    	if (!L.elem) { // 存储空间分配失败
    		exit(OVERFLOW); // 函数头文件在stdlib.h里面
    	}
    	L.length = 0;
    	return OK;
    }
    
    // 1.销毁线性表
    void DestroyList(SqList &L) {
    	if (L.elem) {
    		delete L.elem; // 使用delete关键字(参数为指针)释放存储空间
    		printf("线性表已销毁!程序已退出!\n");
    	}
    }
    
    // 2.清空线性表
    void ClearList(SqList &L) {
    	L.length = 0; // 将线性表长度设置为0
    	printf("线性表已清空!\n");
    }
    
    // 3.求线性表的长度
    int GetLength(SqList L) {
    	return L.length; // 返回线性表的长度
    }
    
    // 4.判断线性表是否为空
    int IsEmpty(SqList L) {
    	if (L.length == 0) {
    		printf("线性表为空!\n");
    		return 1;
    	}
    	else {
    		printf("线性表不为空!\n");
    		return 0;
    	}
    }
    
    // 5.顺序表的取值
    int GetElem(SqList L, int i, ElemType &e) {
    	if (i < 1 || i > L.length) { // 判断i值是否合理
    		printf("下标越界!\n");
    		return ERROR;
    	}
    	e = L.elem[i - 1];
    	printf("取值成功!\n");
    	return OK;
    }
    
    //6.顺序表的查找
    int LocateElem(SqList L, ElemType e) {
    	// 在线性表中查找值为e的数据元素,返回其序号
    	for (int i = 0; i < L.length; i++) {
    		if (e == L.elem[i]) {
    			printf("查找成功!\n");
    			return i + 1; // 查找成功
    		}
    	}
    	printf("查找失败!\n");
    	return 0; // 查找失败,返回0
    }
    
    // 7.顺序表的插入
    Status ListInsert(SqList &L, int i, ElemType e) {
    	if (i<1 || i>L.length + 1) {
    		printf("下标越界!\n");
    		return ERROR; // i值不合法
    	}
    	if (L.length == MAXSIZE) {
    		printf("当前存储空间已满!\n");
    		return ERROR;// 当前存储空间已满
    	}
    	for (int j = L.length - 1; j >= i - 1; j--) {
    		// 插入位置以及之后的元素后移
    		L.elem[j + 1] = L.elem[j];
    	}
    	// 赋值
    	L.elem[i - 1] = e;
    	// 表长加1
    	L.length++;
    	printf("插入元素成功!\n");
    	return OK;
    }
    
    // 8.顺序表的删除
    Status ListDelete(SqList &L, int i) {
    	if (i < 1 || i > L.length) {
    		printf("下标越界!\n");
    		return ERROR;
    	}
    	for (int j = i; j <= L.length - 1; j++) {
    		L.elem[j - 1] = L.elem[j];
    	}
    	L.length--;
    	printf("删除元素成功!\n");
    	return OK;
    }
    
    // 9.遍历输出
    void ListTraverse(SqList &L) {
    	printf("线性表的元素值为:\n");
    	for (int i = 0; i < L.length; i++) {
    		printf("%c ",L.elem[i]);
    	}
    	putchar('\n');
    }
    
    // 主函数
    void main() {
    	SqList L;
    	InitList(L);
    	int i = 0, signal;
    	ElemType data;
    	printf("请输入线性表的初始元素,输入enter表示输入结束:\n");
    	scanf("%c",&data);
    	while (data != '\n') {
    		if (data != ' ') {
    			L.elem[i++] = data;
    			L.length++;
    		}
    		scanf("%c", &data);
    	}
    	while (1) {
    		printf("---------------------------------\n");
    		printf("+  1.DestroyList   2.ClearList  +\n");
    		printf("+  3.GetLength     4.IsEmpty    +\n");
    		printf("+  5.GetElem       6.LocateElem +\n");
    		printf("+  7.ListInsert    8.ListDelete +\n");
    		printf("+  9.ListTraverse  10.End       +\n");
    		printf("---------------------------------\n");
    		printf("请输入您要进行的操作:");	
    		scanf("%d",&signal);
    		if (signal == 1) {
    			DestroyList(L);
    			break; // 销毁后自动退出
    		}
    		if (signal == 2) {
    			ClearList(L);
    		}
    		if (signal == 3) {
    			printf("线性表的长度为:%d\n", GetLength(L));
    		}
    		if (signal == 4) {
    			IsEmpty(L);
    		}
    		if (signal == 5) {
    			ElemType e;
    			printf("请输入要获得的元素下标:");
    			scanf("%d", &i);
    			if (GetElem(L, i, e) != 0) {
    				printf("%d位置上的元素值为:%c\n", i, e);
    			}
    		}
    		if (signal == 6) {
    			ElemType e;
    			printf("请输入要查找的元素:");
    			getchar(); // 在选择6操作的时候按了回车,所以要接收回车
    			scanf("%c", &e);
    			getchar();
    			i = LocateElem(L, e);
    			if (i != 0) {
    				printf("%c元素的位置为:%d\n", e, i);
    			}
    		}
    		if (signal == 7) {
    			ElemType e;
    			printf("请输入要插入的元素位置和元素:");
    			scanf("%d", &i);
    			getchar();
    			scanf("%c", &e);
    			getchar();
    			if (ListInsert(L, i, e) != 0) {
    				printf("%d位置上的元素值为:%c\n", i, e);
    			}
    		}
    		if (signal == 8) {
    			printf("请输入要删除的元素位置:");
    			scanf("%d", &i);
    			ListDelete(L, i);
    		}
    		if (signal == 9) {
    			ListTraverse(L);
    		}
    		if (signal == 10) {
    			printf("程序已退出!\n");
    			break;
    		}
    	}
    }
    
    展开全文
  • 数据结构C语言版线性表之静态链表 个人的学习笔记,如有不合理之处欢迎指正,谢谢! 自己写的代码(我本人觉得只有插入、删除有一丢丢复杂,所以只写了这两种操作的代码) #include<stdio.h> #define ...

    数据结构C语言版:线性表之静态链表

    个人的学习笔记,如有不合理之处欢迎指正,谢谢!

    自己写的代码(我只写了主要的插入、删除、遍历三种操作的代码,其他操作实现起来很简单我就没写)

    #include<stdio.h>
    
    #define MaxSize 10
    
    typedef struct Node{
    	int data;
    	int cur; // 游标
    }SLList[MaxSize];
     
    // 初始化静态链表
    int InitList(SLList L) {
    	for (int l = 0; l < MaxSize - 1; l++) {
    		L[l].cur = l + 1;
    	}
    	L[MaxSize - 1].cur = 0;
    }
    
    // 插入元素
    int InsertList(SLList L, int i, int e) {
    	if (FullList(L)) {
    		printf("静态链表为满!");
    		return;
    	}
    	if (i<1 || i> LengthList(L) + 1) {
    		printf("插入的位置有误!");
    		return;
    	}
    
    	int n = Malloc(L); // 获取空闲元素的下标
    	int temp = MaxSize - 1; // 定义一个临时变量用于遍历
    
    	for (int l = 1; l < i; l++) { // 从头开始遍历
    		temp = L[temp].cur; // 根据游标一个一个遍历
    	}
    
    	L[n].data = e; // 赋值
    	L[n].cur = L[temp].cur; // 将n的上一个元素的游标给n的游标
    	L[temp].cur = n; // 将n给它上一个元素的游标
    }
    
    // 删除元素
    int DeleteList(SLList L, int i) {
    	if (EmptyList(L)) {
    		printf("静态链表为空!");
    		return;
    	}
    	if (i < 1 || i > LengthList(L)) {
    		printf("删除位置有误!");
    	}
    
    	int temp = MaxSize - 1; // 定义一个临时变量用于遍历
    	for (int l = 1; l < i; l++) { // 从头开始遍历
    		temp = L[temp].cur; // 根据游标一个一个遍历
    	}
    	int l = L[temp].cur; // 定义一个临时变量用于存temp的下一个元素
    	L[temp].cur = L[l].cur; // 将temp的下下个元素的下标给temp的游标
    	L[l].cur = L[0].cur; // 将下标0的游标给已删除的l的游标
    	L[0].cur = l; // 重新构成空闲链表
    }
    
    // 寻找空闲下标
    int Malloc(SLList L) {
    	int index = L[0].cur;
    	if (L[0].cur) {
    		L[0].cur = L[index].cur;
    	}
    	return index;
    }
    
    // 静态链表的长度
    int LengthList(SLList L) {
    	int temp = L[MaxSize - 1].cur; // 获取静态链表的的首位置
    	int count = 0; // 定义一个计数器
    	while (temp) {
    		temp = L[temp].cur;
    		count++;
    	}
    	return count;
    }
    
    // 判断是否为空
    int EmptyList(SLList L) {
    	return L[MaxSize - 1].cur == 0;
    }
    
    // 判断是否为满
    int FullList(SLList L) {
    	return L[0].cur == MaxSize - 2;
    }
    
    // 遍历输出
    int TraverseList(SLList L) {
    	int temp = L[MaxSize - 1].cur; // 获取静态链表的的首位置
    	while (temp) {
    		printf("%d ", L[temp].data);
    		temp = L[temp].cur;
    	}
    	putchar('\n');
    }
    
    int main() {
    	SLList L;
    	InitList(L); // 初始化
    	int select, i, e;
    	while (1) {
    		printf("1、插入元素 2、删除元素 3、遍历输出 4、退出程序\n");
    		printf("请输入你要进行的操作:");
    		scanf("%d", &select);
    		if (select == 1) {
    			printf("请输入你要插入的位置:");
    			scanf("%d", &i);
    			printf("请输入你要插入的元素:");
    			scanf("%d", &e);
    			InsertList(L, i, e);
    		}
    		else if (select == 2) {
    			printf("请输入你要删除的位置:");
    			scanf("%d", &i);
    			DeleteList(L, i);
    		}
    		else if (select == 3) {
    			TraverseList(L);
    		}
    		else {
    			break;
    		}
    	}
    }
    
    展开全文
  • 数据结构C语言版线性表之链式存储 个人的学习笔记,如有不合理之处欢迎指正,谢谢! 自己写的代码(我本人觉得只有插入、删除有一丢丢复杂,所以只写了这两种操作的代码) #include<stdio.h> typedef ...
  • 数据结构C语言版线性表之双链表 个人的学习笔记,如有不合理之处欢迎指正,谢谢! 自己写的代码(我本人觉得只有插入、删除有一丢丢复杂,所以只写了这两种操作的代码) #include<stdio.h> typedef struct ...
  • 数据结构C语言版线性表之循环链表 个人的学习笔记,如有不合理之处欢迎指正,谢谢! 自己写的代码(我本人觉得只有插入、删除有一丢丢复杂,所以只写了这两种操作的代码) #include<stdio.h> typedef ...
  • 数据结构C语言版线性表之双循环链表 个人的学习笔记,如有不合理之处欢迎指正,谢谢! 自己写的代码(我本人觉得只有插入、删除有一丢丢复杂,所以只写了这两种操作的代码) #include<stdio.h> typedef ...
  • 数据结构严蔚敏C语言版线性表顺序存储结构(顺序表)C语言实现相关代码1.运行环境2.准备工作1)项目构建1>新建一个SeqList项目2>新建两个文件Sources和Headers3>新建两个C/C++ source和一个C/C++ header2...
  • 原理是申请一段连续的内存空间,对这段内存空间进行相关操作实现基本的功能,大致实现了数据结构C语言版第二章顺序线性表的所有功能和算法,代码如下 #include"stdio.h" #include"stdlib.h" #define OVERFLOW 0 #...
  • 数据结构清华C++代码合集(1)队列_顺序队列队列_顺序循环队列队列_链队列队列_循环队列线性表应用_集合操作1线性表应用_集合操作2线性表应用_一元多项式线性表_顺序表线性表_顺序表(数组)线性表_链表线性表_循环...
  • 数据结构C/C++课程代码 所有案例引入代码 线性表、栈与队列、串、数组和广义表 树和二叉树、图 查找与排序
  • 数据结构线性表的顺序存储结构c语言版 顺序表的创建,输入,输出,插入,删除,按值查找,按位查找操作 C代码 #include<stdio.h> #define Maxsize 50 typedef int ElemType; typedef struct{ ElemType data...
  • 数据结构线性表的链式存储结构c语言版 链表的头插法创建,尾插法创建,输入,输出,插入,删除,按值查找,按位查找,删除,销毁操作 C代码 #include<stdio.h> #include<stdlib.h> typedef int ElemType...
  • 写完线性表实验代码后,有些错误 不会调试 求大神帮帮忙! ps.错误截图:[图片说明](https://img-ask.csdn.net/upload/201509/26/1443267795_67072.png) 代码: #include #include #include #define LIST_INIT_SIZE ...
  • 从今天开始不定时更新关于《数据结构C语言版-严蔚敏》这本书中代码的C语言实现,有错的地方可以发出来hhh 谢谢大家!! 线性表的顺序表示和实现 本篇博客先放上线性表的: 构建:InitList_Sq(&L) 插入:List...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 167
精华内容 66
关键字:

数据结构c语言版线性表代码

c语言 订阅
数据结构 订阅