线性表

最新推荐文章于 2022-01-03 22:21:26 发布
最新推荐文章于 2022-01-03 22:21:26 发布
阅读量249 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43172803/article/details/103193039
版权

线性表

1.顺序表

linetable_array.h

#include <stdio.h>
#define max 100
#define ElemType int
struct List {
	ElemType elements[max];
	int last;
};
typedef int position;
//L.elements[p]
//L.last
void Insert(ElemType x, position p, List &L) {
	position q;
	if (L.last >= max - 1)
		printf("The table is full.\n");
	else if ((p > L.last + 1) || (p < 1))
		printf("The position is illegal.\n");
	else {
		for (q = L.last; q >= p; --q) {
			L.elements[q + 1] = L.elements[q];
			L.elements[p] = x;
			L.last++;
		}
	}
}
void Delete(position p, List &L) {
	position q;
	if (p > L.last || p < 1)
		printf("The position is illegal.\n");
	else {
		L.last--;
		for (q = p; q <= L.last; q++) {
			L.elements[q] = L.elements[q + 1];
		}
	}
}
position Locate(ElemType x, List &L) {
	position q;
	for (q = 1; q <= L.last; q++) {
		if (L.elements[q] == x) 
			return q;
	}
	return L.last + 1;
}
ElemType Retrieve(position p, List &L) {
	if (p > L.last)
		printf("The position is illegal.\n");
	else 
		return L.elements[p];
}
ElemType Previous(position p, List &L){ 
	if (p <= 1 || p > L.last + 1) 
		printf("The position is illegal.\n");
	else 
		return p - 1;
}
ElemType Next(position p, List &L) {
	if (p < 1 || p >= L.last + 1)
		printf("The position is illegal.\n");
	else
		return p + 1;
}
position MakeNull(List &L){ 
	L.last = 0;
	return L.last + 1;
}
position First(List L){ 
	if (L.last > 0) 
		return 1; 
	else 
		printf("The table is empty.\n");
}
position End(List L){ 
	return L.last + 1; 
}

2.链表

linetable_linktable.h

#include <stdio.h>
#include <stdlib.h>
#define ElemType int
struct celltype {
	ElemType data;
	struct celltype *next;
}link;
typedef struct celltype *List, *position;
void Insert(ElemType x, position p) {
	position q;
	q = (List)malloc(sizeof(link));
	q->data = x;
	q->next = p->next; 
	p->next = q;
}
void Delete(position p) {
	position q;
	if (p->next != NULL) {
		q = p->next;
		p->next = q->next;
		free(q);
	}
}
position Locate(ElemType x, List *L) {
	List p;
	p = L;
	while (p->next != NULL) {
		if (p->next->data == x)
			return p;
		p = p->next;
	}
	return p;
}
ElemType Retrieve(position p) {
	return p->next->data;
}
position Previous(position p, List *L) {
	position q;
	if (p == L)
		printf("The position is illegal.\n");
	else {
		q = L;
		while (q->next != p) {
			q = q->next;
		}
		return q;
	}
}
position Next(position p) {
	if (p->next == NULL)
		printf("The position is illegal.\n");
	else 
		return p->next;
}
position MakeNull(List L) {
	L = (List)malloc(sizeof(link));
	L->next = NULL;
	return L;
}
position First(List L) {
	return L;
}
position End(List L) {
	position q;
	q = L;
	while (q->next != NULL)
		q = q->next;
	return q;
}

3.静态链表

static_linklist.h

#define max 100
#define ElemType int
typedef struct{
	ElemType data;
	int next;
}space;
typedef int position;
void Initialize(position *L, space s[], position *avail) {
	for (int j = 0; j <= max - 1; ++j) 
		s[j].next = j + 1;
	*avail = 0;
	*L = 0;
}
position GetNode(position avail, space s[]) {
	position p = s[avail].next;
	s[avail].next = s[p].next;
	return p;
}
void FreeNode(position p, space s[], position avail) {
	s[p].next = s[avail].next;
	s[avail].next = p;
}
void Insert(ElemType x, position p, space s[], position avail) {
	position q = GetNode(avail, s);
	s[q].data = x; 
	s[q].next = s[p].next; 
	s[p].next = q;
}
void Delete(position p, space s[], position avail) {
	position q; 
	if (s[p].next != -1) {
		q = s[p].next; 
		s[p].next = s[q].next; 
		FreeNode(q, s, avail);
	}
}
position Locate(space s[], position L, position avail, ElemType x) {
	if (L == avail)
		return -1;
	if (s[L].next == -1 && s[L].data == x)
		return L;
	else if (s[L].next == -1)
		return -1;
	do{
		if (s[s[L].next].data == x)
			return L;
		L = s[L].next;
		if (L == -1)
			break;
	 } while (L != -1);
	return -1;
}

