Classes/LinkedList/FloatLinkedList.cpp

#include "FloatLinkedList.h"
#include "../Sort/FloatLinkedListQuickSort.h"
#include "../System/SystemDefine.h"

FloatLinkedList::FloatLinkedList()
{
        howfar=0;
}

////////////////////////////////////////////////////////////////////////////////////
//free memory for all Elements that exsist in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

FloatLinkedList::~FloatLinkedList()
{
        removeAllElement();
}

////////////////////////////////////////////////////////////////////////////////////
//free memory for all Elements that exsist in the LinkedList
////////////////////////////////////////////////////////////////////////////////////


void FloatLinkedList::removeAllElement()
{
        if ( howfar != 0 )
        {
                FloatElement *element=first;

                for ( int s=0; s<howfar ; s++ )
                {
                        FloatElement *tempElement=element->next;
                        delete element;
                        element=tempElement;
                }
        }
}

////////////////////////////////////////////////////////////////////////////////////
//How many Elements is it in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

int FloatLinkedList::size()
{
        return howfar;
}

////////////////////////////////////////////////////////////////////////////////////
//add a Element to the LinkedList
////////////////////////////////////////////////////////////////////////////////////


void FloatLinkedList::addLast(float iValue)
{
        if (howfar == 0)
        {
          first = new FloatElement(iValue);
          last=first;
        }
        else
        {
          last->next = new FloatElement(iValue);        
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;
}

////////////////////////////////////////////////////////////////////////////////////
//get a Element from the LinkedList
////////////////////////////////////////////////////////////////////////////////////

float FloatLinkedList::getElement(int step)
{
        FloatElement *element=first;

        for ( int s=0; s<step ; s++ )
        {
                element=element->next;
        }

        return element->value;
}


////////////////////////////////////////////////////////////////////////////////////
//set a Element in the LinkedList
////////////////////////////////////////////////////////////////////////////////////

void FloatLinkedList::setElement( float iValue, int index)
{
    if ( index < howfar && index >= 0)
    {
                FloatElement *element=first;

                for ( int s=0; s<index ; s++ )
                {
                        element=element->next;
                }

                element->value=iValue;
        }
}

////////////////////////////////////////////////////////////////////////////////////
//sort element in linkedlist
////////////////////////////////////////////////////////////////////////////////////

void FloatLinkedList::sortLargestOrder()
{
        FloatLinkedListQuickSort::setStatement(0);
        FloatLinkedListQuickSort::sortLargestOrder(this,0,howfar-1);
}

void FloatLinkedList::sortSmallestOrder()
{
        FloatLinkedListQuickSort::setStatement(1);
        FloatLinkedListQuickSort::sortSmallestOrder(this,0,howfar-1);
}

////////////////////////////////////////////////////////////////////////////////////
//remove a element from the linkedlist
////////////////////////////////////////////////////////////////////////////////////

bool FloatLinkedList::removeElement(int index)
{
        if ( index < howfar && index >= 0)
        {
                int temphowfar=howfar;
                    --howfar;
                FloatElement *lista = first;

                for ( int w=0; w<index ; w++ )
                {
                        lista=lista->next;
                }

                if ( lista == first && temphowfar == 1 )
                {
                        delete first;
                        return true;
                }


                if ( lista == first && temphowfar != 1  )
                {
                        bool s=false;

                        if ( lista->next == last )
                        {
                                s=true;
                        }

                        FloatElement *temp=first->next;
                        delete first;
                        first=temp;

                        if (s == true)
                        {
                                last=first;
                        }

                        return true;
                }

                if ( lista == last )
                {
                        FloatElement *temp=last->previos;
                        delete last;
                        last=temp;
                        return true;
                }

                int t=0;

                if ( lista->next == last && lista->previos == first )
                {
                        t=1;
                }


                FloatElement *tempnext=lista->previos;
                FloatElement *tempprevios=lista->next;
                delete lista;
                tempnext->next=tempprevios;
                tempprevios->previos=tempnext;

                if ( t == 1 )
                {
                        first=tempnext;
                        last=tempprevios;
                }

                return true;
        }

        return false;
}
1	#include "FloatLinkedList.h"
2	#include "../Sort/FloatLinkedListQuickSort.h"
3	#include "../System/SystemDefine.h"
4
5	FloatLinkedList::FloatLinkedList()
6	{
7	howfar=0;
8	}
9
10	////////////////////////////////////////////////////////////////////////////////////
11	//free memory for all Elements that exsist in the LinkedList
12	////////////////////////////////////////////////////////////////////////////////////
13
14	FloatLinkedList::~FloatLinkedList()
15	{
16	removeAllElement();
17	}
18
19	////////////////////////////////////////////////////////////////////////////////////
20	//free memory for all Elements that exsist in the LinkedList
21	////////////////////////////////////////////////////////////////////////////////////
22
23
24	void FloatLinkedList::removeAllElement()
25	{
26	if ( howfar != 0 )
27	{
28	FloatElement *element=first;
29
30	for ( int s=0; s<howfar ; s++ )
31	{
32	FloatElement *tempElement=element->next;
33	delete element;
34	element=tempElement;
35	}
36	}
37	}
38
39	////////////////////////////////////////////////////////////////////////////////////
40	//How many Elements is it in the LinkedList
41	////////////////////////////////////////////////////////////////////////////////////
42
43	int FloatLinkedList::size()
44	{
45	return howfar;
46	}
47
48	////////////////////////////////////////////////////////////////////////////////////
49	//add a Element to the LinkedList
50	////////////////////////////////////////////////////////////////////////////////////
51
52
53	void FloatLinkedList::addLast(float iValue)
54	{
55	if (howfar == 0)
56	{
57	first = new FloatElement(iValue);
58	last=first;
59	}
60	else
61	{
62	last->next = new FloatElement(iValue);
63	last->next->previos=last;
64	last=last->next;
65	}
66
67	howfar++;
68	}
69
70	////////////////////////////////////////////////////////////////////////////////////
71	//get a Element from the LinkedList
72	////////////////////////////////////////////////////////////////////////////////////
73
74	float FloatLinkedList::getElement(int step)
75	{
76	FloatElement *element=first;
77
78	for ( int s=0; s<step ; s++ )
79	{
80	element=element->next;
81	}
82
83	return element->value;
84	}
85
86
87	////////////////////////////////////////////////////////////////////////////////////
88	//set a Element in the LinkedList
89	////////////////////////////////////////////////////////////////////////////////////
90
91	void FloatLinkedList::setElement( float iValue, int index)
92	{
93	if ( index < howfar && index >= 0)
94	{
95	FloatElement *element=first;
96
97	for ( int s=0; s<index ; s++ )
98	{
99	element=element->next;
100	}
101
102	element->value=iValue;
103	}
104	}
105
106	////////////////////////////////////////////////////////////////////////////////////
107	//sort element in linkedlist
108	////////////////////////////////////////////////////////////////////////////////////
109
110	void FloatLinkedList::sortLargestOrder()
111	{
112	FloatLinkedListQuickSort::setStatement(0);
113	FloatLinkedListQuickSort::sortLargestOrder(this,0,howfar-1);
114	}
115
116	void FloatLinkedList::sortSmallestOrder()
117	{
118	FloatLinkedListQuickSort::setStatement(1);
119	FloatLinkedListQuickSort::sortSmallestOrder(this,0,howfar-1);
120	}
121
122	////////////////////////////////////////////////////////////////////////////////////
123	//remove a element from the linkedlist
124	////////////////////////////////////////////////////////////////////////////////////
125
126	bool FloatLinkedList::removeElement(int index)
127	{
128	if ( index < howfar && index >= 0)
129	{
130	int temphowfar=howfar;
131	--howfar;
132	FloatElement *lista = first;
133
134	for ( int w=0; w<index ; w++ )
135	{
136	lista=lista->next;
137	}
138
139	if ( lista == first && temphowfar == 1 )
140	{
141	delete first;
142	return true;
143	}
144
145
146	if ( lista == first && temphowfar != 1 )
147	{
148	bool s=false;
149
150	if ( lista->next == last )
151	{
152	s=true;
153	}
154
155	FloatElement *temp=first->next;
156	delete first;
157	first=temp;
158
159	if (s == true)
160	{
161	last=first;
162	}
163
164	return true;
165	}
166
167	if ( lista == last )
168	{
169	FloatElement *temp=last->previos;
170	delete last;
171	last=temp;
172	return true;
173	}
174
175	int t=0;
176
177	if ( lista->next == last && lista->previos == first )
178	{
179	t=1;
180	}
181
182
183	FloatElement *tempnext=lista->previos;
184	FloatElement *tempprevios=lista->next;
185	delete lista;
186	tempnext->next=tempprevios;
187	tempprevios->previos=tempnext;
188
189	if ( t == 1 )
190	{
191	first=tempnext;
192	last=tempprevios;
193	}
194
195	return true;
196	}
197
198	return false;
199	}