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

Матрица представлена односвязным списком. Объединение 2 программ - C++

Восстановить пароль Регистрация
 
linuxubuntu
3 / 3 / 0
Регистрация: 06.11.2011
Сообщений: 55
28.12.2012, 23:36     Матрица представлена односвязным списком. Объединение 2 программ #1
Само задание: разряженная матрица переменной размерности, ненулевые коэффициенты представлены односвязным списком x,y,v где x,y - координаты элемента в матрице; v - его значение.
Имеются 2 программы. В первой программе работают функции добавления элемента в матрицу, удаление элемента из матрицы, удаление матрицы, получение элемента, вывод матрица на экран.
Во второй программе имеются функции перегрузки арифметических операций +,-,=,>,<,== но некоректно работает функция добавления элемента в матрицу.
Кому не сложно посмотрите код двух программ и кто сможет объедините их в одну программу, в которой коректно работали бы все функции.
Заранее спасибо.

Первая программа:
Кликните здесь для просмотра всего текста
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
//main.cpp
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <math.h>
#include "matrix.h"
using namespace std;
 
int main()
{
     char a;
     int flag = 1, n, m;
     cout << "Введите число строк: ";
     cin >> n;
     cout << "Введите число столбцов: ";
     cin >> m;
     Matrix T(n,m);    
     while(flag)
     {
            cout << "\nВыберите пункт в меню:\n";
            cout << "0 - Выход из программы\n";
            cout << "1 - Добавить новый элемент\n";
            cout << "2 - Очистить матрицу\n";
            cout << "3 - Вывести матрицу на экран\n";
            cout << "4 - Получить элемент\n";
            cout << "5 - Удалить элемент\n";
            cout << endl;
            a = getch();
 
            switch(a)
            {
                 case '0': flag=0; break;
                 case '1':
                 {
                        int x, y, v;
                        cout << "Введите x: ";
                        cin >> x;
                        cout << "Введите y: ";
                        cin >> y;
                        cout << "Введите значение: ";
                        cin >> v;
                        T.Add(x-1,y-1,v);
                        break;
                 }
                 case '2': {T.clear(); break;}
                 case '3': {T.print(); break;}
                 case '4':
                 {
                        int x, y;
                        cout << "Введите x: ";
                        cin >> x;
                        cout << "Введите y: ";
                        cin >> y;
                        cout << T.Get(x-1, y-1);
                        break;
                 }
                 case '5':
                 {
                        int x, y;
                        cout << "Введите x: ";
                        cin >> x;
                        cout << "Введите y: ";
                        cin >> y;
                        T.Remove(x-1,y-1);
                        break;
                 }
                 default: cout << "Неккоректное значние! " << endl;
            }
     };
     getch();
}
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
//matrix.cpp
#include "matrix.h"
#include <iostream>
using namespace std;
 
//MATRIX
Matrix::Matrix()
{
     n = 1;
     m = 1;
     List = new LinkList;
}
 
Matrix::Matrix(int _n, int _m)
{
     n=_n;
     m=_m;
     List = new LinkList;
}
 
Matrix::~Matrix()
{
     delete List;
}
 
int Matrix::GetElementByXY(int i, int j)
{
     return List->Get(i, j);
}
 
void Matrix::clear()
{
     delete List;
     List = new LinkList;
}
 
int Matrix::Get(int i, int j)
{
     if (i<n && j<m)
            return GetElementByXY(i, j);
     return 0;
}
 
void Matrix::Add(int i, int j, int value)
{
   if (i>=n && j>=m) return;
      List->Remove(i,j);
   List->Add(i,j,value);
}
 
void Matrix::Remove(int i, int j)
{
   if (i>=n && j>=m) return;
   List->Remove(i,j);
}
 
void Matrix::print()
{
     int i,j;
     for(i=0; i<n; i++)
     {
            for(j=0; j<m; j++)
                 cout << GetElementByXY(i,j) << "  ";
     cout << "\n";
     }
}
 
int Matrix::equal(Matrix M)
{
     if (n == M.n && m == M.n)
     {
            int i,j, eq=0, gr=0, les=0;
            for (i=0; i<n; i++)
            for (j=0; j<m; j++)
            {
                 if (GetElementByXY(i,j)==M.GetElementByXY(i,j)) eq++;
                 if (GetElementByXY(i,j)>=M.GetElementByXY(i,j)) gr++;
                 if (GetElementByXY(i,j)<=M.GetElementByXY(i,j)) les++;
            }
            if (eq == n*m) return 0;
            if (gr == n*m) return 1;
            if (les == n*m) return -1;
     }
     return -2;
}
 