4.双向链表

doubledir_link.h

#include <stdlib.h>
#include <stdio.h>
#define ElemType int 
struct dcelltype {
	ElemType data; 
	struct dcelltype *next, *prior;
}; /* 结点类型 */ /* 表和位置的类型 */ 
typedef struct dcelltype *DLIST, *position;
void Insert(ElemType x, position p, DLIST *L) {
	DLIST s = (dcelltype *)malloc(sizeof(dcelltype)); 
	s->data = x; 
	s->prior = p;
	s->next = p->next; 
	p->next->prior = s; 
	p->next = s;
}
void Delete(position p, DLIST &L) {
	if (p->prior != NULL)
		p->prior->next = p->next; 
	if (p->next != NULL)
		p->next->prior = p->prior; 
	free(p);
}

5.单向环形链表

roundlink.h

#include <stdio.h>
#include <stdlib.h>
#define ElemType int
typedef struct {
	ElemType data;
	struct celltype *next;
}link;
typedef link *List, *position;
List LInsert(ElemType x,link *R) {
	List p; 
	p = (List)malloc(sizeof(link));
	p->data = x; 
	if (R == NULL) { 
		p->next = p; 
		R = p; 
	}
	else { 
		p->next = R->next; 
		R->next = p; 
	}
	return p;
}
void RInsert(ElemType x, link *R) {
	List q = LInsert(x, R); 
	R = R->next;
	return q;
}
void Ldelete(link *R){
	List p; 
	if (R == NULL)
		printf("Error.\n");
	else {
		p = R->next;
		R->next = p->next; 
		if (p == R) 
			R = NULL; 
		free(p);
	}
}

栈

1.数组栈

stack.h

#define maxlength 1000
typedef char Element;//定义基础类型
typedef struct STACK {
	int top;
	Element ele[maxlength];
}STA;
bool empty(STA s) {//判断非空与否
	return s.top == -1;
}
void makenull(STA *s) {//置栈为空
	s->top = -1;
}
Element top(STA s) {//返回栈顶元素
	if (empty(s)) {
		return NULL;//栈为空返回为空
	}
	return s.ele[s.top];
}
Element pop(STA *s) {//弹出栈顶元素并且返回栈顶元素
	Element ch = s->ele[s->top];
	if (s->top < 0) {
		makenull(s);//栈为空则置空并返回空
		return NULL;
	}
	else {
		s->top--;//出栈，返回原来栈顶元素
		return ch;
	}
}
void push(STA *s, Element x) {//压栈
	s->ele[++s->top] = x;
}

2.链栈

stacklink.h

#include <stdlib.h>
#define ElemType int
struct node {
	ElemType data; 
	struct node *next;
};
typedef struct node *STACK;
STACK MakeNull() {
	STACK s; 
	s=(node *)malloc(sizeof(node));
	s->next = NULL;
	return s;
}
bool Empty(STACK stk) {
	if (stk->next) 
		return false; 
	else 
		return true;
}
void Push(ElemType elm, STACK stk) {
	STACK s; 
	s = (node *)malloc(sizeof(node));
	s->data = elm;
	s->next = stk->next; 
	stk->next = s;
}
void Pop(STACK stk) {
	STACK s;
	if (stk->next) {
		s = stk->next;
		stk->next = s->next; 
		free(s);
	} 
}
ElemType Top(STACK stk) {
	if (stk->next)
		return stk->next->data;
	else 
		return NULL;
}

队列

1.数组队列

queue.h

