《线性表的总结---线性顺序表（静态，动态）---线性链表（动态）》

【静态顺序表的练习】

/*
需求：创建一个静态的顺序表存放整数，大小为10，完成以下操作
1，输入6个整数，打印出顺序表中的内容，并显示表中剩余的空间个数。
2，在顺序表中的第3个位置插入元素0，打印输出顺序表中的内容，并显示表中剩余的空间个数。
3，再试图插入表中第11个位置整数0，程序提示超出范围。
4，删除表中第6个元素，打印出顺序表中的内容，并显示表中剩余的空间个数。
*/

/*
#include<stdio.h>
#define MaxSize 10

//想顺序表中插入元素
void insertElem(int Sqlist[],int &len,int i,int x)
{
　　int t;
　　if(len==MaxSize || i<1 || i>len+1)
　　{
　　printf("插入位置非法！\n");
　　return;
　　}
　　for(t=len-1;t>=i-1;t--)
　　　Sqlist[t+1]=Sqlist[t];
　　Sqlist[i-1]=x;
　　len = len+1;
}

//向顺序表中删除元素
void DelElem(int Sqlist[],int &len,int i)
{
int j;
if(i<1 || i>len)
{
printf("This insert is illegal");
return; //非法删除
}
for(j=i;j<=len-1;j++)
Sqlist[j-1]=Sqlist[j]; //将第i个元素之后的元素前移
len = len-1;
}

//主函数
int main()
{
int Sqlist[MaxSize]; //定义一个静态顺序表
int len,i;
printf("请输入6个整数（以空格分开）:");
for(i=0;i<6;i++)
scanf("%d",&Sqlist[i]);
len = 6;
printf("表中的元素如下：");
for(i=0;i<len;i++)
//输出顺序表中的6个整数
printf("%3d",Sqlist[i]);
//显示顺序表中的剩余空间
printf("\n表中剩余空间为：%d\n",MaxSize-len);

//调用insertElem(int Sqlist[],int &len,int i,int x)函数，向顺序表中插入元素
//向顺序表中的第3位置插入整数0
printf("在表中的第3个位置插入整数0");
insertElem(Sqlist,len,3,0);
printf("\n");
printf("表中的元素如下：");
for(i=0;i<len;i++)
//输出顺序表中的所有元素
printf("%3d",Sqlist[i]);
//显示表中剩余空间
printf("\n表中剩余空间为： %d\n",MaxSize-len);

//调用insertElem(int Sqlist[],int &len,int i,int x)函数，在表中的第11位置插入整数0
printf("在表中的第11个位置插入整数0：");
insertElem(Sqlist,len,11,0);

//调用DeElem(int Sqlist[],int &len,int i)函数，删除顺序表中的第6个元素
printf("删除表中第6个元素");
DelElem(Sqlist,len,6);
printf("表中元素如下：");
for(i=0;i<len;i++)
//输出顺序表中的所有元素
printf("%3d",Sqlist[i]);
printf("\n表中剩余空间为： %d\n",MaxSize-len);
return 0;

}
*/

//【动态顺序表的练习】
/
需求：编写一个程序，动态的创建一个顺序表。要求：顺序表的初始长度为10，向顺序表中输入15个整数
并打印出来；再删除顺序表中的第5个元素，打印出删除后的结果.
/

