sparse

#include <stdio.h>
#include<stdlib.h>

using namespace std;

struct Element
{
  int i;
  int j;
  int x;
}

struct Sparse
{
  int row;
  int col;
  int num;
  struct Element *e;
}

void create(struct Sparse *s)
{
  int i, j,k, x;
  printf("Enter the dimensions\n");
  scanf("%d%d", &i, &j);
  s->row = i;
  s->col = j;
  printf("Enter the num of elements\n");
  scanf("%d", &k);
  s->num = k;
  s->e = (struct Element*) malloc(sizeof(struct Element) * k);
  printf("Enter the Sparse Matrix\n");
  for ( k = 0; k < s->num; k ++) {
    scanf("%d%d%d", &i,&j,&x);
    s->e[k].i = i;
    s->e[k].j = j;
    s->e[k].x = x;
  }
}

void display(struct Sparse s)
{
  int i;
  int j;
  int k;
  for ( i = 0; i < s.row; i ++) {
    for ( j = 0 ; j < s.col; j++) {
      for ( int k = 0; k < s.num; k++) {
        if ( i == s.e[k].i && j == s.e[k].j ) {
          printf("%d ", s.e[k].x);
        }else {
          printf("0 ");
        }
      }
    }
    printf("\n");
  }
}

struct Sparse * add(struct Sparse *s1, struct Sparse *s2)
{
  if ( s1->row  != s2->row || s1->col != s2->col ) return NULL;
  struct Sparse *sum ;
  sum = (struct Sparse *) malloc(sizeof(struct Sparse));
  sum->row = s1->row;
  sum->col = s1->col;
  sum->e = new Element[s1->num + s2->num];
  // or sum->e = (struct Element *) malloc(sizeof(struct Element) * (s1->num + s2->num));
  int i = 0; // trace s1
  int j = 0; // trace s2
  int k = 0;
  while ( i < s1->num && j < s2->num) {
    if ( s1->e[i].i < s2->e[j].i ) {
      sum->e[k++] = s1->e[i++]; // copy s1 to sum
    } else if ( s2->e[j].i < s1->e[i].i ) {
      sum->e[k++] = s2->e[j++]; // copy s2 to sum
    } else {
      if ( s1->e[i].j < s2->e[j].j ) {
        sum->e[k++] = s1->e[i++]; // copy s1 to sum
      } else if ( s2->e[j].j < s1->e[i].j ) {
        sum->e[k++] = s2->e[j++]; // copy s2 to sum
      } else {
        sum->e[k] = s1->e[i++];
        sum->e[k++].x += s2->e[j++].x;
      }
    }
  }
  while ( i < s1->num ) {
    sum->e[k++] = s1->e[i++];
  }
  while ( j < s2->num) {
    sum->e[k++] = s2->e[j++];
  }
  sum->num = k;
  return sum;
}

class Element
{
public:
  int i;
  int j;
  int x;
  Element(int i, int j, int x)
  :i(i), j(j), x(x)
  {
  }
  ~Element() {}
  bool operator==(Element e)
  {
    if (i==e.i && j == e.j ) return true;
    else return false;
  }
  bool operator < (Element e)
  {
    if (i < e.i || i == e.i &&  j < e.j ) return true;
    else return false;
  }
  bool operator > (Element e)
  {
    if (i > e.i || i == e.i &&  j > e.j ) return true;
    else return false;
  }
  Element& operator= (Element e)
  {
    i = e.i;
    j = e.j;
    x = e.x;
    return this;
  }
  friend ostream & operator << (ostream &os, const Element e)
  {
    os << e.i << " " << e.j << " " << e.x;
    return os;
  }
}

class Sparse
{
private:
  int m;
  int n;
  int num;
  Element *ele;
public:
  Sparse(int m, int n, int num) 
  {
    this->m = m;
    this->n = n;
    this->num =num;
    ele = new Element[num];
  }
  ~Sparse()
  {
    delete []ele;
  }
  void create();
  void display();
  Sparse *add(Sparse s2);
  friend ostream & operator<<(ostream &os, Sparse &s) {
    int i, j, k;
    i = j = k = 0;
    for (i = 0; i < s.m; i++) {
      for (j = 0; j < s.n; j++ ) {
        if ( s.ele[k].i == i && s.ele[k].j == j) {
          os << s.ele[k++].x << " ";
        } else {
          os << "0 " 
        }
      }
      os << endl;
   } 
   return os
  }
  friend istream & operator >> (istream &is, Sparse &s) {
    cout << "Enter nonzero elements\n";
    for ( int i = 0; i < s.num; i++) { 
      is >> s.ele[i].i >> s.ele[i].j >> s.ele[i].x;
    }
    return is;
  }
  Sparse operator+(Sparse &s);
};

