这里使用的工具是DEV C++

可以借鉴一下

一、实训名称
线性表的基本操作

二、实训目的
1.掌握线性表的基本概念
2.掌握线性表的存储结构(顺序存储与链式存储)
3.掌握线性表的基本操作

三、实训要求
1.线性表可以顺序表也可以用单链表实现,鼓励大家用两种方式实现。
2.创建线性表时,数据从键盘输入整形数据
3.线性表类型定义和或各种操作的实现,可以用教材给出的方法,也可以自己设计。

实现效果

顺序存储代码实现

源码

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #define MAX 20
  4. #define LISTINCREMENT 10
  5. typedef struct{
  6. int *elem;
  7. int length;
  8. int listsize;
  9. }sqlist;
  10. void Creatlist(sqlist &L){
  11. //创建一个线性表
  12. L.elem=(int *)malloc(MAX*sizeof(int)) ;
  13. if(!L.elem)return ;
  14. L.listsize=MAX;
  15. printf("输入表的长度:");
  16. scanf("%d",&L.length);
  17. printf("输入%d的个数:",L.length);
  18. for(int i=0;i<L.length;i++)
  19. scanf("%d",&L.elem[i]);
  20. }
  21. //开始添加取地址符号
  22. void Traverse(sqlist &L){
  23. //遍历
  24. printf("表中数据为:") ;
  25. for(int i=0;i<L.length;i++)
  26. printf("%3d",L.elem[i]) ;
  27. printf("\n");
  28. }
  29. //查找
  30. void LocateElem(sqlist &L,int e){
  31. int i;
  32. printf("输入要查找的元素:\n");
  33. scanf("%d",&e);
  34. for(int i=0;i<L.length;i++)
  35. {
  36. if(L.elem[i]==e){
  37. printf("查找成功,查找元素为%d",L.elem[i]);
  38. printf("\n");
  39. return ;
  40. }//if
  41. } //for
  42. printf("查找失败!");
  43. printf("\n");
  44. }//void
  45. //确定要删除的元素
  46. int makesureElem(sqlist &L,int e){
  47. int i;
  48. for(i=0;i<L.length;i++){
  49. if(L.elem[i]==e){
  50. printf("要删除的元素 位置为%d",i+1);
  51. printf("\n");
  52. return (i+1);
  53. }//if
  54. } //for
  55. printf("元素不存在!");
  56. printf("\n");
  57. return 0;
  58. }
  59. //插入某个元素
  60. void Listinsert(sqlist &L){
  61. int i;int e;
  62. printf("输入要插入位置及元素\n");
  63. scanf("%d%d",&i,&e);
  64. printf("在顺序线性表中第%d个位置之前插入新的元素%d。\n",i,e);
  65. //在顺序线性表L中第i个位置之前插入新的元素e
  66. if(i<1||i>L.length+1)return;
  67. // 1<=i<=listlength(L)+1;
  68. int *p,*q;
  69. q=&(L.elem[i-1]);
  70. for(p=&(L.elem[L.length-1]);p>=q;--p)*(p+1)=*p;
  71. *q=e;
  72. ++L.length;
  73. return;
  74. }
  75. int listdelete(sqlist &L){
  76. //删除元素
  77. int i,e;
  78. printf("输入要删除的元素\n");
  79. scanf("%d",&e);
  80. i=makesureElem(L,e);
  81. if((i<1)||(i>L.length))return 0;
  82. else{
  83. int *p,*q;
  84. p=&(L.elem[i-1]);
  85. e=*p;
  86. q=L.elem+L.length-1;
  87. for(++p;p<=q;++p)*(p-1)=*p;//被删除元素之后的元素左移
  88. -L.length;
  89. printf("元素被删除!");
  90. }
  91. return 0;
  92. }
  93. int main(){
  94. sqlist L;
  95. Creatlist(L);
  96. Traverse(L);
  97. LocateElem(L,1);
  98. Listinsert(L);
  99. Traverse(L);;
  100. listdelete(L);
  101. Traverse(L);
  102. return 0;
  103. }

链式存储存储实现