#include <stdlib.h>
#include <stdio.h>
#define ElemType char
#define MaxSize 1000
struct QUEUE {
	ElemType data[MaxSize];
	int front;
	int rear;
};
void MakeNull(QUEUE *Q) {
	Q->front = MaxSize - 1;
	Q->rear = MaxSize - 1;
}
bool Empty(QUEUE Q) {
	if (Q.rear == Q.front)
		return true;
	else
		return false;
}
ElemType Front(QUEUE Q) {
	if (Empty(Q))
		return NULL;
	else {
		return Q.data[(Q.front + 1) % MaxSize];
	}
}
void EnQueue(ElemType x, QUEUE *Q) {
	if ((Q->rear + 1) % MaxSize == Q->front)
		printf("The queue is full.\n");
	else {
		Q->rear = (Q->rear + 1) % MaxSize;
		Q->data[Q->rear] = x;
	}
}
void DeQueue(QUEUE *Q) {
	if (Empty(*Q))
		printf("The queue is empty.\n");
	else
		Q->front = (Q->front + 1) % MaxSize;
}

2.链式队列

queuelink.h

#include <stdlib.h>
#include <stdio.h>
#define ElemType int
struct celltype {
	ElemType data;
	struct celltype *next;
};
struct QUEUE { 
	struct celltype *front; 
	struct celltype *rear;
};
void MAKENULL(QUEUE *Q) {
	Q->front = (celltype *)malloc(sizeof(celltype)); 
	Q->front->next = NULL; 
	Q->rear = Q->front;
}
bool EMPTY(QUEUE Q) { 
	if (Q.front == Q.rear) 
		return true ;
	else 
		return false; 
}
ElemType FRONT(QUEUE Q) { 
	if (Q.front->next) 
		return Q.front->next->data;
}
void EnQueue(ElemType x, QUEUE *Q) {
	struct celltype* q = (celltype *)malloc(sizeof(celltype));
	q->data = x; 
	q->next = NULL; 
	Q->rear->next = q; 
	Q->rear = q;
}
void DeQueue(QUEUE *Q) {
	if (Q->rear == Q->front)
		printf("The queue is empty.\n");
	celltype *p = Q->front->next; 
	Q->front->next=p->next; 
	if (p->next==NULL) 
		Q->rear=Q->front; 
	free(p);
}

稀疏矩阵

三元组

#define max 100
struct three {
	int row, col;//行  列
	int data;
};
typedef struct reararr {
	three a[max];
	int m, n, x;//行，列，非零元个数
}M;

压缩存储（十字链表）

#define ElemType int
struct celltype {
	int row; //存储非零元素的行号
	int col; //存储非零元素的列号
	ElemType item;//存储非零元素的值
	struct celltype right;//指针域，指向同一行中的下一个三元组
	struct celltype down;//指针域，指向同一列中的下一个三元组
};

广义表

struct listnode {
	struct listnode *link;//连下一个
	bool tag;//是否有广义表在里面
	union {
		char data;//数据
		struct listnode *dlink;//连到里面的广义表
	};
};
typedef listnode *listpointer;
bool Equal(listpointer S, listpointer T) {
	bool x, y;
	y = false;
	if ((S == NULL) && (T == NULL))
		y = true;
	else if ((S != NULL) && (T != NULL)) {
		if (S->tag == T->tag) {
			if (!S->tag) {
				if (S->data == T->data)
					x = true;
				else
					x = false;
			}
			else
				x = Equal(S->dlink, T->dlink);
			if (x)
				y = Equal(S->link, T->link);
		}
	}
	return y;
}

ADT

在这里插入图片描述
在这里插入图片描述

栈的ADT

逻辑结构
ADT 
Stack
栈：是一种特殊的线性表，数据元素之间的关系是线性关系，其插入，删除只能在表的一端进行（从0开始的一端为头），另一端固定不动。
Data
   栈中元素具有相同类型（为char）及后进先出的特性
Operation
   makenull
       前置：栈存在
       功能：清空栈，将栈置空
   push
       前置：栈存在
       功能：将元素入栈
 	pop
       前置：栈存在
       功能：将栈顶元素出栈并删除，返回被删元素
   top
       前置：栈存在
       功能：读取栈顶元素
   empty
       功能：判断栈是否为空，返回1，否则返回0
存储结构
采用的栈stack的为顺序存储结构——顺序栈，即把逻辑上相邻的节点存储在物理位置上相邻的存储单元中，结点之间的逻辑关系由存储单元的邻接关系来体现。代码中将该栈设置为数组实现，内部ele[]数组存储stack内容，相邻元素存储在相邻数组。具体代码如下：
将地址高端设为栈底，栈顶为地址低端

#define maxlength 1000  
typedef char Element;//定义基础类型  
typedef struct STACK {  
    int top;  
    Element ele[maxlength];  
}STA;  