Matrix& Matrix::plus(Matrix *M)
{
     if (n!=M->n || m!=M->m) return *this;
     else
     {
            List->plus(M->List);
     }
     return *this;
}
 
Matrix& Matrix::minus(Matrix *M)
{
     if (n!=M->n || m!=M->m) return *this;
     else
     {
            List->minus(M->List);
     }
     return *this;
}
 
//LINK_LIST
 
LinkList::LinkList()
{
     head = 0;
     end = 0;
}
 
LinkList::~LinkList()
{
     clear();
}
 
LinkList::LinkList(const LinkList& stack)
{
  head = stack.head;
  //head = 0;
  *this = stack;
}
 
void LinkList::Add(int i, int j, int value)
{
     if (head == 0)
     {
            Node *item = new Node;
            item->next = item;
            item->x = i;
            item->y = j;
            item->v = value;
            head = end = item;
     }
   else
   {
      Node *item = new Node;
      item->x = i;
      item->y = j;
      item->v = value;
      item->next = head;
      end->next = item;
      end = item;
   }
}
 
void LinkList::Remove(int i, int j)
{
   if (!head) return;
   Node *curr = head;
   do
   {
      if (curr->x == i && curr->y == j)
      {
         if (curr == head)
         {
            head = 0;
            end = 0;
         }
         delete curr;
         return;
      }
      curr = curr->next;
   } while (curr !=head);
}
 
int LinkList::Get(int i, int j)
{
   if (!head) return 0;
   Node *curr = head;
   do
   {
      if (curr->x == i && curr->y == j)
      {
         return curr->v;
      }
      curr = curr->next;
   } while (curr !=head);
   return 0;
}
 
void LinkList::clear()
{
   if (!head) return;
   Node *curr = head;
   do
   {
      Node *tmp;
      tmp = head;
      delete tmp;
      head = head->next;
   } while (head !=curr);
   head = 0;
   end = 0;
}
 
void LinkList::print()
{
   if (!head) return;
   Node *curr = head;
   do
   {
      cout << "{" << curr->x << ", " << curr->y << ", " << curr->v << "} ";
      curr = curr->next;
   } while (curr !=head);
}
 
int LinkList::find(int i, int j)
{
   if (!head) return 0;
   Node *curr = head;
   do
   {
      if (curr->x == i && curr->y == j)
      {
         return 1;
      }
      curr = curr->next;
   } while (curr !=head);
   return 0;
}
 
LinkList& LinkList::plus(LinkList *a)
{
   if (!a->head) return *this;
   Node *curr = head;
   do
   {
      if (a->find(curr->x, curr->y))
      {
         curr->v = curr->v + a->Get(curr->x, curr->y);
      }
      curr = curr->next;
   } while (curr !=head);
   Node *curra = a->head;
   do
   {
      if (!find(curra->x, curra->y))
      {
         Add(curra->x, curra->y, curra->v);
      }
      curra = curra->next;
   } while (curra !=a->head);
   return *this;
}
 
LinkList& LinkList::minus(LinkList *a)
{
   if (!a->head) return *this;
   Node *curr = head;
   do
   {
      if (a->find(curr->x, curr->y))
      {
         curr->v = curr->v - a->Get(curr->x, curr->y);
      }
      curr = curr->next;
   } while (curr !=head);
   Node *curra = a->head;
   do
   {
      if (!find(curra->x, curra->y))
      {
         Add(curra->x, curra->y, -curra->v);
      }
      curra = curra->next;
   } while (curra !=a->head);
   return *this;
}
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
//matrix.h
#ifndef __MATRIX_H__
#define __MATRIX_H__
 
class LinkList {
 
private:
        
      struct Node
      {
        int x,y;
        double v;
        Node *next;
      } *head, *end;
      
      int find(int i, int j);
      
public:
       
      LinkList();
      ~LinkList();
      
      void Add(int i, int j, int value);
      void Remove(int i, int j);
      int Get(int i, int j);
      void print();
      void clear();
      LinkList(const LinkList&);
      
      LinkList& plus(LinkList *a);
      LinkList& minus(LinkList *a);
};
 
class Matrix {
 
private:
 
   int n, m;
   LinkList *List;
 