/*

include<stdio.h>

include<conio.h>

include<stdlib.h>

define MaxSize 10

typedef int ElemType; //将int定义为ElemType
typedef struct
{
int *elem;
int length;
int listsize;
}Sqlist;

//初始化一个顺序表
void initSqlist(Sqlist &L)
{
L.elem = (int )malloc(MaxSizesizeof(ElemType));
if(!L.elem)
exit(0);
L.length = 0;
L.listsize = MaxSize;
}

//向顺序表中插入元素
void InsertElem(Sqlist &L,int i,ElemType item)
{//向顺序表L中第i个位置上插入元素item
ElemType base,insertPtr,p;
if(i<1 || i>L.length+1)
exit(0);
if(L.length>=L.listsize)
{
base = (ElemType )realloc(L.elem,(L.listsize+10)sizeof(ElemType));
L.elem = base;
L.listsize+=100;
}
insertPtr = &(L.elem[i-1]); //记下要插入元素位置的地址
for(p = &(L.elem[L.length-1]);p>=insertPtr;p--)
(p+1) = p;
insertPtr = item;
L.length++;
}

//从顺序表中删除元素
void DelElem(Sqlist &L,int i)
{
ElemType delItem,q;
if(i<1 || i>L.length)
exit(0);
delItem = &(L.elem[i-1]);
q = L.elem+L.length-1;
for(++delItem;delItem<=q;++delItem)
(delItem-1) = delItem;
L.length--;
}

//主函数
int main()
{
Sqlist l;
int i;
//调用initSqlist(Sqlist &L)函数，初始化一个顺序表
initSqlist(l);
printf("顺序表已创建完毕...");
printf("\n");
printf("向顺序表中插入1~15个整数(数字之间用空格分开)\n");
for(i=0;i<15;i++)
InsertElem(l,i+1,i+1);
printf("这个顺序表中的元素是：");
for(i=0;i<l.length;i++)
printf("%3d",l.elem[i]);
printf("\n");

//调用DelElem(Sqlist &L,int i)函数，删除第5个元素
DelElem(l,5);
printf("第5个元素已被删除...");
printf("\n");
printf("元素删除后，顺序表中的元素入下：");
for(i=0;i<l.length;i++)
printf("%3d",l.elem[i]);
printf("\n");
return 0;
}

*/

//【数据结构版---线性表-线性表的顺序表示和实现（静态）】
//实现插入元素和删除元素的功能
/*

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 10

typedef int Status; //函数结果状态类型
typedef int ElemType; //元素类型

//向静态顺序表中插入元素
Status InsertElem(int Sqlist[],int len,int i,ElemType x)
{
int t;
if(len==MaxSize || i<1 || i>len+1)
{
printf("非法插入...");
return OVERFLOW;
}
for(t=len-1;t>=i-1;t--)
Sqlist[t+1] = Sqlist[t];
Sqlist[i-1] = x;
len=len+1;
return OK;
}

//向静态顺序表中删除元素
Status DelElem(int Sqlist[],int len,int i)
{
int j;
if(i<1 || i>len)
{
printf("非法删除...");
exit(0);
}
for(j=i;j<len-1;j++)
Sqlist[j-1] = Sqlist[j];
len = *len - 1;
return OK;
}

//主函数（测试）
int main()
{
int Sqlist[MaxSize]; //定义一个静态顺序表
int len,i;
int e1,e2,x;

printf("请从键盘输入6个整数(数字之间以空格分开):");
for(i=0;i<6;i++)
scanf("%d",&Sqlist[i]);
len = 6;
printf("初始静态顺序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf("\n静态顺序表的剩余空间是：%d",MaxSize - len);
printf("\n");

//调用InsertElem(int Sqlist[],int *len,int i,int x)函数，插入元素
printf("输入你要插入的位置:");
scanf("%d",&e1);
printf("\n");
printf("输入你要插入的元素:");
scanf("%d",&x);
InsertElem(Sqlist,&len,e1,x);
//输出当前静态顺序表中的元素，验证是否正确插入
printf("当前顺序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf("\n");
printf("静态顺序表的剩余空间是：%d",MaxSize-len);
printf("\n");

//调用DelElem(int Sqlist[],int *len,int i)函数，删除指定元素
printf("输入你要删除的元素序号:");
scanf("%d",&e2);
DelElem(Sqlist,&len,e2);
//输出当前静态顺序表中的元素，验证是否正确删除
printf("当前顺序表中的元素：");
for(i=0;i<len;i++)
printf("%3d",Sqlist[i]);
printf("\n");
printf("静态顺序表的剩余空间是：%d",MaxSize-len);
printf("\n");

return 0;
}
*/