void Sparse::create()
{
  int i, j,k, x;
  printf("Enter the dimensions\n");
  scanf("%d%d", &i, &j);
  m = i;
  n = j;
  printf("Enter the num of elements\n");
  scanf("%d", &k);
  num = k;
  //e = (struct Element*) malloc(sizeof(struct Element) * k);
  ele = new Element[k];
  printf("Enter the Sparse Matrix\n");
  for ( k = 0; k < s->num; k ++) {
    scanf("%d%d%d", &i,&j,&x);
    ele[k].i = i;
    ele[k].j = j;
    e[k].x = x;
  }
}
void Sparse::display()
{
  int i;
  int j;
  int k;
  for ( i = 0; i < m; i ++) {
    for ( j = 0 ; j < n; j++) {
      for ( int k = 0; k < num; k++) {
        if ( i == e[k].i && j == e[k].j ) {
          printf("%d ", e[k].x);
        }else {
          printf("0 ");
        }
      }
    }
    printf("\n");
  }
Sparse *Sparse::add(Sparse s2)
{
  if ( m  != s2->m || n != s2->n ) return NULL;
  Sparse *sum  = new Sparse();
  //sum = (struct Sparse *) malloc(sizeof(struct Sparse));
  m = s1->m;
  n= s1->n;
  sum->e = new Element[s1->num + s2->num];
  // or sum->e = (struct Element *) malloc(sizeof(struct Element) * (s1->num + s2->num));
  int i = 0; // trace s1
  int j = 0; // trace s2
  int k = 0;
  while ( i < num && j < s2->num) {
    if ( e[i].i < s2->e[j].i ) {
      sum->e[k++] = e[i++]; // copy s1 to sum
    } else if ( s2->e[j].i < e[i].i ) {
      sum->e[k++] = s2->e[j++]; // copy s2 to sum
    } else {
      if ( e[i].j < s2->e[j].j ) {
        sum->e[k++] = e[i++]; // copy s1 to sum
      } else if ( s2->e[j].j < e[i].j ) {
        sum->e[k++] = s2->e[j++]; // copy s2 to sum
      } else {
        sum->e[k] = e[i++];
        sum->e[k++].x += s2->e[j++].x;
      }
    }
  }
  while ( i < num ) {
    sum->e[k++] = e[i++];
  }
  while ( j < s2->num) {
    sum->e[k++] = s2->e[j++];
  }
  sum->num = k;
  return sum;
}
Sparse Sparse::operator+(Sparse &s2)
{
  if ( m  != s2.m || n != s2.n ) return Sparse(0,0,0);
  Sparse *sum  = new Sparse(m, n, num + s2.num);
  //sum = (struct Sparse *) malloc(sizeof(struct Sparse));
  // or sum->e = (struct Element *) malloc(sizeof(struct Element) * (s1->num + s2->num));
  int i = 0; // trace s1
  int j = 0; // trace s2
  int k = 0;
  while ( i < num && j < s2.num) {
    if ( e[i].i < s2.e[j].i ) {
      sum->e[k++] = e[i++]; // copy s1 to sum
    } else if ( s2.e[j].i < e[i].i ) {
      sum->e[k++] = s2.e[j++]; // copy s2 to sum
    } else {
      if ( e[i].j < s2.e[j].j ) {
        sum->e[k++] = e[i++]; // copy s1 to sum
      } else if ( s2.e[j].j < e[i].j ) {
        sum->e[k++] = s2.e[j++]; // copy s2 to sum
      } else {
        sum->e[k] = e[i++];
        sum->e[k++].x += s2.e[j++].x;
      }
    }
  }
  while ( i < num ) {
    sum->e[k++] = e[i++];
  }
  while ( j < s2->num) {
    sum->e[k++] = s2.e[j++];
  }
  sum->num = k;
  return *sum;
}