   int GetElementByXY(int i, int j);
 
public:
 
     Matrix();
     Matrix(int _n, int _m);
     ~Matrix();
 
     void Add(int i, int j, int value);
     void Remove(int i, int j);
     int Get(int i, int j);
     void print();
     void clear();
     
     Matrix& plus(Matrix *M);
     Matrix& minus(Matrix *M);
     int equal(Matrix M);
 
};
#endif

Вторая программа:
Кликните здесь для просмотра всего текста
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
//main.cpp
#include <stdio.h>
#include <conio.h>
#include <iostream>
#include <math.h>
#include "matrix.h"
 
using namespace std;
 
int main()
{
    elem_matr *spisok;
    int count,count_;//количество элементов в списке
    int i;
    int size,size_;//размер матрицы
 
    printf("Сколько ненулевых элементов матрицы будет?: ");
    scanf("%d",&count);
    spisok=new elem_matr[count];
    size=0;
    for(i=0;i<count;i++)
    {
        printf("Задаём %d ненулевой элемент матрицы\n",(i+1));
        printf("x = ");
        scanf("%d",&spisok[i].x);
            if (spisok[i].x>size) size=spisok[i].x;
        printf("y = ");
        scanf("%d",&spisok[i].y);
            if (spisok[i].y>size) size=spisok[i].y;
        printf("v = ");
        scanf("%lf",&spisok[i].v);
    }
    
    matr bezparam();
    matr s_razmerom(count,size);
    matr s_razmerom_spiskom(spisok,count,size);
    //matr s_razmerom_spiskom_2(spisok,count,size);
    //matr x(spisok,count_,size_);
    //s_razmerom_spiskom_2.show_matr();
    s_razmerom_spiskom.show_matr();
    //x=s_razmerom_spiskom+s_razmerom_spiskom_2;
    //x.show_matr();
    //s_razmerom_spiskom_3=s_razmerom_spiskom_1-s_razmerom_spiskom_2;
    //s_razmerom_spiskom_3.show_matr();
    
 
    //matr copy(s_razmerom_spiskom_3);
 
    getch();
}
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
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
//matrix.cpp
#include "matrix.h"
#include <iostream>
 
using namespace std;
matr::matr()
{
    head=NULL;
    size=0;
    count=0;
}
 
matr::matr(int count,int size)
{
    head=NULL;
    matr::size=size;
    matr::count=count;
}
 
matr::~matr()
{
    clear();
}
 
matr::matr(elem_matr list[],int count,int size)
{
    
    int i;
    this->size=size;//первый способ
    matr::count=count;//второй способ
    head=NULL;
    for(i=0;i<count;i++)
    {
        add_end(list[i].x,list[i].y,list[i].v);
    }
 
}
 
matr::matr(matr &T)
{
    load(T);    
}
 
void matr::add_end(int x_,int y_, double v_)
{
        if (head==NULL)
        {
            elem_matr_list* item = new elem_matr_list;
            item->next = item;
            item->x=x_;
            item->y=y_;
            item->v=v_;
            head = end = item;
 
        }
        else
        {
            end->next = new elem_matr_list;
            end=end->next;
            
            end->x=x_;
            end->y=y_;
            end->v=v_;
 
            end->next=NULL;
        }
    
 
}
 
/*void LinkList::Add(int i, int j, int value)
{
     if (head == 0)
     {
            Node *item = new Node;
            item->next = item;
            item->x = i;
            item->y = j;
            item->v = value;
            head = end = item;
     }
   else
   {
      Node *item = new Node;
      item->x = i;
      item->y = j;
      item->v = value;
      item->next = head;
      end->next = item;
      end = item;
   }
}
*/
void matr::load(matr &T)
{
    size=T.size;
    count=T.count;
 
    elem_matr_list *cur;
    cur=T.head;
 
    head=NULL;
 
    while(cur!=NULL)
    {
        add_end(cur->x,cur->y,cur->v);
        cur=cur->next;
    }
}
 
 
 
