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

Матрица - C++

Восстановить пароль Регистрация
 
Рейтинг: Рейтинг темы: голосов - 9, средняя оценка - 4.78
Hon-Sun
0 / 0 / 0
Регистрация: 05.02.2011
Сообщений: 11
05.02.2011, 21:10     Матрица #1
Как можно все нулевые элементы размещать в верхней части матрицы?Если у нас есть int NN - размерность матрицы; int SIZE - количество ненулевых элементов в матрице;
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
05.02.2011, 21:10     Матрица
Посмотрите здесь:

матрица C++
матрица C++
C++ матрица
C++ Матрица
C++ Матрица
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
fridi
-8 / 40 / 1
Регистрация: 21.09.2009
Сообщений: 145
05.02.2011, 21:20     Матрица #2
отсортировать ее все нулевые элементы
например так
0,0,0,0,1,2,3,4,5,6 и т.д
Hon-Sun
0 / 0 / 0
Регистрация: 05.02.2011
Сообщений: 11
05.02.2011, 21:30  [ТС]     Матрица #3
Помогите, пожалуйста!?

Добавлено через 9 минут
Можете подробно написать? Если у меня трехмерная матрица: какая часть верхная, и какая часть нижная. Я не могу определить это. Вот постановка задачи: Для разряженной матрицы целых чисел в соответствии с индивидуальным заданием создать модуль доступа к ней, у котором обеспечить экономию памяти при размещении данных.

Функция write_matr предназначена для записи элемента в матрицу. Прототип функции:
int write_matr(int x, int y, int value);
где x и y - координаты (строка и столбец), value - то значение, которое нужно записать. Функция возвращает значение параметра value, или 0 - если была попытка записи в нулевой участок. Если после выполнения функции значение переменной L2_RESULT -1, то это указывает на ошибку при обращении.

Выполнение функции подобно функции read_matr с тем отличием, что, если координаты указывают на ненулевой участок, то функция записывает value в массив m_addr.

Функция ch_coord предназначена для проверки корректности задания координат. Эта функция описана как static и поэтому может вызываться только из этого же модуля. Прототип функции:
static char ch_coord(int x, int y);
где x и y - координаты (строка и столбец). Функция возвращает 0, если координаты верные, -1 - если неверные. Соответственно, функция также устанавливает значение глобальной переменной L2_RESULT.

Функция lin предназначена для преобразования двумерных координат в индекс в одномерном массиве. Эта функция описана как static и поэтому может вызываться только из этого же модуля. Прототип функции:
static int lin(int x, int y);
где x и y - координаты (строка и столбец). Функция возвращает координату в массиве m_addr.
fridi
-8 / 40 / 1
Регистрация: 21.09.2009
Сообщений: 145
05.02.2011, 21:48     Матрица #4
ну а че писать, просто искать надо нулевой элемент в трех мерной матрицы либо толкать его на верх тоесть простая сортировка пузырком, либо создовать новую матрицу копировать вначале туда все нулевые элементы а потом не нулевые и у тебя получится примерно тоже самое но геморно, вот соб-но сам принцип.
123
213
001
213
---- если текущий элемент равен нулю меняем местами с верхним который не равен нулю
023
213
101
213
примерно так, тока у тебя матрица как я понимаю трех мерная..
Hon-Sun
0 / 0 / 0
Регистрация: 05.02.2011
Сообщений: 11
05.02.2011, 22:00  [ТС]     Матрица #5
Тут пример решения матрицы который содержит нули ниже главной диагонали; А мне нужно все нулевые элементы размещены в верхней части матрицы
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
/************************* Файл LAB2.C *************************/
/* В этом файле определены функции и переменные для обработки
   матрицы, заполненной нулями ниже главной диагонали          */
#include <alloc.h>
static int NN;                          /* Размерность матрицы */
static int SIZE;                              /* Размер памяти */
static int *m_addr=NULL;               /* Адрес сжатой матрицы */
static int lin(int, int);     /* Описание функции линеаризации */
static char ch_coord(int, int);   /* Описание функции проверки */
int L2_RESULT;              /* Внешняя переменная, флаг ошибки */
 
/*********************************************************/
/*            Выделение памяти под сжатую матрицу        */
int creat_matr ( int N ) {
   /* N - размер матрицы */
   NN=N;
   SIZE=N*(N-1)/2+N;
   if ((m_addr=(int *)malloc(SIZE*sizeof(int))) == NULL )
      return L2_RESULT=-1;
   else
      return L2_RESULT=0;
/* Возвращает 0, если выделение прошло успешно, иначе -1 */
}
/**************************************************************/
/*       Уничтожение матрицы (освобождение памяти)            */
int close_matr(void) {
   if ( m_addr!=NULL ) {
      free(m_addr);
      m_addr=NULL;
      return L2_RESULT=0;
      }
   else return L2_RESULT=-1;
/*  Возвращает 0, если освобождение пршло успешно, иначе - -1  */
}
/***********************************************************/
/*     Чтение элемента матрицы по заданным координатам     */
int read_matr(int x, int y) {
   /* x, y -координати (строка, столбец) */
   if ( ch_coord(x,y) ) return 0;
   /* Если координаты попадают в нулевой участок - возвращается
      0, иначе - применяется функция линеаризации */
   return (x > y) ? 0 : m_addr[lin(x,y)];
   /* Проверка успешности чтения - по переменной
      L2_RESULT:  0 - без ошибок, -1 - была ошибка */
}
 
/*************************************************************/
/*      Запись элемента матрицы по заданным координатам      */
int write_matr(int x, int y, int value) {
   /* x, y -координати, value - записываемое значение */
   if ( chcoord(x,y) ) return;
   /* Если координаты попадают в нулевой участок - записи нет, 
      иначе - применяется функция линеаризации */
   if ( x > y ) return 0;
   else return m_addr[lin(x,y)]=value;
   /* Проверка успешности записи - по L2_RESULT */
}
 
/************************************************************/
/*       Преобразование 2-мерних координат в линейную       */
/*                      (вариант 3)                         */
static int lin(int x, int y) {
   int n;
    n=NN-x;
   return SIZE-n*(n-1)/2-n+y-x;
}
 
/***************************************************************/
/*                  Проверка корректности обращения            */
static char ch_coord(int x, int y) {
   if ( ( m_addr==NULL ) ||
        ( x>SIZE ) || ( y>SIZE ) || ( x<0 ) || ( y<0 ) )
      /* Если матрица не размещена в памяти, или заданные
         координаты выходят за пределы матрицы */
       return L2_RESULT=-1;
    return L2_RESULT=0;
}
/*********************Конец файла LAB2.C ***********************/
Помогите пожалуйста подскажите что и где нужно поменять?
Я понимаю что у вас есть и более важные дела, но пожалуйста если это для вас не тяжело помогите пожалуйста
Евгений М.
1033 / 974 / 53
Регистрация: 28.02.2010
Сообщений: 2,817
Завершенные тесты: 2
06.02.2011, 06:33     Матрица #6
Вроде уже было.
http://www.cyberforum.ru/cpp-beginne...ead238254.html
Hon-Sun
0 / 0 / 0
Регистрация: 05.02.2011
Сообщений: 11
06.02.2011, 12:38  [ТС]     Матрица #7
Да, они похожи. Но я не могу решить эту задачу: все нулевые элементы размещены в верхней части матрицы. Если сможете, помогите мне.

Добавлено через 12 минут
Я там кое-что сделала. Но не получается.Вы можете посмотрить
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
 
/* В этом файле определены функции и переменные для обработки
   матрицы, заполненной нулями ниже главной диагонали          */
//#include <stdio.h>
#include /*<alloc.h>*/<stdlib.h>
static int NN;                          /* Размерность матрицы */
static int SIZE;                              /* Размер памяти */
static int *m_addr=NULL;               /* Адрес сжатой матрицы */
static int lin(int, int);     /* Описание функции линеаризации */
static char ch_coord(int, int);   /* Описание функции проверки */
//static int getNN () {return NN; };
int L2_RESULT;              /* Внешняя переменная, флаг ошибки */
 
/*********************************************************/
/*            Выделение памяти под сжатую матрицу        */
int creat_matr ( int N ) {
   /* N - размер матрицы */
  // NN=N;
   SIZE=(NN%2)*((NN%2)-2)/2+(NN%2);
   if ((m_addr=(int *)malloc(SIZE*sizeof(int)))==NULL)
      return L2_RESULT=-1;
   else
      return L2_RESULT=0;
/* Возвращает 0, если выделение прошло успешно, иначе -1 */
}
/**************************************************************/
/*       Уничтожение матрицы (освобождение памяти)            */
int close_matr(void) {
   if ( m_addr!=NULL ) {
      free(m_addr);
      m_addr=NULL;
      return L2_RESULT=0;
      }
   else return L2_RESULT=-1;
/*  Возвращает 0, если освобождение пршло успешно, иначе - -1  */
}
/***********************************************************/
/*     Чтение элемента матрицы по заданным координатам     */
int read_matr(int x, int y) {
   /* x, y -координати (строка, столбец) */
   if ( ch_coord(x,y) ) return 0;
   /* Если координаты попадают в нулевой участок - возвращается
      0, иначе - применяется функция линеаризации */
   return (y < x) ? 0 : m_addr[lin(x,y)];
   /* Проверка успешности чтения - по переменной
      L2_RESULT:  0 - без ошибок, -1 - была ошибка */
}
 
/*************************************************************/
/*      Запись элемента матрицы по заданным координатам      */
int write_matr(int x, int y, int value) {
   /* x, y -координати, value - записываемое значение */
   if ( ch_coord(x,y) ) 
           return 0;
   /* Если координаты попадают в нулевой участок - записи нет, 
      иначе - применяется функция линеаризации */
   if ( y < x )
           return 0;
   else 
           return m_addr[lin(x,y)]=value;
   /* Проверка успешности записи - по L2_RESULT */
}
 
/************************************************************/
/*       Преобразование 2-мерних координат в линейную       */
/*                      (вариант 3)                         */
static int lin(int x, int y) {
   int n;
   //int NN;
    n=(NN%2)-x;
   return SIZE-2(n-1)+n-y;
 
}
 
/***************************************************************/
/*                  Проверка корректности обращения            */
static char ch_coord(int x, int y) {
   if ( ( m_addr==NULL ) ||
        ( x>SIZE ) || ( y>SIZE ) || ( x<0 ) || ( y<0 ) )
      /* Если матрица не размещена в памяти, или заданные
         координаты выходят за пределы матрицы */
       return L2_RESULT=-1;
    return L2_RESULT=0;
}
almazsr
06.02.2011, 13:15
  #8

Не по теме:

Hon-Sun, все-таки что у вас за препод-извращенец...

MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
06.02.2011, 13:22     Матрица
Еще ссылки по теме:

С++ матрица C++
C++ матрица...
C++ матрица

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

Или воспользуйтесь поиском по форуму:
Евгений М.
1033 / 974 / 53
Регистрация: 28.02.2010
Сообщений: 2,817
Завершенные тесты: 2
06.02.2011, 13:22     Матрица #9
Hon-Sun, Переписать код для обращения к элементам матрицы, находящимся выше главной диагонали
Yandex
Объявления
06.02.2011, 13:22     Матрица
Ответ Создать тему
Опции темы

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