Форум программистов, компьютерный форум CyberForum.ru

стеки - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 12, средняя оценка - 4.67
darkside
0 / 0 / 0
Регистрация: 21.12.2009
Сообщений: 12
02.04.2010, 19:10     стеки #1
Разработать функцию, которая формирует стек 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;
}
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
02.04.2010, 19:10     стеки
Посмотрите здесь:

C++ Стеки
Стеки C++
Стеки C++
C++ Стеки
C++ Стеки
Стеки C++
Стеки C++
C++ Стеки

Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Ответ Создать тему
Опции темы

Текущее время: 17:05. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru