資料匯總
問題描述：
在資料處理中經常需要對大量資料進行匯總，將相同關鍵字記錄的某些資料項的值疊加起來，生成一個分類匯總表，
假設某超級市場銷售有m種商品（假設商品的編號為1，2，3，┅┅，m），有n臺前臺收款機（假設收款機的編號為1，2，3，┅┅，n）進行收款，以記錄的形式提供給計算機，每個記錄表示某臺收款機的一種商品一次交易的數量和銷售額，記錄由4個域組成：收款機編號、商品編號、銷售數量、銷售金額，構造一個結構體型別，每次銷售資料以一個結構體變數保存在一個資料檔案中，
實作要求：
⑴撰寫實作將資料記錄插入到資料檔案的最后的函式；
⑵撰寫以收款機為單位的資料分類處理函式，構造n個單鏈表，每個鏈表保存一臺收款機的銷售記錄，這n個單鏈表的頭指標存放在一個指標陣列中，通過陣列的下標就可以知道是哪臺收款機，讀取資料檔案的記錄，將所有的銷售記錄(資料檔案中的全部記錄)分解插入到n個單鏈表；
⑶撰寫以商品為單位的資料分類處理函式，構造m個單鏈表，每個鏈表保存一種商品的銷售記錄，這m個單鏈表的頭指標存放在一個指標陣列中，通過陣列的下標就可以知道是哪種商品，讀取資料檔案的記錄，將所有的銷售記錄(資料檔案中的全部記錄)分解插入到m個單鏈表；
⑷統計每臺收款機的銷售總額；
⑸以收款機為單位，將所有收款機按銷售總額的非遞減順序構造一個單鏈表并輸出；
⑹以商品為單位，統計每種商品的銷售總額；
⑺以商品為單位，將所有銷售的商品按銷售總額的非遞減順序構造一個單鏈表并輸出；
⑻設計一個選單，具有上述要求的所有功能、退出系統等最基本的功能，
下面是代碼實作（C++）
#include<iostream>
#include<fstream>
#include<vector>
#include<array>
#include<windows.h>
#define register_numbers 5//收款機編號
#define commodity_numbers 5//商品編號
#define non_existent_number -1//不存在的商品或收款機編號
struct Sell_Data {
//資料記錄
int cash_register_number;//收款機編號
int commodity_number;//商品編號
int sell_number;//銷售數量
double sell_sum;//銷售金額
};
struct Node_Cash_Register_Data {
//收款機節點
int commodity_number;//商品編號
int sell_number;//銷售數量
double sell_sum;//銷售金額
Node_Cash_Register_Data* next = nullptr;//指向下一節點的指標
};
struct Node_Commodity_Data {
//商品節點
int cash_register_number;//收款機編號
int sell_number;//銷售數量
double sell_sum;//銷售金額
Node_Commodity_Data* next = nullptr;//指向下一節點的指標
};
struct Register_Sum {
int cash_register_number=-1;//收款機編號
double sell_total_sum = 0;//銷售總金額
Register_Sum* next = nullptr;//指向下一節點的指標
};
struct Commodity_Sum {
int commodity_number=-1;//商品編號
double sell_total_sum = 0;//銷售總金額
Commodity_Sum* next = nullptr;//指向下一節點的指標
};
class Data_Summarization {
private:
std::vector<Sell_Data> records;//資料記錄
std::array<Node_Cash_Register_Data*, register_numbers> registers{ nullptr };//構造n個單鏈表，每個鏈表保存一臺收款機的銷售記錄
std::array<Node_Commodity_Data*, commodity_numbers> goods{ nullptr };//構造m個單鏈表，每個鏈表保存一種商品的銷售記錄
std::array<Register_Sum, register_numbers> register_sort;
std::array<Commodity_Sum, commodity_numbers> goods_sort;
Register_Sum* register_sort_node = nullptr;//這個節點用于排好序的單鏈表的表頭指標
Commodity_Sum* goods_sort_node = nullptr;//這個節點用于排好序的單鏈表的表頭指標
public:
Data_Summarization() = default;//建構式
Data_Summarization(std::vector<Sell_Data> m);
~Data_Summarization();//解構式
void Sell_Data_Insert(const Sell_Data& m);//將資料記錄插入到records中
void Sell_Data_Insert(std::vector<Sell_Data>& m);
Data_Summarization operator=(const std::vector<Sell_Data>& m);//運算子多載
Data_Summarization operator+(const Sell_Data& m);
bool stastics_attach();//將資料記錄插入到資料檔案的最后
void Initialize_List();//將鏈表初始化
void sort();//排序
void register_sort_display();//將所有收款機按銷售總額的非遞減順序輸出
void goods_sort_display();//將所有商品按銷售總額的非遞減順序輸出
double register_sum_max(int index);//輸入收款機編號，回傳銷售總額
double goods_sum_max(int index);//輸入商品編號，回傳銷售總額
// double operator[](std::array<Register_Sum, register_numbers> register_sort);//多載[]
// double operator[](std::array<Commodity_Sum, commodity_numbers> goods_sort);
}data_summarization;
Data_Summarization::Data_Summarization(std::vector<Sell_Data> m) {
this->records = m;
}//建構式
Data_Summarization::~Data_Summarization() {
for (int i = 0; i < register_numbers; i++) {
auto p1 = registers[i];
while (p1->next != nullptr) {
auto temp1 = p1;
p1 = p1->next;
delete[]temp1;
}
}//遍歷釋放空間
for (int j = 0; j < commodity_numbers; j++) {
auto p2 = goods[j];
while (p2->next != nullptr) {
auto temp2 = p2;
p2 = p2->next;
delete[]temp2;
}
}//遍歷釋放空間
}
void Data_Summarization::Sell_Data_Insert(const Sell_Data& m) {//將資料記錄插入到records中
(this->records).push_back(m);
}
void Data_Summarization::Sell_Data_Insert(std::vector<Sell_Data>& m) {
this->records = m;
}
Data_Summarization Data_Summarization::operator=(const std::vector<Sell_Data>& m) {//多載=
this->records = m;
return *this;
}
Data_Summarization Data_Summarization::operator+(const Sell_Data& m) {//多載+
(this->records).push_back(m);
return *this;
}
bool Data_Summarization::stastics_attach() {//將資料記錄插入到資料檔案的最后
std::ofstream outfile;
outfile.open("stastics.out", std::ios::app | std::ios::binary);
if (!outfile) {
std::cout << "file open error" << std::endl;
return false;
}//檢查打開檔案是否成功
else {
auto first = this->records.begin();
auto last = this->records.end();
for (; first != last; ++first) {
outfile.write((char*)(&(*first)), sizeof(Sell_Data));
}
outfile.close();
}//向檔案中寫入資料
return true;
}
void Data_Summarization::Initialize_List() {//初始化鏈表
auto first1 = this->records.begin();
auto last1 = this->records.end();
for (; first1 != last1; ++first1) {
int temp1 = first1->cash_register_number;
if (this->registers[temp1] == nullptr) {
registers[temp1] = new Node_Cash_Register_Data;
}//如果表中第一個元素為nullptr就新申請一個
auto p1 = registers[temp1];
while (p1->next != nullptr) {
p1 = p1->next;
}//獲得鏈表中最后一項的地址
auto q1 = new Node_Cash_Register_Data;
q1->commodity_number = first1->commodity_number;
q1->sell_number = first1->sell_number;
q1->sell_sum = first1->sell_sum;
p1->next = q1;//賦值
}//收款機鏈表
auto first2 = this->records.begin();
auto last2 = this->records.end();
for (; first2 != last2; ++first2) {
int temp2 = first2->commodity_number;
if (this->goods[temp2] == nullptr) {
goods[temp2] = new Node_Commodity_Data;
}//如果表中第一個元素為nullptr就新申請一個
auto p2 = goods[temp2];
while (p2->next != nullptr) {
p2 = p2->next;
}//獲得鏈表中最后一項的地址
auto q2 = new Node_Commodity_Data;
q2->cash_register_number = first1->cash_register_number;
q2->sell_number = first1->sell_number;
q2->sell_sum = first1->sell_sum;
p2->next = q2;//賦值
}//商品鏈表
}
void Data_Summarization::sort() {//排序
int i, j;
for (i = 0; i < register_numbers; ++i) {
auto p1 = registers[i];
while (p1->next != nullptr) {
register_sort[i].sell_total_sum += p1->sell_sum;
}
register_sort[i].cash_register_number = i;
}
for (j = 0; j < commodity_numbers; ++j) {
auto p2 = goods[j];
while (p2->next != nullptr) {
goods_sort[j].sell_total_sum += p2->sell_sum;
}
goods_sort[j].commodity_number = j;
}//這些步驟用來初始化這個串列，然后把它們排序，然后在用一個單鏈表串起來
int k, n;
for (k = 0; k < register_numbers; ++k) {
for (n = 0; n < register_numbers - k - 1; ++n) {
Register_Sum temp1;
if (register_sort[n].sell_total_sum > register_sort[n + 1].sell_total_sum) {
temp1.sell_total_sum = register_sort[n].sell_total_sum;
temp1.cash_register_number = register_sort[n].cash_register_number;
register_sort[n].sell_total_sum = register_sort[n + 1].sell_total_sum;
register_sort[n].cash_register_number = register_sort[n + 1].cash_register_number;
register_sort[n + 1].sell_total_sum = temp1.sell_total_sum;
register_sort[n + 1].cash_register_number = temp1.cash_register_number;
}
}
}
for (k = 0; k < commodity_numbers; ++k) {
for (n = 0; commodity_numbers - k - 1; ++n) {
Commodity_Sum temp2;
if (goods_sort[n].sell_total_sum > goods_sort[n + 1].sell_total_sum) {
temp2.sell_total_sum = goods_sort[n].sell_total_sum;
temp2.commodity_number = goods_sort[n].commodity_number;
goods_sort[n].sell_total_sum = goods_sort[n + 1].sell_total_sum;
goods_sort[n].commodity_number = goods_sort[n + 1].commodity_number;
goods_sort[n + 1].sell_total_sum = temp2.sell_total_sum;
goods_sort[n + 1].commodity_number = temp2.commodity_number;
}
}
}//使用一個簡單的冒泡來排序
for (k = 0; k < register_numbers - 1; ++k) {
register_sort[k].next = ®ister_sort[k + 1];
}
for (j = 0; j < commodity_numbers - 1; ++j) {
goods_sort[j].next = &goods_sort[j + 1];
}//構造成一個單鏈表
register_sort_node = ®ister_sort[0];
goods_sort_node = &goods_sort[0];
}
void Data_Summarization::register_sort_display() {
for (int i = 0; i < register_numbers; ++i) {
if(register_sort[i].cash_register_number!=non_existent_number)
std::cout << register_sort[i].cash_register_number+1;//非遞減順序列印下表加一
if (i != register_numbers - 1) {
std::cout << "->";
}
}
std::cout << std::endl;
}
void Data_Summarization::goods_sort_display() {
for (int j = 0; j < commodity_numbers; ++j) {
if(goods_sort[j].commodity_number!=non_existent_number)
std::cout << goods_sort[j].commodity_number+1;//非遞減順序列印下表加一
if (j != commodity_numbers) {
std::cout << "->";
}
}
std::cout << std::endl;
}
double Data_Summarization::register_sum_max(int index){
int i=0;
for(;i<register_numbers;++i){
if(register_sort[i].cash_register_number==index-1)
break;
}
return register_sort[i+1].sell_total_sum;
}
double Data_Summarization::goods_sum_max(int index){
int j=0;
for(;j<commodity_numbers;++j){
if(goods_sort[j].commodity_number==index-1)
break;
}
return goods_sort[j+1].sell_total_sum;
}
// double Data_Summarization::operator[](int index, std::array<Register_Sum, register_numbers> register_sort) {
// return register_sort[index].sell_total_sum;
// }//多載的[]我想這樣方便些用這個來排序
// double Data_Summarization::operator[](int index; std::array<Commodity_Sum, commodity_numbers> goods_sort) {
// return goods_sort[index].sell_total_sum;
// }
// void Quick_sort(Data_Summarization A.register_sort, register_numbers) {//快速排序演算法
// if (register_numbers <= 1)
// return;//設定遞回出口
// Register_Sum mark = Data_Summarization[0, register_sort];
// int temp = 0;
// //定義填坑法的兩個指標，index是坑，carry是運算元
// int index = 0, carry = register_numbers - 1;
// while (carry != index) {
// if (index < carry) {
// if (Data_Summarization[carry, register_sort] < mark) {
// Data_Summarization[index, register_sort] = Data_Summarization[carry, register_sort];
// temp = carry;
// carry = index + 1;
// index = temp;//交換index carry 并讓carry移動一位
// }
// else
// --carry;
// }
// else if (index > carry) {
// if (Data_Summarization[carry, register_sort] > mark) {
// Data_Summarization[index, register_sort] = Data_Summarization[carry, register_sort];
// temp = carry;
// carry = index - 1;
// index = temp;
// }
// else
// ++carry;
// }
// }
// register_sort[carry, register_sort] = mark;
// //分而治之
// Quick_sort(register_sort, carry);
// Quick_sort(®ister_sort[carry + 1, register_sort], register_numbers - carry - 1);//遞回快速排序
// }
// class register_sum{
// private:
// int cash_register_number;//收款機編號
// double sell_total_sum;//銷售總金額
// public:
// friend class Data_Summarization;
// register_sum(Node_Commodity_Data* p);
// ~register_sum();
// };
// register_sum::register_sum(Node_Commodity_Data* p)
// {
// }
// register_sum::~register_sum()
// {
// }
void menu(){
std::cout << "\t\t\t\t" <<"歡迎使用" std::endl;
std::cout << "\t\t\t\t1------------------輸入收款記錄" << std::endl;
std::cout << "\t\t\t\t2------------------將資料記錄插入到資料檔案" << std::endl;
std::cout << "\t\t\t\t3------------------統計每臺收款機的銷售總額" << std::endl;
std::cout << "\t\t\t\t4------------------將所有收款機按銷售總額的非遞減順序構造一個單鏈表并輸出" << std::endl;
std::cout << "\t\t\t\t5------------------以商品為單位，統計每種商品的銷售總額" << std::endl;
std::cout << "\t\t\t\t6------------------以商品為單位，將所有銷售的商品按銷售總額的非遞減順序構造一個單鏈表并輸出" << std::endl;
std::cout << "\t\t\t\t7------------------清屏" << std::endl;
std::cout << "\t\t\t\t8------------------退出" << std::endl;
std::cout << "\t\t\t\t9------------------" << std::endl;
std::cout << "\t\t\t\t10-----------------" << std::endl;
}
void operator_define(int m){
switch (m)
{
case 1:
std::cout<<"請依次輸入 收款機編號、商品編號、銷售數量、銷售金額"<<std::endl;
Sell_Data temporary_variable;
while(std::cin>>temporary_variable.cash_register_number>>temporary_variable.commodity_number>>temporary_variable.sell_number>>temporary_variable.sell_sum){
data_summarization.Sell_Data_Insert(const Sell_Data& temporary_variable);
}
break;
case 2:
data_summarization.stastics_attach();
break;
case 3:
data_summarization.Initialize_List();
std::cout<<"請輸入你要查詢的收款機序號："<<std::endl;
int index;
std::cin>>index;
data_summarization.sort();
data_summarization.register_sum_max(int index);
break;
case 4:
data_summarization.register_sort_display();
break;
case 5:
data_summarization.Initialize_List();
std::cout<<"請輸入你要查詢的收款機序號："<<std::endl;
int index1;
std::cin>>index1;
data_summarization.sort();
data_summarization.goods_sum_max(int index1);
break;
case 6:
data_summarization.goods_sort_display();
break;
case 7:
system("cls");//清屏
menu();
break;
}
}
int main{
menu();
int a;
std::cin>>a;
while(a!=8){
operator_define(a);
}
return 0;
}
代碼待除錯…
轉載請註明出處，本文鏈接：https://www.uj5u.com/qita/237229.html
標籤：其他