源码

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <malloc.h>
  4. struct danlianbiao_Node{
  5. int data;
  6. struct danlianbiao_Node *next;
  7. };
  8. //base的结构体
  9. struct danlianbiao{
  10. int length;
  11. struct danlianbiao_Node *base;
  12. };
  13. struct danlianbiao *danlianbiao_init();
  14. void danlianbiao_free(struct danlianbiao *list);
  15. //清除
  16. void danlianbiao_clear(struct danlianbiao *list);
  17. int danlianbiao_length(struct danlianbiao *list);
  18. //添加
  19. void danlianbiao_add(struct danlianbiao *list,int index,int value);
  20. void danlianbiao_remove(struct danlianbiao *list,int index);
  21. //修改
  22. void danlianbiao_set(struct danlianbiao *list,int index,int value);
  23. int danlianbiao_get(struct danlianbiao *list,int index );
  24. //查询
  25. int danlianbiao_lookup(struct danlianbiao *list,int value);
  26. int danlianbiao_isempty(struct danlianbiao *list,int value);
  27. void menu()
  28. {
  29. printf("********目录*******\n");
  30. printf("输出单链表中的各元素值1\n");
  31. printf("在单链表中插入数据元素2\n");
  32. printf("在单链表中插入数据元素3\n");
  33. printf("寻找单链表中某一个数值4\n");
  34. printf("结束程序 0\n");
  35. printf("**********************************\n");
  36. }
  37. int main(int argc, char *argv[]) {
  38. int n,m,i,e;
  39. printf("请输入元素的个数 :");
  40. scanf("%d",&n);
  41. printf("以此输入%d个数据元素 :",n);
  42. menu();
  43. printf("输入你的选择:");
  44. scanf("%d",&m);
  45. switch(m)
  46. {
  47. case 1:
  48. printf("现在链表的元素为:");
  49. break;
  50. case 2:
  51. printf("依次输入插入位置和数据元素(空格隔开):");
  52. scanf("%d %d",&i,&e);
  53. }
  54. return 0;
  55. }
  56. struct danlianbiao *danlianbiao_init(){
  57. struct danlianbiao *list=NULL;
  58. list=( struct danlianbiao *)malloc(sizeof( struct danlianbiao ));
  59. list->base=(struct danlianbiao_Node *)malloc(sizeof(struct danlianbiao_Node));
  60. list->base->data=-1;
  61. list->base->next=NULL;
  62. list->length=0;
  63. return list;
  64. }
  65. void danlianbiao_free(struct danlianbiao *list){
  66. struct danlianbiao_Node *pnode=NULL;//可能出现问题指针
  67. while(list->base!=NULL){
  68. pnode=list->base;
  69. list->base=pnode->next;
  70. free(pnode);
  71. }//while
  72. free(list);
  73. }
  74. //清除
  75. void danlianbiao_clear(struct danlianbiao *list){
  76. struct danlianbiao_Node *next=NULL;//可能出现问题指针
  77. struct danlianbiao_Node *pnode=NULL;
  78. while(list->base->next!=NULL){
  79. next=list->base->next;
  80. list->base->next=next->next;
  81. free(pnode);
  82. }//while
  83. list->length=0;
  84. }
  85. //获得单链表的长度
  86. int danlianbiao_length(struct danlianbiao *list){
  87. }
  88. //添加 ,该函数没有错误
  89. void danlianbiao_add(struct danlianbiao *list,int index,int value){
  90. int i=0;
  91. struct danlianbiao_Node *pnode=NULL;
  92. struct danlianbiao_Node *p=NULL;
  93. p=(struct danlianbiao_Node *)malloc(sizeof(struct danlianbiao_Node ));
  94. p->data=value;
  95. pnode=list->base;
  96. while(i<index-1&&pnode!=NULL){
  97. pnode=pnode->next;
  98. i++;
  99. }//while
  100. p->next=pnode->next;
  101. pnode->next=p;
  102. list->length++;
  103. }
  104. //
  105. //移除这一项没有错误
  106. void danlianbiao_remove(struct danlianbiao *list,int index){
  107. struct danlianbiao_Node *pnode=NULL;
  108. struct danlianbiao_Node *p=NULL;
  109. p=(struct danlianbiao_Node *)malloc(sizeof(struct danlianbiao_Node ));
  110. //有错误
  111. int value;int i;
  112. p->data=value;
  113. pnode=list->base;
  114. while(i<index-1&&pnode!=NULL){
  115. pnode=pnode->next;
  116. i++; }
  117. p=pnode->next;
  118. pnode->next=p->next;
  119. free(p);
  120. }
  121. //设置值 ,这一项没有错误
  122. void danlianbiao_set(struct danlianbiao *list,int index,int value){
  123. int i=0;
  124. struct danlianbiao_Node *pnode=NULL;
  125. struct danlianbiao_Node *p=NULL;
  126. p=(struct danlianbiao_Node *)malloc(sizeof(struct danlianbiao_Node ));
  127. p->data=value;
  128. pnode=list->base;
  129. while(i<index-1&&pnode!=NULL){
  130. pnode=pnode->next;
  131. i++;
  132. }//while
  133. pnode->data=value;
  134. }
  135. //得到一个数值函数方法没有错误
  136. int danlianbiao_get(struct danlianbiao *list,int index ){
  137. int i=0;
  138. int value;
  139. struct danlianbiao_Node *pnode=NULL;
  140. struct danlianbiao_Node *p=NULL;
  141. p=(struct danlianbiao_Node *)malloc(sizeof(struct danlianbiao_Node ));
  142. p->data=value;
  143. pnode=list->base;
  144. while(i<index-1&&pnode!=NULL){
  145. pnode=pnode->next;
  146. i++;
  147. }//while
  148. return( pnode->data);
  149. }
  150. //
  151. int danlianbiao_lookup(struct danlianbiao *list,int value){
  152. int i=0;
  153. struct danlianbiao_Node *pnode=NULL;
  154. for(pnode=list->base->next;pnode !=NULL;pnode=pnode->next){
  155. i++;
  156. if(pnode->data==value) {
  157. return i;
  158. }//if
  159. }//for
  160. return 0;
  161. }
  162. int danlianbiao_isempty(struct danlianbiao *list,int value){
  163. }

