Inserir Classificação + Classificação da pilha 09 - Classificação 3 Inserção ou Classificação da pilha (25 pontos)

09-Classificação 3 Inserção ou Heap Sort (25 pontos)

De acordo com a Wikipedia:

A classificação de inserção itera, consumindo um elemento de entrada a cada repetição e aumentando uma lista de saída classificada. Cada iteração e classificação de inserção remove um elemento dos dados de entrada, localiza o local a que pertence na lista classificada e o insere lá. Ele se repete até que nenhum elemento de entrada permaneça.

A classificação de heap divide sua entrada em uma região classificada e uma região não classificada, e reduz iterativamente a região não classificada, extraindo o elemento maior e movendo-o para a região classificada. envolve o uso de uma estrutura de dados de heap em vez de uma pesquisa em tempo linear para encontrar o máximo.

Agora, dada a sequência inicial de números inteiros, juntamente com uma sequência resultante de várias iterações de algum método de classificação, você pode dizer qual método de classificação estamos usando?

Especificação de entrada:
cada arquivo de entrada contém um caso de teste. Para cada caso, a primeira linha fornece um número inteiro positivo N (≤100). Então, na próxima linha, N inteiros são dados como a sequência inicial. A última linha contém a sequência parcialmente classificada dos N números. Supõe-se que a sequência de destino esteja sempre ascendente. Todos os números em uma linha são separados por um espaço.

Especificação de saída:
para cada caso de teste, imprima na primeira linha “Classificação de inserção” ou “Classificação de pilha” para indicar o método usado para obter o resultado parcial. Em seguida, execute este método para mais uma iteração e produza na segunda linha a sequência resultante. É garantido que a resposta seja exclusiva para cada caso de teste. Todos os números em uma linha devem ser separados por um espaço e não deve haver espaço extra no final da linha.

Entrada de amostra 1:

10
3 1 2 8 7 5 9 4 6 0
1 2 3 7 8 5 9 4 6 0

Saída de amostra 1:

Insertion Sort
1 2 3 5 7 8 9 4 6 0

Entrada de amostra 2:

10
3 1 2 8 7 5 9 4 6 0
6 4 5 1 0 3 2 7 8 9

Saída de amostra 2:

Heap Sort
5 4 3 1 0 2 6 7 8 9

Resolução de problemas,
classificação de heap e classificação dividida, cada etapa é julgada;

1. Função de entrada
Por conveniência, T é usado para julgamento de classificação por inserção e I é usado para julgamento de classificação em pilha;

#include<iostream>
using namespace std;
#define MAXN 101

int N;
int T[MAXN]; 
int I[MAXN];
int Result[MAXN];
void input()
{
	cin>>N;
	for(int i=0;i<N;i++)
	cin>>T[i];
	
	for(int i=0;i<N;i++) I[i]=T[i];
	
	for(int i=0;i<N;i++)
	cin>>Result[i];
}

2. Inserir classificação + juiz

void InsertSort()
{
	int i;
	
	for(int i=1;i<N;i++)
	{
		int tmp=T[i];
		int j;
		for(j=i;j>0&&T[j-1]>tmp;j--)
			T[j]=T[j-1];
		T[j]=tmp;
		//判断是否与某一步骤吻合 
		int flag=1;
		
		for(int t=0;t<N;t++)
		{
			if(T[t]!=Result[t])
				{
					flag=0;
					break;
				 }	  
		}

		//执行输出 
		if(flag==1){
			cout<<"Insertion Sort"<<endl;
			tmp=T[i+1];
			for(j=i+1;j>0&&T[j-1]>tmp;j--)
				T[j]=T[j-1];
			T[j]=tmp;
			for(int t=0;t<N-1;t++)
			cout<<T[t]<<" ";
			cout<<T[N-1];
			break;
		}
	}
}

3. heapsort
função máximo de heap pia raiz
Precauções :
cada criança e comparar temperatura, temperatura maior do que o pai para a posição, se menos do que o achado criança do pai, temperatura para a posição do pai;
a esquerda O subscrito de filho é pai 2 + 1 e o direito é 2 pai + 2;

void PercDown(int parent,int n)    //根结点下沉 
{
	int child;
	int temp = I[parent];
	int p;
	for(p=parent;2*p+1<n;p=child)
	{
		child=p*2+1;
		if(child!=n-1&&I[child+1]>I[child])
		++child;

		if(I[child]>temp){     //堆排序关键——与temp比较，并非与parent比较 
			I[p]=I[child];
			
		}
		else break; 
	}
	
	I[p]=temp;
}

Converta a matriz de leitura no heap máximo:
afunde cada nó raiz de trás para frente ;
nota :
a coordenada do nó raiz inferior é n / 2-1, porque o primeiro número subscrito começa em 0;

void BuildHeap(int n)
{
	int i;
	
	for(i=n/2-1;i>=0;i--) 
	{
		PercDown(i,N);
	}
}

Função de classificação de heap + julgamento + função de troca
Cada vez que o cabeçalho e o final do heap são substituídos, o nó raiz afunda no número antes do final do heap.

void Swap(int &a,int &b)
{
	int temp=a;
	a=b;
	b=temp;
}


void HeapSort()
{
	BuildHeap(N); //变为最大堆
	
	for(int i=N-1;i>=0;i--)
	 {
	 	Swap(I[0],I[i]);
	 	PercDown(0,i);         //等于删除最小堆的一个元素，把堆尾放到头部下沉即可 
	 	
	 	//下沉后判断与result是否相同 
	 	int flag=1;
	 	for(int m=0;m<N;m++)
	 	{
	 		if(I[m]!=Result[m])
	 		{
	 			flag=0;
			 	break;
		 	}
			 }
		 	if(flag==1)
		 	{
		 		cout<<"Heap Sort"<<endl;
		 		Swap(I[0],I[i-1]);
				PercDown(0,i-1); 
				 
				cout<<I[0];
				for(int i=1;i<N;i++)
				cout<<" "<<I[i];
				return;
			 }
	 
}
}

Função 4.main

int main()
{
	input();
	BuildHeap(N);
	HeapSort();
	InsertSort();
}

Observe que a
classificação de heap é mais problemática;