Estructura de datos (dos) cola de pila de tabla lineal

Reimpreso de Luofang Senior Sister y algunos gadgets en Internet

---

Hay nodos vacíos en la lista vinculada

---

La pila no necesita estar vacía

---

Mesa lineal

Definición y características
de una tabla lineal Una secuencia ordenada compuesta por n elementos con las mismas características de datos se denomina tabla lineal. En particular, cuando n = 0, es una tabla vacía.
Características: (para tablas lineales no vacías o estructuras lineales)
(1) Solo hay un elemento de datos llamado el "primero"
(2) Solo hay un elemento de datos El elemento de datos llamado "último"
(3) Excepto por el primero, cada dato en la estructura tiene solo un predecesor
(4) Excepto por el último, cada dato en la estructura tiene solo un sucesor

Tabla de secuencia

Declaración de código :

#define Maxsize 100	//线性表可能达到的最大长度
typedef struct 
{
	ElemType *elem;	//存储空间的基地址
	int length;			//当前长度
}Sqlist;				//顺序表的数据结构类型为Sqlist

inicialización

Status InitList(Sqlist &L)
{//构造一个空的顺序表L
	L.elem  =new ElemType[Maxsize];	 //为顺序表分配一个大小为Maxsize的数组空间
	if(!L.elem) exit(OVERFLOW);     //存储分配失败退出
	L.length=0;					//空表长度为0
}

Valor

Status GetELem(Sqlist &L,int i)
{
	if(i<1||i>L.length) return ERROR;   //判断i取值是否合理
	e=L.elem[i-1];
	return OK;
}

Encontrar

int Locate(Sqlist &L,ElemType e)
{
	for(int i=0;i<L.length;i++)
	{
		if(L.elem[i]==e)
			return i+1;
	}
	 return 0;
}

insertar

Status ListInsert(SqList &L,int i,int e)
{
	if(i<1||i>L.length+1) return ERROR;
	if(L.lengrh==Maxszie) return ERROR;
	for(int j=L.length-1;j>=i-1;j--)
	{
		L.elem[j+1]=L.elem[j];
	}
	L.elem[i-1]=e;
	L.length++;
	return OK;
}

Eliminar

Status ListDelete(Sqlist &L,int i)
{
	if(i<1||i>L.length) return ERROR;
	for(int j=i;j<=L.length-1;j++)
	{
		L.elem[j-1]=L.elem[j];
	}
	--L.length;
	return OK;
}

Lista única

declaración

typedef struct LNode
{
	ElemType data;
	struct LNode *next;
}LNode,*LinkList；

inicialización

Status InitList(LinkList &L)
{
	L=new LNode;		//生成新的结点作为头结点，用指针L指向头结点
	L->next=NULL;	//头结点的指针域置空
	return OK;
}

Valor

Status GetElem(LinkList &L,int i,ElemType &e)
{
	LinkList p=L->next;  //用p指向首元节点
	j=1;	//j作为计数器
	while(p&&j<i)
	{
		p=p->next;
		++j;
	}
	if(!p||j>i)
		return ERROR;
	e=p->data;
	return OK;
}

Encontrar

LNode *LocateElem(LinkList &L,ElemType e)
{
	p=L->next;
	while(p&&p->data!=e)
	{
		p=p->next;
	}
	return p;
}

insertar

