/ *] [Problema Descrição
essa questão exige um conjunto de definido e implementado para o armazenamento de dados de número inteiro, um conjunto de programação e de teste em várias operações a função principal.
] [Requisitos básicos
para realizar o seguinte conjunto de operações:
(1) adicionar um número para a recolha; // conclusão
(2) a remoção de um elemento a partir da colecção; // conclusão
(3) determina se um elemento da colecção; // concluída
(4) dois conjuntos de realização e operação;
(5) dois conjuntos de operação intersecção implementado;
(6) o cálculo da diferença entre os dois conjuntos de realização;
(7) determina se os dois conjuntos são iguais;
(8) determina se um conjunto é um subconjunto de outro conjunto, se sim, a soma de complemento absoluto de outra forma, encontrar o complemento relativa;
(9) mostra todos os elementos do conjunto de saída. // completa
concepção de um menu, chamar todas as funções e sair do sistema acima dos requisitos.
[Dica] alcançar
pode ser representado em uma lista ordenada ou encomendar um conjunto de tabelas.
[Dados de Teste]
invoca várias operações na função principal, o resultado da operação de exibição. Os dados de teste deve refletir os resultados de várias operações, tanto quanto possível.
* /
// arquivo de cabeçalho contém funções de biblioteca
# include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
//函数状态码定义
#define VERDADEIRO 1
#define FALSE 0
#define OK 1
#define ERRO 0
#define inviável -1
#define OVERFLOW -2
LIST_INIT_SIZE 100 #define
#define LISTINCREMENT 10
// definição da estrutura
typedef int ElemType; // elementos na tabela são inteiro
typedef struct {
int * elem; // memória endereço base
comprimento int; // número de elementos na tabela número
int listsize; // tabela tamanho capacidade
} SqList; // definições de tipo de mesa sequência
int ListInsert_Sq (SqList & G, int pos, int e); // pos inseridos do elemento E
int ListDelete_Sq (SqList & G, pos, int & E); // Remover os elementos de pos lugar, e retorna por E
int ListLocate_Sq (SqList L , e int); // Encontrar posição elemento de retorno de e
ListPrint_Sq vazio (SqList G); // gera sequencialmente a forma linear
// inicialização e destruição da estrutura da operação
// Inicializar L int InitList_Sq (SqList & G) na forma de uma tabela vazia da sequência ordenada
{
L.elem = (int ) malloc (LIST_INIT_SIZE o sizeof (int));
if (! L.elem)
Sair (o overflow);
L.listsize = LIST_INIT_SIZE;
L.length = 0;
devolver o OK;
}
// função principal
int main () {
SqList L;
int OperationType; // tipo de operação
IF (! InitList_Sq (L) = o OK)
{
printf ( "InitList_Sq: falha de inicialização !!! \ n-");
retorno -1;
}
para (. int i = 1; I <= 10; i ++)
{
ListInsert_Sq (G, I, I);
}
printf ( " conjunto de operações (tabela seqüência) \ o n- ");
... printf (" 1 aumento \ n2 excluir \ n3 encontrar \ tabela de seqüência de saída n4 \ o n- ");
printf (" por favor insira o seguinte: ");
Scanf ( "% D", e OperationType);
o tempo (! OperationType = 0)
{
IF (OperationType == 1.) Para aumentar o funcionamento //
{
int POS, elem;
o printf ( "Por favor, insira o local inserido");
scanf ( "% D "e POS);
o printf (" Por favor entre o elemento de inserção ");
Scanf (" % D", e elem);
ListInsert_Sq (L, POS, elem);
}
else IF (OperationType == 2) // exclusão
{
int POS; elem int;
printf ( "Por favor introduza localização suprimido:");
Scanf ( "% d", & POS);
ListDelete_Sq (G, POS, elem);
printf ( "elemento excluído é% d \ n" , elem);
}
else IF (OperationType == 3) // encontrar posicionando operação.
{
int elem;
o printf ( "Por favor entre o elemento de encontrar");
Scanf ( "% D", e elem);
int ListLocate_Sq POS = (L ,elemento);
IF (Pos.> = POS 1 && <= L.length)
{
printf ( "posição do elemento é D% \ n-", POS);
}
else
{
printf ( "nenhum elemento tal tabela \ n-");
}
}
else if (OperationType == 4) // operação de saída
{
ListPrint_Sq (L);
}
else IF (OperationType == 0)
{
return 0;
}
else
{
printf ( "erro de entrada, por favor, re-entrar \ n-");
}
printf ( "Por favor de operação de entrada:");
Scanf ( "% D", & OperationType);
}
}
int ListInsert_Sq (SqList & G, POS, int e)
{
int * newbase; // primeiro endereço de expansão definida
se (pos > = pos. 1 && <+ = L.length. 1) // determinação pos de se para dentro da gama da L.length
{
if (L.length> = L.listsize)// Se L.length atingiu ou ultrapassou o valor ajustado , a capacidade é necessária
{
newbase = (int *) realloc (L.elem, (+ L.listsize LISTINCREMENT) * a sizeof (int)); // um alocada dinamicamente para newbase o novo comprimento da LISTINCREMENT espaço
(! newbase) se // erro é devolvido se a alocação falhar
retorno de erro;
L.elem = newbase; // endereço do novo grupo de espaço de alocação
L.listsize + = LISTINCREMENT; // espaço agora longa é igual ao comprimento do espaço original mais o comprimento do espaço recentemente alocado
}
int P *, Q *;
P = & (L.elem [pos - 1.]); // endereços atribuir à posição original do ponteiro elemento pos P
para (Q = & (L.elem [L.length - 1] ); q> = P; -q) // endereço originalmente atribuído tabela de sequência com a última posição dados q, e dados sequencialmente movido para a frente a partir de uma para tr pedaços
{
* (. 1 + Q) = Q *;
}
* P = e; e // dados para a posição de pos
++ L.length; // fim de aumentar um comprimento da mesa
devolver o OK;
}
else
retorno no OVERFLOW;
}
int ListDelete_Sq (G & SqList, POS, int & e)
{
SE (pos> = Posição 1 && <= L.length.) // POS determina se o comprimento da tabela de sequências
{
int * Q;
E = L.elem [pos - 1.]; // primeira atribuição de e, i que devolve o número de excluído
para (q = & (L.elem [ pos - 1]); q <= & (L.elem [L.length - 1]); q ++) // após os posição pos sequencialmente movido para a frente de um elemento
{
* = Q * (Q + 1.);
}
. L.length L.length = - 1; // Guardar um comprimento L
}
else
retorno no OVERFLOW;
}
int ListLocate_Sq (SqList L, E int )
{
int a = -1; // para um dado valor inicial, para encontrar se os dados na primeira vários, não pode ser de -1, de modo que a atribuição de -1
para (int i = 0; I <= L. comprimento @ 1; i ++) // loop for para encontrar
{
SE ([I] == L.elem E)
{
a = I;
break;
}
}
if (a> = 0 && a <L.length = -1)
retorno Um + 1; // Se um valor para atender aos requisitos, então um retorno
a outra pessoa
retorno de erro; // se um não for atendida, é devolvido um erro.
}
ListPrint_Sq vácuo (SqList L)
{
for (int i = 0; I <= L.length - 2; i ++)
{
printf ( "% D", [I] L.elem);
}
printf ( "% D", L.elem [L.length -1]);
}