判断栈是否为空

bool empty(STA s) {//判断非空与否  
    return s.top == -1;  
}  

将栈置空

void makenull(STA *s) {//置栈为空  
    s->top = -1;  
}  

返回栈顶元素

Element top(STA s) {//返回栈顶元素  
    if (empty(s)) {  
        return NULL;//栈为空返回为空  
    }  
    return s.ele[s.top];  
}  

弹出栈顶元素并且返回

Element pop(STA *s) {//弹出栈顶元素并且返回栈顶元素  
    Element ch = s->ele[s->top];  
    if (s->top < 0) {  
        makenull(s);//栈为空则置空并返回空  
        return NULL;  
    }  
    else {  
        s->top--;//出栈，返回原来栈顶元素  
        return ch;  
	}  
}  

压栈

void push(STA *s, Element x) {//压栈  
    s->ele[++s->top] = x;  
}

队列的ADT

逻辑结构
ADT 
Queue
队列：是一种特殊的线性表，数据元素之间的关系是线性关系，其一端插入，删除只能在表的另一端进行。
Data
   队列中元素具有相同类型（为char）及先进先出的特性
Operation
   q_makenull
       清空队列，将队列置空
   q_empty
       判断队列是否为空
 	front
       返回队首元素
   enqueue
       将元素入队尾
   dequeue
       将队首元素出队
存储结构
采用的队列queue为顺序存储结构——顺序栈，即把逻辑上相邻的节点存储在物理位置上相邻的存储单元中，结点之间的逻辑关系由存储单元的邻接关系来体现。代码中将该栈设置为数组实现，相邻元素存储在相邻数组。具体代码如下：

#define ElemType char
#define MaxSize 1000
struct QUEUE {
	ElemType data[MaxSize];
	int front;
	int rear;
};

将队列置空

void MakeNull(QUEUE *Q) {
	Q->front = MaxSize - 1;
	Q->rear = MaxSize - 1;
}

判断队列是否为空

bool Empty(QUEUE Q) {
	if (Q.rear == Q.front)
		return true;
	else
		return false;
}

获得队首元素

ElemType Front(QUEUE Q) {
	if (Empty(Q))
		return NULL;
	else {
		return Q.data[(Q.front + 1) % MaxSize];
	}
}

将元素入队

void EnQueue(ElemType x, QUEUE *Q) {
	if ((Q->rear + 1) % MaxSize == Q->front)
		printf("The queue is full.\n");
	else {
		Q->rear = (Q->rear + 1) % MaxSize;
		Q->data[Q->rear] = x;
	}
}

将队首元素出队

