数据结构——顺序表

最新推荐文章于 2023-01-10 22:25:02 发布
最新推荐文章于 2023-01-10 22:25:02 发布
阅读量747 收藏 1
点赞数
分类专栏： # 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QM19900420/article/details/122952560
版权

目录

1.单链表

1.1带头结点

1.1.1 按位序插入

1.1.2前插操作

1.1.3 后插操作

1.1.4删除操作 

1.2不带头结点

1.2.1 按位序插入

2.双链表

#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;
#define InitSize 10 //默认的最大长度
typedef struct{
	int *data;	//指示动态分配数组的指针
	int MaxSize;	//顺序表的最大容量
	int length; 	//顺序表的当前长度 
}SeqList;

//初始化
void InitList (SeqList &L){
	L.data=(int *)malloc(InitSize *sizeof(int));
	L.length=0;
	L.MaxSize=InitSize;
} 
//动态增加数组的长度
void IncreaseSize (SeqList &L,int len){
	int *p=L.data;
	L.data=(int *)malloc((L.MaxSize+len)*sizeof(int));
	for(int i=0;i<L.length;i++)
	{
		L.data[i]=p[i];
	}
	L.MaxSize=L.MaxSize+len;
	free(p); 
} 

//插入--在L的位序i处插入元素e 
bool ListInsert(SeqList &L,int i,int e){
	if(i<1||i>L.length+1)	//判断i是否有效 
		return false;
	if(L.length>=L.MaxSize)	//当前存储空间已满，不能插入 
		return false;
	for(int 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 true;
} 

//删除--在L的位序i处删除元素e 
bool ListDelete(SeqList &L,int i,int e){
	if(i<1||i>L.length+1)	//判断i是否有效 
		return false;
	e=L.data[i-1]; 
	for(int j=i;j<L.length;j++)	//将第i个元素后的元素前移 
	{
		L.data[j-1]=L.data[j]; 
	}
	L.length--;		//长度减1 
	return true;
} 

//按位查找
ElemType GetElem(SeqList L,int i){
	return L.data[i-1];
} 

//按值查找
ElemType LocateElem(SeqList L,ElemType e){
	for(int i=0;i<L.length;i++)
		if(L.data[i]==e)	//下标为i的元素值=e，返回其位序i +1 
			return i+1;
	return 0;	//退出循环，说明查找失败 
} 

//输出
void out(SeqList &L){
	for(int i=0;i<L.length;i++)
	{
		cout<<L.data[i];
	}
	cout<<endl;
}
void ints(SeqList &L){
	for(int i=0;i<L.length;i++)
	{
		cin>>L.data[i];
	}
	cout<<endl;
}


int main(){
	SeqList L;	//声明一个顺序表
	InitList(L);	//初始化顺序表 
	IncreaseSize(L,5);	
	ListInsert(L,3,3); 
	int e=-1;
	if(ListDelete(L,3,e))
		cout<< "已删除第3个元素，删除元素为"<<e;
	else
		cout<<"位序i不合法，删除失败"<<endl; 
	out(L);
	return 0; 

}

1.单链表

1.1带头结点

//顺序表——单链表 ——带头节点 
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;

//定义一个单链表 
typedef struct LNode{	//LNode:结点 
	int data;	//data：数据域 
	struct LNode *next;	//指向下一个结点的指针 
	}LNode,*LinkList;
//free(p);

//初始化一个空的单链表
bool InitList(LinkList &L){
	L = (LNode *) malloc(sizeof(LNode));	//分配一个头结点 
	if(L==NULL)		//内存不足，分配失败 
		return false;
	L->next=NULL; //头结点不存储数据 
	return true;
}
 

void test(){
	LinkList L;
	InitList(L);
}

1.1.1 按位序插入

//顺序表——单链表——按位序插入（带头结点）

bool InsertNextNode (LNode *p,ElemType e);
//在第i个位置插插入元素e (带头结点)
bool ListInsert(LinkList &L, int i,ElemType g){
	if(i<1)
		return false;
	LNode *p; 	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向的是第几个结点
	p = L; 		//L指向头结点，头结点是第0个结点(不存数据)
	
	//循环找到第i-1个结点
	while (p!=NULL && j<i-1) {	
		p=p->next;
		j++; 
	}
	return InsertNextNode (p,e);
}

1.1.2前插操作

//顺序表——单链表 ——带头节点——前插操作:在p结点之前插入元素e
bool InsertNextNode (LNode *p,ElemType e){
	if (p==NULL)
		return false;
	LNode *s = ( LNode *)malloc(sizeof( LNode) );
	if (s==NULL)	//内存分配失败
		return false;
	s->next=p->next;
	p->data = s;	//新结点s连接到P之后 
	s->data=p->data;	//将p中的元素复制到s之中 
	p->next=e;	//覆盖
	return true;
}

1.1.3 后插操作

//后插操作:在p结点之后插入元素e
bool InsertNextNode (LNode *p,ElemType e){
	if (p==NULL)
		return false;
	LNode *s = ( LNode *)malloc(sizeof( LNode) );
	if (s==NULL)	//内存分配失败
		return false;
	s->data = e;	//用结点s保存数据元素e
	s->next=p->next;
	p->next=s;	//将结点s连到p之后
	return true;
}

1.1.4删除操作 

//顺序表——单链表 ——带头节点——删除操作 
bool ListDelete(LinkList &L, int i,ElemType &e){
	if(i<1)
		return false;
	LNode *p;	//指针p指向当前扫描到的结点
	int j=0;	//当前p指向的是第几个结点
	p = L;		//L指向头结点，头结点是第0个结点(不存数据)
	while (p!=NULL && j<i-1)  //循环找到第i-1个结点
		p=p->next;
		j++;
	}
	if(p==NULL)		//i值不合法
		return false;
	if( p->next == NULL)	//第i-1个结点之后已无其他结点
		return false;
	LNode *q=p->next;	//令q指向被删除结点
	e = q->data;	//用e返回元素的值
	p->next=q->next;	//将*q结点从链中断开
	free(q);	//释放结点的存储空间
	return true;	//删除成功
}

