Set Operations(DS)(15C++)

最新推荐文章于 2024-01-08 14:23:33 发布

hling_so

最新推荐文章于 2024-01-08 14:23:33 发布

阅读量838

点赞数

分类专栏： c++ 文章标签： c++

本文链接：https://blog.csdn.net/hling_so/article/details/52438516

版权

c++ 专栏收录该内容

40 篇文章 2 订阅

订阅专栏

Set Operations(DS)(15C++)

标签（空格分隔）：程序设计实验 c++

本人学院

Set OperationsDS15C

description

Set operations.

You need finish function.

Require knowledge:

Know set operations：include

intersection(交集）

union（并集）

the complement of B with respect to A（B对A的补）

symmetric difference（对称差）
copy constructor
overload

Require task:

Define a copy constructor
Overload four operators

Hint:

找到之前的题目Set，并拷贝你们的部分答案到这里，不需要重新写，但不要拷贝标准答案，有抄袭检查。

file provided

main.cpp

//
//  main.cpp
//  C++
//
//  Created by 李天培 on 16/2/25.
//  Copyright © 2016年 lee. All rights reserved.
//

#include <iostream>
#include <algorithm>
#include "Set.hpp"

void display(int* members, int size) {
    std::sort(members, members + size);
    std::cout << "{";
    for (int i = 0; i < size; i++) {
        if (i < size - 1) std::cout << members[i] << ", ";
        else std::cout << members[i];
    }
    std::cout << "}" << std::endl;
}

int main(int argc, const char * argv[]) {
    int test[6];
    std::cin >> test[0]
    >> test[1]
    >> test[2]
    >> test[3]
    >> test[4]
    >> test[5];
    // Constructor 1
    Set s1 = Set();
    display(s1.getMembers(), s1.getSize());
    std::cout << "is empty set: " << s1.isEmptySet() << std::endl;
    // append func
    std::cout << "append: " << s1.append(test[0]) << std::endl;
    std::cout << "append: " << s1.append(test[4]) << std::endl;
    display(s1.getMembers(), s1.getSize());
    // repeat append
    std::cout << "append: " << s1.append(test[0]) << std::endl;
    display(s1.getMembers(), s1.getSize());

    std::cout << "is empty set: " << s1.isEmptySet() << std::endl;

    // Constructor 2
    Set s2 = Set(test, 5);
    // remove func
    std::cout << "remove: " << s2.remove(test[0]) << std::endl;
    display(s2.getMembers(), s2.getSize());
    // repeat append
    std::cout << "remove: " << s2.remove(test[0]) << std::endl;
    display(s2.getMembers(), s2.getSize());

    std::cout << test[5] << " is in set: " << s2.isInSet(test[5]) << std::endl;
    std::cout << test[2] << " is in set: " << s2.isInSet(test[2]) << std::endl;

    display(s1.getMembers(), s1.getSize());
    display(s2.getMembers(), s2.getSize());

    Set s3;
    s3 = s1 & s2;
    display(s3.getMembers(), s3.getSize());

    s3 = s1 | s2;
    display(s3.getMembers(), s3.getSize());

    s3 = s1 - s2;
    display(s3.getMembers(), s3.getSize());

    s3 = s2 - s1;
    display(s3.getMembers(), s3.getSize());

    s3 = s1 + s2;
    display(s3.getMembers(), s3.getSize());

    return 0;
}

Set.hpp

//
//  Set.hpp
//  C++
//
//  Created by 李天培 on 16/2/25.
//  Copyright © 2016年 lee. All rights reserved.
//

#ifndef Set_hpp
#define Set_hpp

#include <stdio.h>

#define MAX_MEMBERS 100

class Set {
private:
    int members[MAX_MEMBERS];
    int size;
public:
    // Create an empty set.
    Set();
    // Create an set with some element.
    Set(int* m, int s);
    // Copy Constructor
    Set(Set const &s);

    // append a element to set.
    // If element in the set, return false.
    // Or insert in set and return true.
    bool append(int e);

    // remove a element by its value from set.
    // If element in the set, then remove it and return true.
    // Or return false.
    bool remove(int e);

    // return true if the set is empty, or return false.
    bool isEmptySet();

    // return true if the element e is in the set, or return false.
    bool isInSet(int e);

    // & is intersection of two set
    Set operator&(const Set &s);
    // | is union of two set
    Set operator|(const Set &s);
    // A - B is the complement of B with respect to A
    Set operator-(const Set &s);
    // A + B is their symmetric difference. A + B = (A - B) | (B - A)
    Set operator+(const Set &s);

    // return set.
    int* getMembers();

    // return size of set.
    int getSize();

};

#endif /* Set_hpp */

understanding

题目要求我们在之前那题set的基础上,增加
拷贝构造函数
重载& | - + 操作符函数

my answer

#include<iostream>
#include<cstring>
#include"Set.hpp"
using namespace std;

    Set::Set() {
        size = 0;
        members[size] = 0;
    }

    Set::Set(int* m, int s) {
        size = 0;
        members[size] = 0;
        for (int i = 0; i < s; i++) {
            append(m[i]);
        }
    }
    Set::Set(Set const &s) {
        int i;
        memset(this->members, 0, MAX_MEMBERS*sizeof(i));
        this->size = s.size;
        for (i = 0; i < s.size; i++) {
            this->members[i] = s.members[i];
        }
    }

    bool Set::append(int e) {
        if (size + 1 >= MAX_MEMBERS || isInSet(e)) return false;
            members[size] = e;
            size++;
            return true;
    }

    bool Set::remove(int e) {
        bool flag = false;
        int i;
        for (i = 0; i < size; i++) {
            if (e == members[i]) {
                flag = true;
                size--;
                for (int j = i; j < size; j++) {
                    members[j] = members[j + 1];
                }
                i--;
            }
        }
        return flag;
    }

    bool Set::isEmptySet() {
        if (size == 0)
            return true;
        else
            return false;
    }

    int* Set::getMembers() {
        return members;
    }

    int Set::getSize() {
        return size;
    }

    bool Set::isInSet(int e) {
        for (int i = 0; i< size; i++) {
            if (e == members[i]) {
                return true;
            }
        }
        return false;
    }
    // & is intersection of two set
    Set Set::operator&(const Set &s) {
        Set temp = s;
        for (int i = 0; i < temp.size; i++) {
            if (!isInSet(temp.members[i])) {
                temp.remove(temp.members[i]);
                i--;
            }
        }
        return temp;
    }
    // | is union of two set
    Set Set::operator|(const Set &s) {
        Set temp = s;
        for (int i = 0; i < size; i++) {
            if (!temp.isInSet(members[i])) {
                temp.append(members[i]);
            }
        }
        return temp;
    }
    // A - B is the complement of B with respect to A
    Set Set::operator-(const Set &s) {
        Set temp1 = s, temp = *this;
        for (int i = 0; i < temp.size; i++) {
            if (temp1.isInSet(temp.members[i])) {
                temp.remove(temp.members[i]);
                i--;
            }
        }
        return temp;
    }
    // A + B is their symmetric difference. A + B = (A - B) | (B - A)
    Set Set::operator+(const Set &s) {
        Set temp = s;
        temp = (*this - temp) | (temp - *this);
        return temp;
    }

the standard answer

//
//  Set.cpp
//  C++
//
//  Created by 李天培 on 16/2/25.
//  Copyright © 2016年 lee. All rights reserved.
//

#include "Set.hpp"

Set::Set() {
    size = 0;
}

Set::Set(int* m, int s) {
    size = 0;
    for (int i = 0; i < s ; i++) {
        if (!isInSet(m[i])) {
            members[size++] = m[i];
        }
        if (size == MAX_MEMBERS) break;
    }
}

Set::Set(Set const &s) {
    size = s.size;
    for (int i = 0; i < size; i++) {
        members[i] = s.members[i];
    }
}

bool Set::append(int element) {
    if (size < MAX_MEMBERS && !isInSet(element)) {
        members[size] = element;
        size++;
        return true;
    } else {
        return false;
    }
}

bool Set::remove(int element) {
    for (int i = 0; i < size; i++) {
        if (members[i] == element) {
            members[i] = members[--size];
            return true;
        }
    }
    return false;
}

bool Set::isEmptySet() {
    return (size == 0) ? true : false;
}

int* Set::getMembers() {
    return members;
}

int Set::getSize() {
    return size;
}

bool Set::isInSet(int element) {
    for (int i = 0; i < size; i++) {
        if (members[i] == element) {
            return true;
        }
    }
    return false;
}

Set Set::operator&(const Set &s) {
    Set temp;
    for (int i = 0; i < s.size; i++) {
        if (isInSet(s.members[i])) {
            temp.members[temp.size++] = s.members[i];
        }
    }
    return temp;
}

Set Set::operator|(const Set &s) {
    Set temp(*this);
    for (int i = 0; i < s.size; i++) {
        temp.append(s.members[i]);
    }
    return temp;
}

Set Set::operator-(const Set &s) {
    Set temp(s);
    Set temp2(*this);
    for (int i = 0; i < temp2.size; i++) {
        if (temp.isInSet(temp2.members[i])) {
            temp2.remove(temp2.members[i]);
        }
    }
    return temp2;
}

Set Set::operator+(const Set &s) {
    Set temp(s);
    return (*this - temp) | (temp - *this);
}