Inlägg

#include <cstdlib>
#include <iostream>
#include "IntArray.h"
#include "List.h"
#include <time.h>
#include <vector>
#include <algorithm>
using namespace std;
void print_list(linked_list *ll)
{
        ll->print();
        std::cout << std::endl;
}
int main(){
    int n=100;
	//IntArray *ia=new IntArray(n); <-- ger segmenterings fel!!
    clock_t sTime;
    srand((unsigned)clock());
    IntArray ia(n);
    cout << "Osorterad IntArray:" << endl;
    for(int i=0; i<n; i++) //Ändra storlek på container här.
    {
        ia[i]=rand()%10000;
        cout << ia[i] << endl;
    }
    sTime = clock();
    cout << "Sorterad IntArray:" << endl;
    ia.SelectionSort(ia, n);
    clock_t cWait = clock();
    cout << "Total CPU tid använd: " << (double) (clock()-sTime)/CLOCKS_PER_SEC \
    << " sekunder." << endl;
    cout << endl;
    cout << "Sorterad linked list med Insertion sort: " << endl;
    linked_list *l1=new linked_list();
    //placerar in 100 random värden i listan
    for(int i=0; i<100; i++) //Ändra storlek på container här.
    {
        l1->push_back( rand() % 10000);
    }
    l1->print();
    cout << '\n';
    cout << "Total CPU tid använd: " << (double) (clock()-sTime)/CLOCKS_PER_SEC \
    << " sekunder." << endl;
    cout << endl;
    vector<int> v;
    for(int i=0; i<100; i++) //Ändra storlek på container här.
    {
        v.push_back(rand()% 10000);
    }
    cout << endl;
    cout << "Vector fylld med slumpade tal i osorterad ordning:" << endl;
    for (vector<int>::iterator it = v.begin() ; it != v.end(); ++it)
        cout << " " << *it;
    cout << '\n';

    std::sort(v.begin(), v.end());


    cout << endl;
    cout << "Vector fylld med slumpade tal i sorterad ordning:" << endl;
    for (vector<int>::iterator it = v.begin() ; it != v.end(); ++it)
    cout << " " << *it;
    cout << '\n';
    cout << "Total CPU tid använd: " << (double) (clock()-sTime)/CLOCKS_PER_SEC \
        << " sekunder" << endl;


    cin.get();
    return 0;
}

#include "List.h"
#include <stddef.h>
#include <iostream>
#include <stdlib.h>

linked_list::linked_list(void)
{
     head = nullptr;
     tail = nullptr;
}
linked_list::node_t::node_t(node_t* prev, node_t* next)
{
    this->prev = prev;
    this->next = next;
}
//push back placeras ett objekt längst bak
void linked_list::push_back(double value)
{
    node_t* newNode;
    if(is_empty())
    {
        newNode = new node_t(nullptr, nullptr);
        newNode->value = value;
        head = newNode;
        tail = newNode;
    }
    else
    {
        newNode = new node_t(tail, nullptr);
        newNode->value = value;
        tail->next = newNode;
        tail = newNode;
    }
}
//storleken för listan
size_t linked_list::size() const
{
	node_t* traverse = head;
	size_t size = 0;

	while(traverse != nullptr)
	{
		size += 1;
		traverse = traverse->next;
	}

	return size;
}
//skriver ut innehållet i en lista
void linked_list::print() const
{
	for(node_t* it = head; it != nullptr; it = it->next)
	{
		std::cout<< it->value << ", ";
	}
}
//kollar om en lista är tom
bool linked_list::is_empty() const
{
    if(head == nullptr || tail == nullptr)
    {
        return true;
    }
    else
    {
        return false;
    }
}

#ifndef LIST_H
#define LIST_H
#include <stdlib.h>


class linked_list
{
    public :
    linked_list(void);
    linked_list(const linked_list & src);

    linked_list & operator =( const linked_list & rhs );

    linked_list & operator +=( const linked_list & rhs);
    void push_back(double value);

    // accessing elements
    double back () const;
    bool is_empty() const;
	size_t size() const;
    void print() const;
    private :
    struct node_t {
		node_t ( node_t * next =nullptr, node_t * prev =nullptr);
    node_t * next ;
    node_t * prev ;
    double value;
    };
    node_t * head ;
    node_t * tail ;
};

#endif // LIST_H

 #include <cstdlib>
#include <iostream>
#include "IntArray.h"
using namespace std;
int main(){
    int n=100;
    IntArray ia(n);//=IntArray(n);
	//IntArray *ia=new IntArray(n); <-- ger segmenterings fel!!
	for(int i=0; i<n;i++){
        ia[i]=rand()%10000;
        cout<<ia[i]<<endl;
	}
	ia.SelectionSort(ia, n);
    cin.get();
    return 0;
}

#ifndef INTARRAY_H
#define    INTARRAY_H

class IntArray {
public:
    IntArray(size_t size);
    IntArray(size_t size, int init_value);
    IntArray(const IntArray& orig); // Copy constructor
    ~IntArray();
    void SelectionSort(IntArray, int);


    int operator[](int i) const;
    int& operator[](int i);
private:
    IntArray();

    int* begin;
    size_t size;
};
#endif // INTARRAY_H_INCLUDED

#include<cstdlib>
#include<iostream>
#include "IntArray.h"
using namespace std;
IntArray::IntArray() {
}

IntArray::IntArray(size_t size):size(size), begin(new int[size]){

}

IntArray::IntArray(size_t size, int init_value):size(size), begin(new int[size]){
    for(size_t i = 0; i < size; i++){
        begin[i]=init_value;
    }
}

IntArray::IntArray(const IntArray& orig) {
}

IntArray::~IntArray() {
}

int IntArray::operator [](int i) const{
    return begin[i];
}
int& IntArray::operator [](int i){
    return begin[i];
}
void IntArray::SelectionSort(IntArray ia, int size){
    int i,j,tmp,iMin;
    int n=size;
	for (j = 0; j < n-1; j++) {
         iMin = j;
         for ( i = j+1; i < n; i++) {
            if (ia[i] < ia[iMin]) {
                iMin = i;
            }
         }
        if ( iMin != j ) {
            tmp=ia[j];
            ia[j]=ia[iMin];//Här får jag mitt segmenterings fel enligt codeblocks...
            ia[iMin]=tmp;
        }
	}
    cout<<"sorterad -------------" << endl;
    for(int i=0; i<n;i++){
       cout<<ia[i]<<endl;
	}
}