1.2不带头结点

//顺序表——单链表 ——不带头节点 
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;

//定义一个单链表 
typedef struct LNode{	//LNode:结点 
	int data;	//data：数据域 
	struct LNode *next;	//指向下一个结点的指针 
	}LNode,*LinkList;
LNode * p = (LNode *) malloc(sizeof(LNode));	//增加一个新的结点：在内存中申请一个结点所需要的空间，并用指针P指向这个结点 
//free(p);

//初始化一个空的单链表
bool InitList(LinkList &L){
	L=NULL;		//空表，暂时还没有任何结点，防止脏数据 
	return true;
}

//判断单链表是否为空
bool Empty(LinkList L){
	if(L==NULL)
		return true;
	else
		return false;
} 

void test(){
	LinkList L;
	InitList(L);
}

1.2.1 按位序插入

//顺序表——单链表——按位序插入（不带头结点）

//在第i个位置插插入元素e (不带头结点)
bool ListInsert(LinkList &L, int i,ElemType g){
	if(i<1)
		return false;
	//如果不带头结点，则插入、删除第1个元素时,需要更改头指针L
	if(i==1){
		LNode *s = ( LNode *)malloc(sizeof( LNode) );	//申请新的结点空间 
		s->data = e;
		s->next=L;
		L=s;
		return true;
	}
	
	//i>1的情况 
	LNode *p; 	//指针p指向当前扫描到的结点
	int j=1;	//当前p指向的是第几个结点
	p = L; 		//L指向头结点，头结点是第0个结点(不存数据)
	
	//循环找到第i-1个结点
	while (p!=NULL && j<i-1) {	
		p=p->next;
		j++; 
	}
	//i值不合法
	if(p==NULL)		
		return false;
		
	LNode *s = ( LNode *)malloc(sizeof( LNode) );	//申请新的结点空间 
	s->data = e;
	s->next=p->next;p->next=s;	//将结点s连到p之后
	return true;	//插入成功
}