void matr::clear()
{
 
    elem_matr_list *cur;
    elem_matr_list *cur_ud;
 
    cur=head;
    cur_ud=head;
 
    do
    {
        cur=cur->next;
        delete(cur_ud);
        cur_ud=cur;
    }while(cur_ud!=NULL);
}
 
 
void matr::show_matr()
{
    int i;
    int j;
    int q;
    elem_matr_list *cur;
    bool flag;
    for (i=0;i<size;i++)
    {
        for (j=0;j<size;j++)
        {
            cur=head;
            flag=false;
 
            while(cur!=NULL && flag==false)
            {
                if (cur->x==(j+1) && cur->y==(i+1))
                {
                    printf("%10.2lf",cur->v);
                    flag=true;
                }
                cur=cur->next;
            }
 
            if (flag==false) printf("%10.2lf",0);
        }
        printf("\n");
    }   
 
}
 
void matr::addition(matr &T)
{
    if (size==T.size)
    {
    elem_matr_list *cur=head;
    elem_matr_list *cur2=T.head;
 
    while (cur!=NULL)
    {
            if (cur->x==cur2->x && cur->y==cur2->y)
                cur->v+=cur2->v;
            else 
                add_end(cur2->x,cur2->y,cur2->v);
    cur2=cur2->next;
    cur=cur->next;
    }
    }
    else
        printf("Сложение невозможно, матрицы разного размера");
 
}
 
void matr::substruction(matr &T)
{
    if (size==T.size)
    {
    elem_matr_list *cur=head;
    elem_matr_list *cur2=T.head;
 
    while (cur!=NULL)
    {
            if (cur->x==cur2->x && cur->y==cur2->y)
                cur->v-=cur2->v;
            else 
                add_end(cur2->x,cur2->y,(cur2->v)*-1);
    cur2=cur2->next;
    cur=cur->next;
    }
    }
    else
        printf("Вычитание невозможно, матрицы разного размера");
 
}
 
 
int matr::compare(matr &T)
{
    if (size==T.size)
    {
    elem_matr_list *cur=head;
    elem_matr_list *cur2=T.head;
    double sum=0,sum2=0; 
    while (cur!=NULL)
    {
        sum+=cur->v;
        sum2+=cur2->v;
    cur2=cur2->next;
    cur=cur->next;
    }
    if (sum>sum2) return 1;
    else if (sum<sum2) return -1;
    else return 0;
    }
    else
        printf("Сравнение невозможно, матрицы разного размера");
 
}
 
matr &matr::operator+(matr&T)
{
    matr R(T);
    R.addition(T);
    return R;
}
 
matr &matr::operator-(matr&T)
{
    matr R(T);
    R.substruction(T);
    return R;
}
 
//**********
matr &matr::operator=(matr&T)
{
 
    matr R(T);
    R.load(T);
    return R;
}
 
bool matr::operator<(matr&T)
{
    matr *R=new matr(*this);
    int n = (*R).compare(T);
    if (n==-1) return true;
    else if (n==1) return false;
}
 
bool matr::operator>(matr&T)
{
    matr *R=new matr(*this);
    int n = (*R).compare(T);
    if (n==-1) return false;
    else if (n==1) return true;
}
 
bool matr::operator==(matr&T)
{
    matr *R=new matr(*this);
    int n = (*R).compare(T);
    if (n==0) return true;
    else return false;
}
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
//matrix.h
#ifndef __MATRIX_H__
#define __MATRIX_H__
 
struct elem_matr
{
    int x,y;
    double v;
};
 
 
 
class matr
{   
 
private:
        
struct elem_matr_list
{
    int x,y;
    double v;
    elem_matr_list *next;
}*head,*end;
 
    int size;
    int count;
public:
    matr();
    matr(int count,int size);
    matr(elem_matr list[],int count,int size);
    matr(matr &T);
    ~matr();
 
    void load(matr &T);
    void show_matr();
    void add_end(int x_,int y_, double v_);
    void add(int x_,int y_, double v_);
    void clear();
    void addition(matr &T);
    void multipli(matr &T);
    void substruction(matr &T);
    int compare(matr &T);
 
 
    matr& operator+(matr&);
    matr& operator-(matr&);
    matr& operator=(matr&);
 
    bool operator>(matr &T);
    bool operator<(matr &T);
    bool operator==(matr &T);
};
#endif
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
28.12.2012, 23:36     Матрица представлена односвязным списком. Объединение 2 программ
Посмотрите здесь:

Задача с односвязным и двухсвязным списком (сортировка). C++
C++ Работа с односвязным списком
C++ Работа с односвязным линейным списком
Ошибки связанные с односвязным списком C++
C++ Полиморфизм в сочетании с односвязным списком
Реализация с односвязным списком C++
C++ Задача с односвязным списком
C++ Работа с односвязным списком

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

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

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