Премини към съдържанието

Препоръчан отговор


Здравейте имам тази задача и трябва да запиша елементите на списъка във файл, където да се запишат и сортираните стекове, но не знам как. Направих там да се записвам стековете, но немога списъка

#include<iostream>
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
#include<fstream>
#include<ctime>

using namespace std;

float time_sort = 0;// променлива за показване на времето за, което сортирваме

//динамична структора за стек и неговия елемент
typedef struct elem { int key; elem *next; } *pelem;
typedef struct stack { pelem start; } *pstack;

//функция за добавяне към върха в стека
void push(pstack s, int n) {
	pelem p = s->start;
	s->start = (pelem)malloc(sizeof elem);
	s->start->key = n;
	s->start->next = p;
}

// функция за извличане на елемент от върха стека
int pop(pstack s) {
	int n = -1;
	pelem p = s->start;
	if (p != NULL) {
		n = p->key;
		s->start = p->next;
		free(p);
	}
	return n;
}

//проверка дали стека е празен
int isStackEmpty(pstack s) {
	return s->start == NULL;
}

// създаване на стек
pstack create_stack() {
	pstack t = (pstack)malloc(sizeof stack);
	memset(t, 0, sizeof stack);
	return t;
}

// сортиране на стека чрез селекция
void selection_sort(pstack s) {
	const clock_t begin = clock(); // запаметяваме началното време при стартиране на сортировката

	pstack ret = create_stack();
	pstack temp = create_stack();
	int iteration = 0;

	while (!isStackEmpty(s)) { // докато стигнем последния елемент в подадения стек
		int current = pop(s); // изваждаме и присвояваме най-горния елемент(текущ), който ще го сравним със всички останали
		while (!isStackEmpty(s)) { // докато стигнем последния елемент в подадения стек
			int n = pop(s);   // вземаме най-горния елемент
			if (n < current) { // сравняваме  го с текущия
				// ако е по-малък го разменяме  с текущия
				int swap = current;
				current = n;
				n = swap;
			}
			push(temp, n); // слагаме по-големия елемент във временен стек
			iteration++;
		}
		push(ret, current); // добавяме най-малкото число в ret(стек)
		s->start = temp->start; // присвояваме началния стек на времения
		temp->start = NULL; // изчистваме времения стек
		iteration++;
	}
	s->start = ret->start;// присвояваме началния указателя на подадения стек към началния на вече сортирания стек
	time_sort = (float(clock() - begin) / (CLOCKS_PER_SEC)* 1000);
	cout << " TIme for sort  mls-> " << time_sort << "Брой итерации -> " << iteration << endl;
}

//функция за запис на числа от файлове в два динамични стека
void initStackFromFile(pstack s, pstack s2){
	fstream fp;
	int num;

	//първи стек
	fp.open("numsToStack.txt", ios::in);

	//proverq dali vajlyt e otvoren pravilno
	if (!fp){
		cout << "Can not open this file ERROR. \n";
		exit(1);
	}

	//записваме числата в стека докато стигнем край на файла
	while (fp >> num){
		if(num>25)
		{
			push(s, num);}
		else
		push(s2, num);
	}

	fp.close();
	cout << "Числата са записани правилно в стековете\n";


	
}

//тук генерираме различна последователност от числа за да проследим сортирането в различни ситуации
void generate(string fileName, string fileName2)
{
	srand((unsigned)time(0));

	const int NumberElements = 1000; // бр елементи общо за двата стека (пример = 10, по 5 елемента във всеки файл)
	//Генериране на разбъркани числа
	fstream fp;
	int numsTostack[NumberElements];

	srand(time(NULL));
	for (int i = 0; i < NumberElements; i++) // обхождаме масива за да го запълним
	{
		numsTostack[i] = (rand() % 50 ) + 1; // генератор на сл. числа( диапазон на числата)
	}

	//записваме първата половина в първия файл
	fp.open(fileName, ios::out);
	for (int i = 0; i < NumberElements/2; i++)
		fp << numsTostack[i] << endl;
	fp.close();

	//записваме втората половина в първия файл
	fp.open(fileName2, ios::out);
	for (int i = NumberElements/2; i < NumberElements; i++)
		fp << numsTostack[i] << endl;
	fp.close();
}

//добавяме сортираните стекове във файлове
void add_to_file_Sorted(pstack s, pstack s2){
	fstream fp;

	// записваме стойностите от първия стек
	fp.open("Сортирана стек1.txt", ios::out);
	pelem p = s->start;
	pelem p2 = s2->start;
	fp <<"Стек1: ";
	while (p != NULL) {
		fp <<p->key<<" ";
		p = p->next;}

	fp<<endl;
	fp <<"Стек2: ";
	while (p2 != NULL) {
		fp << p2->key <<" ";
		p2 = p2->next;
	}

	fp.close();
}

void show(pstack s){
		
	pelem p = s->start;

	while (p != NULL) {
		cout << p->key << " ";
		p = p->next;
	}

}

// струкора който представлява елемент от списък
typedef struct Element{
	int data;
	Element *prev, *next;
	Element(const int& value) {
		data = value;
		prev = next = NULL;
	}
};

// структора списък
typedef struct List{
	int size;
	Element *head, *tail;
};

// запазваме големината на списъка в структората, така при търсене на големината му имаме сложност на алгоритъм O(1)
int size(List& list) {
	return list.size;
}