Status LinkInsert(LinkList &L,int i,ElemType e)
{//在带头结点的单链表L中第i个位置插入元素为e的新节点
	s=new LNode;
	s->data=e;
	p=L;
	j=0;
	while(p&&j<i-1)  //查找第i-1个节点，p指向该节点
	{
		p=p->next;
		++j;
	}
	if(!p||j>i-1） return ERROR;
	s->next=p->next;
	p->next=s;
	return 0K;
}

Eliminar

Status ListDelete(LinkList &L,int i)
{
	//在带头结点的单链表中删除第i个节点
	p=L；
	j=0;
	while((p->next)&&(j<i-1))
	{
		p=p->next;
		j++;
	}
	if(!(p->next)||(j>i-1)) return ERROR;
	q=p->next;	//保存待删除的节点
	p->next=p->next->next;
	delete q;
	return OK;
}

Cree una lista enlazada individualmente:

Nota: ¿Cuál es la diferencia entre la creación de una lista enlazada individualmente y la inicialización de una lista enlazada individualmente? La inicialización de una lista enlazada individualmente es crear una lista enlazada vacía con solo el nodo principal, y la creación de una lista enlazada individualmente es crear una lista enlazada individualmente con múltiples nodos. Es decir, partiendo del estado de la lista vacía, los nodos de cada elemento se establecen a su vez y se insertan en la lista enlazada uno por uno.
Según las diferentes posiciones de inserción, se divide en preinterpolación y posinterpolación.
(1) Preinterpolación (obviamente, la complejidad temporal del algoritmo es O (n))

void CreatList_H(LinkList &L,int n)
{
	//逆位序输入n个元素的值，建立带头结点的单链表
	L=new LNode;
	L->next=NULL;
	for(int i=0;i<n;i++)
	{
		p=new LNode;
		cin>>p->data;
		p->next=L-next;
		L-next=p;
	}
}

(2) Método posterior a la interpolación (la complejidad temporal del algoritmo sigue siendo O (n))
Para permitir que el nuevo nodo se inserte al final de la lista vinculada, es necesario agregar un nuevo puntero r para apuntar al nodo final de la lista vinculada

void CreatList(LinkList &L,int n)
{
	L=new LNode;
	L->next=NULL;
	r=L;
	for(int i=0;i<n;i++)
	{
		p=new LNode;
		cin>>p->data;
		p->next=NULL;
		r->next=p;
		r=p;
	}
}

Lista enlazada circular

declaración:

typedef struct DuLNode
{
	ElemType data;
	struct DuLNode *prior;
	struct DuLNode *next;
}DuLNode,*DuLinkList;

Apilar

Pila: primero en entrar, último en salir

Representación secuencial de la pila

#define Maxsize 100
typedef struct 
{
	SElemType *top;
	SElemType *base;
	int stackSize;
}SqStack;

Toca la pizarra

inicialización

Status InitSatck(SqStack &s)
{
	s.base=new SElemType[Maxsize];
	if(!s.base) return ERROR;
	s.top=s.base;
	s.stackSize=Maxsize;
	return OK;
}

empujar

Status Push(SqStack &s,SElemType e)
{
	if(s.top-s.base==Maxsize) return ERROR；
	*s.top++=e;
	return OK;
}

Desapilar

Status Pop(SqStack &s,SElemType &e)
{
	if(s.top==s.base) return ERROR;
	e=*--top;
	return OK;
}

Parte superior de la pila

SElemType GeTop(SqStack &s)
{
	if(s.top!=s.base) 
	{
		p=s.top;
		return *--p;
	}
}

Representación de la pila de cadenas

typedef struct StackNode
{
	ElemType data;
	struct StackNode *next;
}StackNode,*LinkStack;

inicialización

Status InitStack(LinkStack &s)
{
	s=NULL;
	return OK;
}

empujar

Status Push(LinkStack &s,SElemType e)
{
	p=new StackNode;
	p->data=e;
	p->next=s;
	s=p;
	return 0K;
}

Desapilar

status Pop(LinkStack &s,SElemType &e)
{
	if(s==NULL) return ERROR;
	e=s->data;
	p=s;
	s=s->next;
	delete p;
	return OK;
}

Parte superior de la pila

SElemType GeTop (LinkStack & s)

{
	if(s!=NULL)
		return s->data;
}

Representación de cola circular secuencial

#define Maxsize 100
typedef struct 
{
	QElemType *base;   //存储空间的基地址
	int rear;
	int front;
}SqQueue;

inicialización

Status InitQueue(SqQueue &Q)
{
	Q.base=new QElemType[Maxsize];
	if(!Q.base) return ERROR;
	Q.front=Q.rear=0;
	return OK;
}

Encuentra la longitud

int QueueLength(SqQueue &Q)
{
	return  (Q.rear-Q.front+Maxsie)%Maxsize;
}

Únete al equipo

Status EnQueue(SqQueue &Q,QElemType e）
{
	if((Q.rear+1)%Maxsize==Q.front) return ERROR;   //队满
	Q.base[Q.rear]=e;
	Q.rear=(Q.rear+1)%Maxsize;
	return OK;
}

Dejar el equipo

Status DeQueue(SQueue &Q,QElemType &e)
{
	if(Q.rear==Q.front) return ERROR;  //队空
	e=Q.base[Q.front];
	Q.front=(Q.front+1）%Maxsize;
	return OK;
}

Obtener elemento

QElemType GetTop(SQueue &Q)
{
	if(Q.rear!=Q.front)
		return Q.base[Q.front];
}

Equipo de cadena

typedef struct QNode
{
	QElemType data;
	struct ONode *next;
}QNode,*QueuePtr;

typedef struct 
{
	QNode *front;
	QNode *rear;
}LinkQueue;

inicialización

status InitQueue(LinkQueue &Q)
{
	Q.front=Q.rear=new QNode;
	Q.front->next=NULL;
	return OK;
}

Únete al equipo

status EnQueue(LinkQueue &Q,QElemType e)
{
	p=new QNode;
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p
	return OK;
}

Dejar el equipo

status DeQueue(LinkQueue &Q,QElemType &e)
{
	if(Q.rear==Q.front) return OK;
	p=Q.front->next;
	e=p->data;
	Q.front->next=p->next;  //修改头指针
	if(Q.rear=p) Q.rear=Q.font;   //如果最后一个元素被删
	delete p;
	return OK;
}

Toma la parte superior de la cabeza

QElemType GeTop(LinkQueue &Q)
{
	if(Q.rear!=Q.front)
		return Q.front->next->data;
}