Estrutura de dados (dois) - fila de pilha da tabela linear

Reproduzido de Luofang Senior Sister e alguns gadgets na Internet

---

Existem nós vazios na lista ligada

---

A pilha não precisa estar vazia

---

Tabela linear

A definição e as características
de uma tabela linear Uma sequência ordenada composta de n elementos com as mesmas características de dados é chamada de tabela linear. Em particular, quando n = 0, é uma tabela vazia
Características: (para tabelas lineares não vazias ou estruturas lineares)
(1) Existe apenas um elemento de dados denominado "primeiro"
(2) Existe apenas um elemento de dados O elemento de dados denominado "último"
(3) Exceto o primeiro, cada dado na estrutura possui apenas um predecessor
(4) Exceto o último, cada dado na estrutura possui apenas um sucessor

Tabela de sequência

Declaração de código :

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

inicialização

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;
}

inserir

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;
}

excluir

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

declaração

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

inicialização

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;
}

inserir

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;
}

excluir

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;
}

Crie uma lista unida individualmente:

Nota: Qual é a diferença entre a criação de uma lista unida individualmente e a inicialização de uma lista unida unicamente: A inicialização de uma lista unida unicamente é criar uma lista vinculada vazia com apenas o nó principal, e a criação de uma lista unida unicamente é criar uma lista unida unicamente com vários nós. Ou seja, a partir do estado da lista vazia, os nós de cada elemento são estabelecidos por sua vez, e inseridos na lista encadeada um a um.
De acordo com as diferentes posições de inserção, ele é dividido em pré-interpolação e pós-interpolação.
(1) Pré- interpolação (obviamente, a complexidade de tempo do algoritmo é 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 de pós-interpolação (a complexidade de tempo do algoritmo ainda é O (n))
A fim de permitir que o novo nó seja inserido no final da lista vinculada, um novo ponteiro r precisa ser adicionado para apontar para o nó final da 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 ligada circular

declaração:

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

Pilha

Pilha: primeiro a entrar, último a sair

Representação de pilha sequencial

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

Bata no quadro-negro

inicialização

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

Empurrar

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

Desempilhar

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

Fique no topo da pilha

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

Representação de pilha de cadeia

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

inicialização

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

Empurrar

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

Desempilhar

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

Fique no topo da pilha

SElemType GeTop (LinkStack & s)

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

Representação de fila circular sequencial

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

inicialização

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

Encontre o comprimento

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

Junte-se ao time

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;
}

Deixar o time

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;
}

Buscar elemento

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

Equipe da rede

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

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

inicialização

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

Junte-se ao time

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

Deixar o time

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;
}

Pegue o topo da cabeça

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