2.双链表

//顺序表——双链表
#include<stdlib.h>
#include<iostream>
#include<string.h>
using namespace std;

//定义一个双链表 
typedef struct DNode{	//LNode:结点 
	int data;	//data：数据域 
	struct DNode *prior,*next;	//指向下一个结点的指针 
	}DNode,*DLinkList;


//初始化一个空的双链表
bool InitDList(DLinkList &L){
	L = (DNode *) malloc(sizeof(DNode));	//分配一个头结点 
	if(L==NULL)		//内存不足，分配失败 
		return false;
	L->next=NULL; //头结点不存储数据 
	L->prior=NULL; 
	return true;
}

//在p结点之后插入s结点
bool InsertNextDNode( DNode *p，DNode *s){
	if ( p==NULL ls==NULL)//非法参数
		return false;
	s->next=p->next;	//将结点*s插入到结点*p之后
	if (p->next != NULL) //如果p结点有后继结点
		p->next->prior=s;
	s->prior=p;
	p->next=s;
}
	
//删除p结点的后继结点
bool DeleteNextDNode( DNode *p){
	if ( p==NULL)
		return false;
	DNode *q = p->next;	//找到p的后继结点q
	if (q==NULL)
		return false;	// p没有后继
	p->next=q->next;
	if (q->next !=NULL)//q结点不是最后一个结点
	q->next->prior=p;
	free(q);//释放结点空间
	return true;
}

//销毁双链表
void DestoryList(DLinklist &L){ 
	//循环释放各个数据结点
	while (L->next != NULL)
	DeleteNextDNode(L);
	free(L);	//释放头结点
 	L=NULL;		//头指针指向NULL
}
 
void test(){
	LinkList L;
	InitDLinkList(L);
}