//【数据结构版---线性表-线性表的顺序表示和实现（动态）】
/*

include<stdio.h>

include<stdlib.h>

include<conio.h>

define TRUE 1

define FALSE 0

define OK 1

define ERROR 0

define INFEASIBLE -1

define OVERFLOW -2

define LIST_INIT_SIZE 100 //动态顺序表存储空间的初始分配量

define LISTINCREMENT 10 //动态顺序表存储空间的分配增量

typedef int Status; //函数结果状态
typedef int ElemType; //元素类型
typedef struct
{
ElemType *elem;
int length;
int listsize;
}Sqlist;

//初始化一个顺序表
Status InitList_Sq(Sqlist &L)
{
L.elem = (ElemType )malloc(LIST_INIT_SIZEsizeof(ElemType));
if(!L.elem)
exit(OVERFLOW); //存储分配失败
L.length = 0; //动态线性表的初始长度为0
L.listsize = LIST_INIT_SIZE; //动态线性表的初始容量
return OK;
}

//向动态线性表中插入元素
Status InsertElem(Sqlist &L,int i,ElemType e)
{
ElemType newbase,q,p;
if(i<1 || i>L.length+1)
return ERROR;
if(L.length >= L.listsize)
{//当前存储空间已满，增加分配
newbase = (ElemType )realloc(L.elem,(L.listsize+LISTINCREMENT)sizeof(ElemType));
if(!newbase)
exit(OVERFLOW); //分配失败
L.elem = newbase;
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 Creat_Sq(Sqlist &L)
//{
// ElemType temp;
// printf("请输入你要插入到动态顺序表中的元素(ending 9999):");
// scanf("%d",&temp);
// while(temp!=9999)
// {
// InsertElem(L,L.length+1,temp);
// printf("请输入你要插入到动态顺序表中的元素(ending 9999):");
// scanf("%d",&temp);
// }
// return OK;
//}

Status Creat_Sq(Sqlist &L)
{
ElemType temp,n,i;
printf("请输入你要插入元素的个数：");
scanf("%d",&n);
printf("\n请输入你要插入的元素（以空格分开）:");
for(i=0;i<n;i++)
{
scanf("%d",&temp);
InsertElem(L,L.length+1,temp);
}
return OK;
}

//顺序表的遍历
Status Print_Sq(Sqlist L)
{
int i;
for(i=0;i<L.length;i++)
printf("%4d",L.elem[i]);
printf("\n");
return OK;
}

//向动态顺序表中删除元素
Status DelElem(Sqlist &L,int i,ElemType &e)
{
ElemType p,q;
if(i<1 || i>L.length)
return ERROR;
p = &(L.elem[i-1]);
e = p; //把要删除的元素的值赋给e
q = L.elem+L.length-1;
for(++p;p<=q;++p)
(p-1) = *p;
--L.length;
return OK;
}

//顺序表的查找
Status Locate_Sq(Sqlist L,ElemType e)
{
int i,n;
char change;
ElemType p;
p = L.elem;
for(i=0;i<L.length;i++)
{
if(p++ == e)
n = i;
}
printf("你要找的%d是第%d个元素\n",L.elem[n],n+1);
return OK;
}

//顺序表的排序
void Sort_Sq(Sqlist &L)
{
int i,j;
char change;
ElemType temp;
i = L.elem[L.length-1];
for(change = TRUE;i>=1;i--)
{
change = FALSE;
for(j=0;j<i-1;j++)
{
if(L.elem[j]>L.elem[j+1])
{
temp = L.elem[j];
L.elem[j] = L.elem[j+1];
L.elem[j+1] = temp;
change = TRUE;
}
}
}
}

//主函数
int main()
{
ElemType e,e1,e2,e3,e4;
Sqlist sq;

InitList_Sq(sq);
printf("动态顺序表已创建好...\n");
Creat_Sq(sq);
printf("\n");
printf("顺序表中的元素有:\n");
Print_Sq(sq);
printf("\n");

printf("请输入要插入的位置：");
scanf("%d",&e1);
printf("\n请输入你要插入的元素：");
scanf("%d",&e2);
InsertElem(sq,e1,e2);
printf("插入元素后，顺序表中的元素如下:\n");
Print_Sq(sq);
printf("\n");

printf("请输入你要删除的元素的位置：");
scanf("%d",&e3);
DelElem(sq,e3,e);
printf("删除指定元素后，顺序表中的元素如下：\n");
Print_Sq(sq);
printf("\n");

printf("请输入你要查找的元素：");
scanf("%d",&e4);
Locate_Sq(sq,e4);

Sort_Sq(sq);
printf("排序后的结果是：\n");
Print_Sq(sq);
return 0;
}
*/