线性表的基本操作(C语言实现)的更多相关文章

  1. 浅谈c语言的线性表的基本操作———基于严蔚敏的数据结构(c语言版)

    主要讲的是线性表的创建,插入及删除: 0. 线性表的建立,对于这类操作主要是利用了结构体的性质,对于定义的线性表的特性主要有三点:首先 Typedef struct { ElemType   *ele ...

  2. Problem C: 线性表的基本操作

    Description 线性表是一类重要的且基础的数据结构.请定义MyList类,来模拟针对线性表的插入.删除等操作: 1. 数据成员int *elements:线性表元素. 2. 数据成员int l ...

  3. (续)线性表之双向链表(C语言实现)

    在前文实现单向链表的基本操作下,本文实现双向链表的基本操作. 双向链表与单链表差异,是双向链表结点中有前向指针和后向指针.所以在插入和删除新结点元素时候不见要考虑后向指针还要考虑前向指针. 以下是双向 ...

  4. 【数据结构与算法】线性表操作(C语言)

    #include <stdio.h> #include <stdlib.h> #define OK 1 #define NO 0 #define MAXSIZE 20 type ...

  5. 使用C语言实现线性表

    线性表是最常用且最简单的一种数据结构.一个线性表是n个数据元素的有限序列,序列中的每个数据元素,可以是一个数字,可以是一个字符,也可以是复杂的结构体或对象.例如:1,2,3,4,5是一个线性表,A,B ...

  6. 【线性表基础】顺序表和单链表的插入、删除等基本操作【Java版】

    本文表述了线性表及其基本操作的代码[Java实现] 参考书籍 :<数据结构 --Java语言描述>/刘小晶 ,杜选主编 线性表需要的基本功能有:动态地增长或收缩:对线性表的任何数据元素进行 ...

  7. 学习使用C语言实现线性表

    线性表是最常用且最简单的一种数据结构.一个线性表是n个数据元素的有限序列,序列中的每个数据元素,可以是一个数字,可以是一个字符,也可以是复杂的结 构体或对象.例如:1,2,3,4,5是一个线性表,A, ...

  8. C语言数据结构-顺序线性表的实现-初始化、销毁、长度、查找、前驱、后继、插入、删除、显示操作

    1.数据结构-顺序线性表的实现-C语言 #define MAXSIZE 100 //结构体定义 typedef struct { int *elem; //基地址 int length; //结构体当 ...

  9. 线性表的Java实现

    一.概念 对于常用的数据结构,可分为线性结构和非线性结构,线性结构主要是线性表,非线性结构主要是数和图.当n>0时,表可表示为:(a0,a1,a2,a3,…an) 1. 线性表的特征: 1.存在 ...

随机推荐

  1. GitHub 主页美化设置教程

    GitHub profile设置教程 早些时候逛GitHub,就发现别人的主页特别的精美,当时没有空研究,前几天得空给安排了一下 先看一下成品 贴一个github上一个男人的主页 下面这个是我的 果然 ...

  2. day20--Java集合03

    Java集合03 8.LinkedList 1)linkedList底层实现了双向链表和双端队列的特点 2)可以添加任意元素(元素可以重复),包括null 3)线程不安全,没有实现同步 LinkedL ...

  3. zabbix 报表动作日志 报错”503“

  4. Vue组件的继承用法

    Vue组件的继承用法 点击打开视频讲解 vue组件的继承适用于UI几乎一样,只是数据不一样的情况下,但是这种情况通过统一封装组件也是能实现的,小功能建议用封装,大功能建议用组件继承,因为大功能在结合搜 ...

  5. 浅拷贝工具类,快速将实体类属性值复制给VO

    /** * 浅拷贝的工具类 */ public class PropertiesUtil { /** * 两个类,属性名一样的元素,复制成员. */ public static void copy(O ...

  6. HC32L110(四) HC32L110的startup启动文件和ld连接脚本

    目录 HC32L110(一) HC32L110芯片介绍和Win10下的烧录 HC32L110(二) HC32L110在Ubuntu下的烧录 HC32L110(三) HC32L110的GCC工具链和VS ...

  7. KingbaseES 创建只读(read_only)用户

    数据库版本: prod=> select version(); version --------------------------------------------------------- ...

  8. KingbaseES 数据库参数优化

    一.数据库应用类型 针对不同的应用模型,需要对数据库配置进行优化: 1.网络应用程序(WEB) ​通常受 CPU 限制 DB比RAM小得多 90% 或更多的简单查询 2.在线事务处理 (OLTP) ​ ...

  9. Springboot pageHelper总结

    Springboot上使用pageHelper总结 1. 在pom.xml 中引入依赖 <!--pagehelper--> <dependency> <groupId&g ...

  10. 手写tomcat——概述

    1. 使用java 编写一个echo http服务器 使用java 编写一个echo http服务器 https://github.com/ZhongJinHacker/diy-tomcat/tree ...