Austismes
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
顺序表的基本操作_【数据结构】顺序表基本操作的实现（C语言）
weixin_35754962的博客
01-27 451
线性表的顺序存储称为顺序表线性表元素为逻辑上相邻，顺序存储时在物理上也相邻（以数组的形式进行存储）L=( , ,..., , ,... )注意：顺序表下标从1开始，而数组下标从0开始数组大小是固定的，线性表的大小不是固定的顺序表是一维的，而数组可以是多维的1，顺序表的定义：数组静态分配#define MaxSize 50 #define ElemType int typedef stru...
【数据结构】线性表
love_guanghui的博客
04-21 496
一，线性表 1.基本概念 a.定义：线性表是具有相同数据类型的n个数据元素的有限序列***，其中n位表长，当n=0是线性表是一个空表。 b.几个概念： ·ai是线性表中的“第i个”元素线性表中的位序（注意：位序从1开始，数组下标从0开始）。 ·a1是表头元素*；an是表尾元素。 ·除第一个元素外，每个元素有且仅有一个前驱；除最后一个元素外，每个元素有且仅有一个后继。 2.基本操作 InitList(&L):初始化表。构造一个空的线性表L，分配内存空间 DestroyList(&L):销毁操
数据结构——顺序表的合并
qq_45966201的博客
02-02 1万+
数据结构——顺序表的合并 具体要求：写一个函数，其函数的功能是将非递增顺序表LA和LB合并到非递增顺序表LC中 数据结构—顺序表的操作之合并顺序表 一、顺序表的结构 首先要定义的是顺序表的结构体，只有先定义了顺序表的结构体类型，才可以继续进行下一步操作 #define maxsize 100 typedef struct { int elem[maxsize];//线性表元素 int last;//线性表长度 }SeqList; 二、顺序表的操作 1.生成顺序表 在有了顺序表的结构之后，
数据结构---线性表
zzqingyun的博客
01-10 1527
静态分配int length;}SqList;L.length=0;return 0;动态分配#define MAXSIZE 5 //MAXSIZE是根据实际问题定义的足够大的整数常量//定义了一个指针变量存放地址int length;}SqList;//定义顺序表类型SqList L;//在C++中也可以使用new,和delete//释放空间return 0;增加数组空间的长度int length;}SqList;
数据结构 ，第一章，绪论
wofengyun的专栏
09-18 1323
一、基本概念和术语 l       数据(Data)：是指所有能输入到计算机中并被计算机程序处理的符号的总称。是计算机加工的“原料”。 l       数据元素(Data Element):是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。有些情况下，数据元素也称为元素、结点、顶点、记录。有时数据元素可以由若干数据项（也称为字段、域、属性）组成，数据项是数据的有独立含义的最小
两个非递减有序单链表La和Lb合并成一个非递增有序链表Lc
m0_52118763的博客
11-02 9454
#include<iostream> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <math.h> using namespace std; typedef int ElemType; //元素类型 typedef int Status; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR.
数据结构——顺序表的建立和基本操作
06-16
顺序表的建立和基本操作，主要含有顺序表的定义，顺序表的初始化，顺序表的插入操作，删除操作，按位查找和按值查找操作的算法，以及完整的函数调用流程。数据结构的代码实现。
数据结构实验——顺序表
12-22
数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表数据结构实验——顺序表
数据结构C++ 线性表——顺序表和单链表基本操作(含代码和注释).docx
11-04
注：分为三个内容：顺序表、单链表、运行结果。代码包含顺序表和单链表的基本操作（增删改查等，详见注释），并展示了两个具体使用例子，包括对基本操作的验证和合并两个有序线性表为一个有序表。代码均已通过Dev-...
数据结构顺序表与链表
WBG_TheShy的博客
09-06 142
/找不到时i为0,否则R[i]就是要找的结点；=NULL && j
数据结构线性表的定义、初始化和创建
qq_48471248的博客
07-29 1895
SqList//该语句表示这是一个顺序表。intlength;//顺序表的当前长度。intdata[MaxSize];//设置为用数组存放元素。//初始化一个顺序表。
两个非递减有序集合合并为一个非递减有序集合
RegretPain的博客
11-22 6287
已知线性表LA和LB中的数据元素或是按值非递减有序排列，现要求将LA和LB合并为一个新的线性表LC，且LC中的元素要求同样按值非递减排列。上述问题是数据结构（C语言）上的一个线性表的合并问题，这里使用C++的一些东西来完成它。void MergeList(const vector<int>&la,const vector<int>&lb,vector<int>&lc) { vector<in
已知两个线性升序表LA，LB，然后合并两个表为LC，并保持升序
acgl
09-18 4654
创建两个升序顺序表，合并为一个表并保持有序，时间复杂度为O（m+n）
将La和Lb合并为一个新的线性表Lc的几种结构的归纳
热门推荐
xiaoshi935的专栏
08-23 1万+
在数据结构线性表一章中，提出了三种方法。1、总的方法，并没有涉及具体的存储类型。此处给出了具体的思想。void MergeList(List La, List Lb, List &Lc) { //已知线性表La和Lb中的数据元素按值非递减排列 //归并La和Lb得到新的线性表Lc，Lc的数据元素也按值非递减排列 InitList(Lc); int ai, bj; int
数据结构笔记【自用】
poiboc的博客
05-06 506
自己瞎记
p[0] =(int*)&data是什么意思？, (int*)与(int)*的区别
EricHai的博客
04-15 742
(int*)与(int)*的区别 直接上代码： /** * 功能：测试 p[0] =(int*)&data, 与(int)*data的区别 */ void test_int_point() { //(int*)&a printf("=====================test (int*)&a===================\n"); int a = 15; int* p[3] = { NULL }; p[0] = (int*)&a
Java数据结构——用顺序表编写一个简易通讯录
最新发布
05-15
好的，下面是用Java顺序表实现简易通讯录的代码： 首先，在Java中需要定义一个类来表示通讯录中的每一个联系人，这个类包含联系人的姓名和电话号码两个属性： ```java public class Contact { private String ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值