//【数据结构版--线性表的链式表示和实现】

include<stdio.h>

include<stdlib.h>

include<malloc.h>

define TRUE 1

define FALSE 0

define OK 1

define ERROR 0

define INFEASIBLE -1 //infeasible-->不可行的

define NULL 0

typedef int Status;
typedef int ElemType;

//定义结构体
typedef struct LNode
{
ElemType data;
struct LNode next;
}LNode,LinkList;

//带表头结点的单链表的插入
Status Listinsert_L(LinkList &L,int i,ElemType e)
{
LinkList p,s;
int j;
p = L;
j = 0;
while(p && j<i-1)
{
p = p->next;
++j;
}
if(!p || j>i-1)
return ERROR;
s=(LinkList)malloc(sizeof(LNode)); //生产新结点
s->data=e;
s->next=p->next;
p->next=s;
L->data++;
return OK;
}

//【头插法】逆序输入n个元素的值，创建一个带表头节点的单链表
/
void CreatList_L(LinkList &L,int n)
{
int i;
LNode p;

L=(LinkList)malloc(sizeof(LNode));
L->data=0; //令表头中的数据域内的值为0（其值为表中元素的个数）
L->next=NULL; //建立带表头节点的单链表
printf("Please input data:(输入8个整数,由大到小输入)\n");
for(i=n;i>0;--i)
{
p=(LinkList)malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next = L->next;
L->next=p;
L->data++; //递增表中元素的个数
}
// printf("%d",L->data); //此处L->data的功能是输出表中元素的个数
}
*/
//尾插法
Status CreatList_L(LinkList &L)
{
ElemType temp;
L=(LinkList)malloc(sizeof(LNode));
if(!L) return ERROR;
L->data=0;
L->next=NULL;
printf("Please Input data (9999) ending\n");
scanf("%d",&temp);
while(temp!=9999)
{
Listinsert_L(L,L->data+1,temp);
scanf("%d",&temp);
}
return OK;
}

//查找单链表中第i个元素，若存在，其值赋给e并返回OK,否则返回ERROR
Status GetElem_L(LinkList L,int i,ElemType &e)
{
//L为带头结点的单链表的头指针
LNode *p1;
p1=L->next;
int j=1; //初始化，p指向第一个结点，j为计数器
while(p1 && j<i)
{
p1 = p1->next;
++j;
}
if(!p1 || j>i)
return ERROR; //第i个元素不存在
e=p1->data;
return OK;
}

//带头结点单链表的删除
Status ListDelete_L(LinkList &L,int i,ElemType &e)
{
LNode p,q;
int j;
p = L;
j=0;
while(p->next && j<i-1) //注意不能写成（p && j<i-1）
{
p=p->next;
++j;
}
if(!(p->next) || j>i-1)
return ERROR;
q = p->next;
p->next = q->next;
e = q->data;
//printf("%d",e);
free(q);
L->data--; //使链表中的元素个数减一
return OK;
}
//求单链表的长度的函数
void Length_L(LinkList L)
{
int num=0;
LinkList p;
p=L->next;
while(p)
{

printf("%3d",p->data);
p=p->next;
num++;
}
printf("\n这个单链表的长度为：%d",num);
}

//定义输出链表函数
Status Print_L(LinkList L)
{
LinkList p;
p=L->next;
printf("this list contains %d elements\n",L->data);
while(p)
{
printf("%4d->",p->data);
p=p->next;
}
printf("NULL\n");
return OK;
}

