стеки
02.04.2010, 19:10. Показов 3103. Ответов 0
Разработать функцию, которая формирует стек Stack, включив в него по одному разу элементы, которые входят в стек Stack1, но не входят в стек Stack2.
все работает,но во второй стек включаются элементы сколько бы раз они не встречались,а нужно строго по одному..плиз помогите если кто может=((
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| //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); |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
| //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;
} |
|
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| //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;
} |
|
0
|
(