//функция за добавяне към списъка
void push_front(List& list, int value) {
	Element* element = new Element(value);
	element->next = list.head;
	if (list.size == 0)
		list.head = list.tail = element;
	else
		list.head = list.head->prev = element;
	list.size++;
}

//функция за първоначално инициализиране на списъка
List init() {
	List list;
	list.size = 0;
	list.head = list.tail = NULL;
	return list;
}


//формиране на нова структура списък от двата стека
void initList(List& list, pstack s1, pstack s2){

	// добавяме всички елементи от първия стек (след добавянето им стека е празен)
	while (!isStackEmpty(s1)){
		push_front(list, pop(s1));
	}
	// за втория
	while (!isStackEmpty(s2)){
		push_front(list, pop(s2));
	}
	
		
}

// намираме минималния елемент кратен на подадено число
int minElementInList(List& list1, int& numberFromUser){

	int tempminElement = 0;
	Element* link = list1.head;
	int minElement = link->data; // за най-малък елемент избираме първия от списъка

	// обхождаме целия списък
	for (int i = 0; i < list1.size; i++){
		if ((link->data % numberFromUser) == 0){ // ако елемента се дели без остатък на подадения параметър и е по-малък от най-малкия 
			if (minElement > link->data){
				minElement = link->data;// запаметяваме елемента, като най-малък
			}
			else if (minElement % numberFromUser != 0){
				minElement = link->data;
			}	
		}
		cout<<link->data<<" ";
        link = link->next; // указателя сочи следващия елемент от списъка
	}
	
	// проверка дали минималния елемент се дели без остатък, в случей, че никой елемент не е, нито по-малък от първия, нито се дели без остатък на подадения параметър
	if (minElement % numberFromUser == 0){
		return minElement; // връшаме най-малкия
	}
	else{
		// в случей че не съществува такъв елемент
		return 0; // връшаме нула защото знаем имаме записани само положителни числа 
	}
	
	

}

// добавяме най-малкото число във файл
void add_to_file_min(int minDev){

	fstream fp;
	fp.open("Най-малкото.txt", ios::out);

	fp << minDev;

	fp.close();
}

int main() {

	pstack s1 = create_stack();
	pstack s2 = create_stack();
	List list = init();
	
	//push_front(list,1);
	


	int choice;
	int numberFromUserDev= 0;
	int minNumberDef ;

	system("chcp 1251");
	system("cls");

	//меню
	do{
		
		cout << "1.Инициализиране на стековете със числа" << endl
			<< "2.Сортиране на двата стека чрез селекция" << endl
			<< "3.Показване на стойностите в стековете" << endl
			<< "4.Инициализиране  на списъка с елементите на двата стека" << endl
			<< "5.Извеждане на списъка и намиране на най-малкото число кратно на число въведено от потребителя " << endl
			<< "6.Генериране на случайни числа във файл " << endl
			<< "7.Изход" << endl
			<< "Въведете вашият избор -> ";
		cin >> choice;
		system("cls");

		switch (choice)
		{

			case(1): 
				initStackFromFile(s1, s2);				
				cout << endl << endl;
			break;

			case(2):	
				 selection_sort(s1);	cout << "Първата стек е сортирана "<< endl << endl;
				 selection_sort(s2);	cout << endl;
				 cout << "Втората стек е сортирана \n";  
				 add_to_file_Sorted(s1, s2);
				 cout << endl << endl;
			break;

			case(3) :
				 cout << "Първи стек" << endl;
				 show(s1);	
				 cout << endl; 
				 cout << "Втори стек" << endl;
				 show(s2);				
				 cout << endl << endl;							 
			break;

			case(4):
				initList(list, s1, s2);
				cout << "Елементите от двата стека вече са във списък!";
				cout << endl << endl;
				

			break;

			case(5):
				do{
					cout << "Въведете число по което да намерите най-малкия елемент в списъка, който се дели на него -> ";
					cin >> numberFromUserDev;
					cout<<"Елементите на списъка: ";
				} while (!numberFromUserDev);

				minNumberDef = minElementInList(list, numberFromUserDev); //запаметяваме резултата от функцията на променлива

				if (minNumberDef){ // в случей, че не намерим такова число ще получим 0
					cout << endl << "Най-малкото число, което се дели на " << numberFromUserDev << " без остатък е -> " << minNumberDef << endl << endl;
					add_to_file_min(minNumberDef);
				}
				else{
					cout << endl << "Няма число което се дели на " << numberFromUserDev << endl << endl;
				}
			break;

			case(6) :
					generate("numsToStack.txt", "numsToStack2.txt");	
				    cout << "Успешно генерирахте числа във два файла " << endl;
					cout << endl;				 
			break;
			case(7) :
				cout << "Довиждане " << endl;
			break;

			default:
				cout << "Въвели сте невалиден избор. Моля въведете отново. " << endl << endl; break;

		}
	} while (choice != 7);


	system("PAUSE");

	return 0;

}

 

Редактирано от petar96 (преглед на промените)

Сподели този отговор


Линк към този отговор
Сподели в други сайтове

Регистрирайте се или влезете в профила си за да коментирате

Трябва да имате регистрация за да може да коментирате това

Регистрирайте се

Създайте нова регистрация в нашия форум. Лесно е!

Нова регистрация

Вход

Имате регистрация? Влезте от тук.

Вход

×

Информация

Поставихме бисквитки на устройството ви за най-добро потребителско изживяване. Можете да промените настройките си за бисквитки, или в противен случай приемаме, че сте съгласни с нашите условия за ползване.