/*已知线性表中的元素以值递增有序排列,并以单链表作存储结构。
写一高效算法，删除表中所有值大于mink且小于maxk的元素（若表中存在这样的元素）
同时释放被删节点空间，并分析算法时间复杂度。

（考虑当这个线性表不是有序排列该怎么办，那就写一个单链表的排序算法，
若单链表的元素无序，则先调用排序算法进行排序，再调用此算法进行删除）*/

Status Delete_Between(LinkList &L,int mink,int maxk)
{
LNode p,q;
p = L;
while(p->next->data<=mink)
p=p->next; //p是最后一个不大于mink的元素
if(p->next) //如果还有比mink更大的元素
{
q=p->next;
while(q->data<maxk)
q=q->next; //q是第一个不小于maxk的元素
p->next=q;
}
return OK;

}
//建立主函数
int main()
{
LinkList L;
int n=8,i,i_1,i_2,e,e_1,e_2,e_3,e_4;

//调用CreatList_L函数，创建一个单链表
//printf("Please input the number in the list:\n");
//CreatList_L(L,n); //调用头插法时用
CreatList_L(L);
printf("\n");

//调用GetElem_L函数，查找单链表中的第i个元素,调用Length_L函数，求表长
printf("单链表中的数据为：\n");
Print_L(L);
printf("\n");
printf("\n请输入你要获取的元素序号:");
scanf("%d",&i);
GetElem_L(L,i,e);
printf("the %dth number is:%d",i,e);
printf("\n");

//调用Listinsert_L函数，实现元素插入功能,然后调用输出链表函数，输出插入后的链表
　　printf("清输入插入元素的位置：\n");
　　scanf("%d",&i_1);
　　printf("\n请输入要插入的元素：\n");
　　scanf("%d",&e_1);
　　Listinsert_L(L,i_1,e_1);
　　Print_L(L);
　　printf("\n");

//调用Delete函数，用来删除指定的元素,然后再调用Print_L函数输出删除元素后的链表
　　printf("请输入要删除的位置是：\n");
　　scanf("%d",&i_2);
　　ListDelete_L(L,i_2,e_2);
　　Print_L(L);
　　printf("\n");

//调用Delete_Between函数，用来删除指定两个元素之间的元素,然后调用Print函数，输出操作后的链表
　　printf("\n删除a和b之间的元素，请输入：");
　　scanf("%d%d",&e_3,&e_4);
　　Delete_Between(L,e_3,e_4);
　　Length_L(L);
　　Print_L(L);
　　printf("\n");

　　return 0;
}

出处：https://www.cnblogs.com/sun-/p/4866706.html）

原文地址：https://www.cnblogs.com/xyz-8108923246/p/10593469.html

时间： 2024-10-03 02:51:12

《线性表的总结---线性顺序表（静态，动态）---线性链表（动态）》的相关文章

CI框架源码阅读笔记3 全局函数Common.php