void DeQueue(QUEUE *Q) {
	if (Empty(*Q))
		printf("The queue is empty.\n");
	else
		Q->front = (Q->front + 1) % MaxSize;
}
fastaway
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于typedef和struct使用过程中的一些思考（2020/12/23更新）
weixin_44640697的博客
12-23 840
关于typedef和struct使用过程中的一些思考 以下内容所记录的内容是自己在编写ADT工具类时遇到的问题，做出一些记录，好记性不如烂笔头 以下内容如有错误的地方还望不吝赐教 1、C与C++中关于typedef和struct的使用辨析： 题目案例1：C中定义结构体类型（简洁版 少写了类名） typedef struct { ··· }Sqlist, Linklist, SqStack; 注意： 需要说明的是 在此处 Sqlist, Linklist, SqStack都是同一种数据类型，
线性表的定义与操作-顺序表，链式表(C语言)
m0_51955470的博客
11-14 284
顺序表: typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; }; /* 初始化 */ List MakeEmpty() { List L; L = (List)malloc(sizeof(struct LNode)); L->Last = -1; return L; } /* 查找 *
数据结构C语言——循环队列
weixin_45454137的博客
07-19 437
队列的顺序存储定义 typedef int Position; typedef struct QNode * PtrToQNode; struct QNode{ ElementType * Data; Position Front,Rear; int MaxSize; }; typedef PtrToQNode Queue; Queue CreateQueue(int MaxSize){ Queue Q=(Queue)malloc(sizeof(struct QNode)); Q->Dat
【数据结构】【期末复习】知识点总结
m0_55251293的博客
01-03 1万+
*这里的位置是结点的地址 */当 Top = -1时，表示栈空；当Top = MaxSize -1 时，栈满！/*存储元素的数组*//*栈顶指针*//*堆栈最大容量*//* QElemType类型根据实际情况而定，这里假设为int *//* 循环队列的顺序存储结构 */int front;/* 头指针 */int rear;/* 尾指针，若队列不空，指向队列尾元素的下一个位置 */}SqQueue;
数据结构——堆栈（二）
zz0377的博客
03-30 186
堆栈（Stack）可以认为是具有一定约束的线性表，插入和删除操作都作用在一个称为栈顶（Top）的端点位置。
基础线性表
10-11
线性表（linear_list）是最常用且最简单的一种数据结构
C++通过类实现线性表
08-19
C++ 通过类实现线性表 本文详细介绍了 C++ 通过类实现线性表的知识点，包括线性表的基本概念、类实现线性表的思路、类成员函数的实现等。 线性表的基本概念 线性表是一种基本的数据结构，线性表是由零个或多个...
线性表综合题_C语言_线性表_
09-29
线性表是计算机科学中数据结构的基础概念，它是由n（n≥0）个相同类型元素构成的有限序列。在本题中，我们关注的是如何使用C语言来实现线性表的一些基本操作，包括添加元素（增）、删除元素（删）、修改元素（改）...
数据结构线性表
04-08
线性表是最基本、最简单、也是最常用的一种数据结构。线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。
typedef学习笔记
galaxy_yyg的博客
12-05 468
typedef在语句中所起的作用把语句原先定义变量变成了定义类型。 比对一下两个声明： int *p; typedef int *p; int *p 中, p是一个变量，其类型为pointer to int； 在int *p前面增加一个typedef后，p变为一个typedef-name，这个typedef-name所表示的类型就是int *p声明式中p的类型(int
typedef用法小结
dortmund2013的博客
09-21 126
1. 给类型起一个新名字 typedef int newInt; newInt a = 2; 2. 与结构体结合使用 3. 与函数结合使用
数据结构基础 - 二分查找
qq_25175067的博客
03-09 1611
01-复杂度3 二分查找（20 分） 本题要求实现二分查找算法。 函数接口定义： Position BinarySearch( List L, ElementType X ); 其中List结构定义如下： typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSI...
线性表的两种实现方法-数据结构学习笔记2.1
凤凰涅磐
03-25 826
typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; }; /* 初始化 */ List MakeEmpty() { List L;
数据结构—线性表实现代码
进阶中的程序员吃吃的博客
05-18 767
顺序表：typedef int Position; typedef struct LNode *List; struct LNode {     ElementType Data[MAXSIZE];     Position Last; };   /* 初始化 */ List MakeEmpty() {     List L;     L = (List)malloc(sizeof(struct ...
typedef int (*pfunc)(int ,int);是什么？
Sam.yu的专栏
09-14 7195
typedef S32             (*IntCallback)(SimObject *obj, S32 argc, const char *argv[]);这是我看到的原型，之前有typedef int S32,当时一下子没看出来，傻了，后来在网上看到别人说的typedef的用法中特意提到这个用法：函数指针写了个小例子：//////////////////////////
c语言中typedef的几种用法
热门推荐
夜夜夜夜
07-07 2万+
几种用法：1.常规变量类型定义例如：typedef unsigned char uchar 描述：uchar等价于unsigned char类型定义 uchar c声明等于unsigned char c声明2.数组类型定义 例如： typedef int array[2]; 描述： array等价于 int [2]定义; array a声明等价于int a[2]声明扩展： typedef in
1-5 线性表元素的区间删除 (20 分)
韩旭051的博客
08-29 7350
1-5线性表元素的区间删除(20分) 给定一个顺序存储的线性表，请设计一个函数删除所有值大于min而且小于max的元素。删除后表中剩余元素保持顺序存储，并且相对位置不能改变。 函数接口定义： List Delete( List L, ElementType minD, ElementType maxD ); 其中List结构定义如下： typedef int Position...
C++ typedef 用法详解
cuizhiyi2008的专栏
10-29 5060
typedef是替一个对象取一个别名，以此增强程序的可读性。 1 定义一种数据类型的别名 typedef int INT; //定义int类型的一个别名INT。注意：末尾的分号 typedef char* pStr; 2 定义结构体的别名（很久远的事情了，现在C++已经不存在这个问题） struct sPositon //结构体定义 { int x; int ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值