Разработать функцию, которая формирует стек Stack, включив в него по одному разу элементы, которые входят в стек Stack1, но не входят в стек Stack2. все работает,но во второй стек включаются элементы сколько бы раз они не встречались,а нужно строго по одному..плиз помогите если кто может=(( | Код |
//mystack.h
#pragma once
#define MYSTACK_ESE 0x0000// возврат в случае пустоты стека
#define MYSTACK1_EXC 200
//*************************************************************************
struct Stack // блок управления стеком
{
int Top; // вершина стека
int Size; // размер стека
void** Storage; // хранилище данных стека
};
//*************************************************************************
struct StackException
{
int Code;
#define MYSTACK1_EXC_OVERFLOW MYSTACK1_EXC + 1
#define MYSTACK1_EXC_POPEMPTY MYSTACK1_EXC + 2
#define MYSTACK1_EXC_PEEKEMPTY MYSTACK1_EXC + 3
#define MYSTACK1_EXC_APPOVERFLOW MYSTACK1_EXC + 4
#define MYSTACK1_EXC_COPYOVERFLOW MYSTACK1_EXC + 5
char Msg[100];
#define MYSTACK1_EXC_OVERFLOW_MSG "Stack overfow"
#define MYSTACK1_EXC_EMPTY_MSG "Stack empty"
const Stack *St;
StackException (int code, char msg[],const Stack* st);
};
//*************************************************************************
extern Stack CreateStack(int n); // выделить ресурса для стека
Stack CreateStack(const Stack& ps); // создать стек по образцу
bool Push(Stack& s, void* x); // добавить x на вершину стека s
void* Pop(Stack& s); // удалить элемент с вершины стека s
void* Peek(const Stack& s); // получить вершину стека
bool isStackFull(const Stack& s); // стек заполнен ?
bool isStackEmpty(const Stack& s); // стек пуст ?
int ClearStack(Stack& s); // очистить стек s
void ReleaseStack(Stack& s); // освободить ресурсы стека
bool CopyStack(Stack& to, const Stack& from);
bool AppendStack(Stack& to, const Stack& from);
Stack CrtStack(Stack& s1, Stack& s2);
|
| Код |
//mystack.cpp
#include "stdafx.h"
#include <string.h>
#include "Mystack.h"
#include <iostream>
//*************************************************************************
Stack CreateStack(int n)
{
Stack *s = new Stack;
s->Top = -1;
s->Size = n;
s->Storage = new void*[n];
return *s;
}
//*************************************************************************
Stack CreateStack(const Stack& ps) // создать стек по образцу
{
Stack *s = new Stack;
s->Storage = new void*[s->Size = ps.Size];
for (int i = 0; i <= (s->Top = ps.Top); i++) s->Storage[i] = ps.Storage[i];
return *s;
}
//*************************************************************************
bool isStackFull(const Stack& s) // стек заполнен ?
{
return (s.Top >= s.Size-1);
}
//*************************************************************************
bool isStackEmpty(const Stack& s) // стек пуст ?
{
return (s.Top < 0);
}
//*************************************************************************
void* Pop(Stack& s) // удалить элемент с вершины стека s
{
void* vp = (void*)MYSTACK_ESE;
if (!isStackEmpty(s)) vp = s.Storage[s.Top--];
else throw StackException(MYSTACK1_EXC_POPEMPTY,MYSTACK1_EXC_EMPTY_MSG, &s);
return vp;
}
//*************************************************************************
bool Push(Stack& s, void* x) // добавить x на вершину стека s
{
bool vp = true;
if (vp = !isStackFull (s)) s.Storage[++(s.Top)] = x;
else throw StackException(MYSTACK1_EXC_OVERFLOW, MYSTACK1_EXC_OVERFLOW_MSG, &s);
return vp;
}
//*************************************************************************
void* Peek(const Stack& s) // получить вершину стека
{
void* vp = (void*)MYSTACK_ESE;
if (!isStackEmpty(s)) vp = s.Storage[s.Top];
else throw StackException(MYSTACK1_EXC_PEEKEMPTY, MYSTACK1_EXC_EMPTY_MSG, &s);
return vp;
}
//*************************************************************************
int ClearStack(Stack& s)
{
int w=s.Top+1;
s.Top=-1;
return w;
}
//*************************************************************************
void ReleaseStack(Stack& s)
{
s.Size=0;
s.Top=-1;
delete[] s.Storage;
}
//*************************************************************************
bool AppendStack(Stack& to, const Stack& from)
{
try
{
bool rc = true;
for (int i = 0; i<= from.Top && rc; i++) rc=Push(to, from.Storage[i]);
return rc;
}
catch (StackException se) { throw StackException(MYSTACK1_EXC_APPOVERFLOW, se.Msg, se.St);}
}
//*************************************************************************
bool CopyStack(Stack& to, const Stack& from)
{
ClearStack(to);
bool rc=false;
try
{
rc=AppendStack(to,from);
}
catch (StackException se) {throw StackException(MYSTACK1_EXC_COPYOVERFLOW, se.Msg, se.St);}
return rc;
}
//*************************************************************************
StackException::StackException(int code, char msg[], const Stack *st)
{
Code=code;
strcpy_s(Msg,sizeof(Msg),msg);
St=st;
}
Stack CrtStack(Stack& s1, Stack& s2)
{
int n=0; //будет размер стека s
for (int i = 0; i < s1.Size; i++)
{
int j=0;
while((*(int*)(s1.Storage[i])!=*(int*)(s2.Storage[j]))&&(++j<s2.Size));//(cодержимое) элем одного стека
//не равен содержимому другого
//и индекс след элем-а 2го стека не выходит за пределы его размера
//т.е находим сколько различный элем-ов в стеках(это и будет размер нового)
if (j== s1.Size)n++; //если индекс равен размеру 1го стека наращиваем n
}
Stack *s = new Stack; //создаем новый стек s
s->Top = -1; //его вершина -1
s->Size = n; //его размер n
s->Storage = new void*[n]; //его содержимое
for (int i = 0; i < s1.Size; i++)
{
int j=0;
while((*(int*)(s1.Storage[i])!=*(int*)(s2.Storage[j]))&&(++j<s2.Size));//j++ пока он не будет размера 2го стека
if (j== s1.Size)
if (bool vp = !isStackFull (*s)) s->Storage[++(s->Top)] = (s1.Storage[i]);
//пишем в новый стек элем-ы 1го стека
//кот-ых нет во 2ом
//top c 0(т к был -1)
else throw StackException(MYSTACK1_EXC_OVERFLOW, MYSTACK1_EXC_OVERFLOW_MSG, s);
}
return *s;
}
|
| Код |
//main.cpp
#include "stdafx.h"
#include "Mystack.h"
#include <iostream>
#include "time.h"
#define N 10
int irand(int min,int max)
{
return (int)(((double)rand()/(double)RAND_MAX)*(max-min)+min);
}
void FillArray(int arr[],int n)
{ for (int i=0;i<n;i++)
arr[i]=irand(0,10);
}
int _tmain(int argc, _TCHAR* argv[])
{srand((unsigned)time(NULL));
int a[N];
int b[N];
FillArray(a, N);
FillArray(b, N);
Stack s1,s2,sn;
s1=CreateStack(sizeof(a)/sizeof(int));
for (int i=0;i<N;i++)
Push(s1,(void*)(a+i)); // добавить элем на вершину стека s1
s2=CreateStack(sizeof(b)/sizeof(int));
for (int i=0;i<N;i++)
Push(s2,(void*)(b+i)); // добавить элем на вершину стека s2
sn=CrtStack(s1,s2); //выполняем ф-ию
for(int i=0; i<sn.Size;i++)
std::cout<<*((int*)Pop(sn))<<" "; //выводим элем-ы нового стека
std::cout<<std::endl;
for (int i=0;i<N;i++)
{
std::cout<<*((int*)Pop(s1))<<" ";
}
std::cout<<std::endl;
for (int i=0;i<N;i++)
{
std::cout<<*((int*)Pop(s2))<<" ";
}
std::cout<<std::endl;
return 0;
}
|
|
стек 
Дата 2.4.2010, 18:12 (
Загрузка ...
