Armazenamento em cadeia de tabelas lineares (2)

1. Preparação

Primeiro preparamos a estrutura para armazenamento (tome as informações do aluno como exemplo)

typedef struct // Cria uma variável de estrutura para as informações do aluno
{
char name [];
int age;
char num [];
} stu;

typedef struct element//创建用于存储的结构体变量
{
stu info;
struct element* Next=NULL;
}ele;

int main()
{
ele* start =(ele ** )malloc(100×sizeof（ele）)

return 0;
}

2. Adições, exclusões, modificações e liberações (para distinguir, usamos ~ em vez de *)

1. Para adicionar um elemento, precisamos completar estas etapas
(1) encontrar a posição na lista vinculada
(2) adicionar o elemento
void Listadd (ele ~ start, int n, ele ~ ptr) // n é a posição adicionada , ptr é obrigatório Elementos adicionados
{
assert (n <100);
assert (start);
ele ~ p = start;
while (p-> Next && n--)
{
p = p-> Next;
}
ptr-> Next = (p -> Avançar) -> Avançar;
p-> Avançar = ptr;
}
2. Excluir um elemento é semelhante a ele, então não vou repeti-lo.
3. Encontre um elemento
(1) encontre a posição do elemento
(2) retorne seu ponteiro
ele ~ Listfind (ele ~ início, int n)
{
ele ~ p = início;
assert (p);
assert (n <100);
p = p -> Próximo;
enquanto (p && n--)
{
p = p-> Próximo;
}
retorna p;
4. Modifique um elemento
(1) encontre o elemento naquela posição
(2) modifique
void Listchange (ele ~ start, int n, ele ~ ptr)
{
ele ~ p = start;
afirmar (p);
afirmar (n <100);
enquanto (p && n--)
{

        p=p->Next;
        }

        ptr->Next=p->Next;
        p->Next=ptr;

}
5. 释放 链表
void Freelist (ele ~ start)
{
ele ~ p = start;
afirmar (p);
ele ~ tmp = NULL;
enquanto (p-> Próximo)
{
tmp = p;
p = p-> Próximo;
livre (p);
}
p = NULL;
}

3. Explicaremos as perguntas feitas no início do artigo anterior

Não
é difícil organizar todos os elementos nas duas matrizes em uma grande matriz em ordem decrescente , mas se você quiser economizar espaço, você pode também usar uma lista vinculada

Conforme mostrado na figura, primeiro organize as duas matrizes em ordem, da maior para a menor, depois compare o tamanho do elemento apontado pelo ponteiro de peq e adicione um ao ponteiro do elemento menor; em seguida, compare. A primeira comparação salva o elemento maior e, nas comparações subsequentes, o endereço do elemento maior em cada comparação é armazenado no campo de ponteiro do elemento maior na comparação anterior.