从本篇开始,将深入CI框架的内部,一步步去探索这个框架的实现.结构和设计. Common.php文件定义了一系列的全局函数(一般来说,全局函数具有最高的加载优先权,因此大多数的框架中BootStrap引导文件都会最先引入全局函数,以便于之后的处理工作). 打开Common.php中,第一行代码就非常诡异: if ( ! defined('BASEPATH')) exit('No direct script access allowed'); 上一篇(CI框架源码阅读笔记2 一切的入口 index

IOS测试框架之：athrun的InstrumentDriver源码阅读笔记

athrun的InstrumentDriver源码阅读笔记 作者:唯一 athrun是淘宝的开源测试项目,InstrumentDriver是ios端的实现,之前在公司项目中用过这个框架,没有深入了解,现在回来记录下. 官方介绍:http://code.taobao.org/p/athrun/wiki/instrumentDriver/ 优点:这个框架是对UIAutomation的java实现,在代码提示.用例维护方面比UIAutomation强多了,借junit4的光,我们可以通过junit4的

Yii源码阅读笔记 - 日志组件

?使用 Yii框架为开发者提供两个静态方法进行日志记录: Yii::log($message, $level, $category);Yii::trace($message, $category); 两者的区别在于后者依赖于应用开启调试模式,即定义常量YII_DEBUG: defined('YII_DEBUG') or define('YII_DEBUG', true); Yii::log方法的调用需要指定message的level和category.category是格式为“xxx.yyy.z

源码阅读笔记 - 1 MSVC2015中的std::sort

大约寒假开始的时候我就已经把std::sort的源码阅读完毕并理解其中的做法了,到了寒假结尾,姑且把它写出来 这是我的第一篇源码阅读笔记,以后会发更多的,包括算法和库实现,源码会按照我自己的代码风格格式化,去掉或者展开用于条件编译或者debug检查的宏,依重要程度重新排序函数,但是不会改变命名方式(虽然MSVC的STL命名实在是我不能接受的那种),对于代码块的解释会在代码块前(上面)用注释标明. template<class _RanIt, class _Diff, class _Pr> in

CI框架源码阅读笔记5 基准测试 BenchMark.php

上一篇博客(CI框架源码阅读笔记4 引导文件CodeIgniter.php)中,我们已经看到:CI中核心流程的核心功能都是由不同的组件来完成的.这些组件类似于一个一个单独的模块,不同的模块完成不同的功能,各模块之间可以相互调用,共同构成了CI的核心骨架. 从本篇开始,将进一步去分析各组件的实现细节,深入CI核心的黑盒内部(研究之后,其实就应该是白盒了,仅仅对于应用来说,它应该算是黑盒),从而更好的去认识.把握这个框架. 按照惯例,在开始之前,我们贴上CI中不完全的核心组件图: 由于BenchMa

CI框架源码阅读笔记2 一切的入口 index.php

上一节(CI框架源码阅读笔记1 - 环境准备.基本术语和框架流程)中,我们提到了CI框架的基本流程,这里这次贴出流程图,以备参考: 作为CI框架的入口文件,源码阅读,自然由此开始.在源码阅读的过程中,我们并不会逐行进行解释,而只解释核心的功能和实现. 1.       设置应用程序环境 define('ENVIRONMENT', 'development'); 这里的development可以是任何你喜欢的环境名称(比如dev,再如test),相对应的,你要在下面的switch case代码块中

Apache Storm源码阅读笔记

欢迎转载,转载请注明出处. 楔子 自从建了Spark交流的QQ群之后,热情加入的同学不少,大家不仅对Spark很热衷对于Storm也是充满好奇.大家都提到一个问题就是有关storm内部实现机理的资料比较少,理解起来非常费劲. 尽管自己也陆续对storm的源码走读发表了一些博文,当时写的时候比较匆忙,有时候衔接的不是太好,此番做了一些整理,主要是针对TridentTopology部分,修改过的内容采用pdf格式发布,方便打印. 文章中有些内容的理解得益于徐明明和fxjwind两位的指点,非常感谢.

CI框架源码阅读笔记4 引导文件CodeIgniter.php

到了这里,终于进入CI框架的核心了.既然是"引导"文件,那么就是对用户的请求.参数等做相应的导向,让用户请求和数据流按照正确的线路各就各位.例如,用户的请求url: http://you.host.com/usr/reg 经过引导文件,实际上会交给Application中的UsrController控制器的reg方法去处理. 这之中,CodeIgniter.php做了哪些工作?我们一步步来看. 1.    导入预定义常量.框架环境初始化 之前的一篇博客(CI框架源码阅读笔记2 一切的入

jdk源码阅读笔记之java集合框架（二）（ArrayList）

关于ArrayList的分析,会从且仅从其添加(add)与删除(remove)方法入手. ArrayList类定义: p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 18.0px Monaco } span.s1 { color: #931a68 } public class ArrayList<E> extends AbstractList<E> implements List<E> ArrayList基本属性: /** *

dubbo源码阅读笔记--服务调用时序

上接dubbo源码阅读笔记--暴露服务时序,继续梳理服务调用时序,下图右面红线流程. 整理了调用时序图 分为3步,connect,decode,invoke. 连接 AllChannelHandler.connected(Channel) line: 38 HeartbeatHandler.connected(Channel) line: 47 MultiMessageHandler(AbstractChannelHandlerDelegate).connected(Channel) line: