Classes/LinkedList/IntLinkedList.cpp

#include "IntLinkedList.h"
#include "../Sort/IntLinkedListQuickSort.h"
#include "../System/SystemDefine.h"

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

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

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

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


void IntLinkedList::removeAllElement()
{

        if ( howfar != 0 )
        {
                IntElement *element=first;

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

}

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

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

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

void IntLinkedList::addLast(int iValue)
{
        if (howfar == 0)
        {
          first = new IntElement(iValue);
          last=first;
        }
        else
        {
          last->next = new IntElement(iValue);  
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

}

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

int IntLinkedList::getElement(int index)
{
        IntElement *element=first;

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

        return element->value;
}

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

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

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

                element->value=iValue;
        }
}


void IntLinkedList::sortLargestOrder()
{
        IntLinkedListQuickSort::setStatement(0);
        IntLinkedListQuickSort::sortLargestOrder(this,0,howfar-1);
}

void IntLinkedList::sortSmallestOrder()
{
        IntLinkedListQuickSort::setStatement(1);
        IntLinkedListQuickSort::sortSmallestOrder(this,0,howfar-1);
}

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

bool IntLinkedList::removeElement(int index)
{
        if ( index < howfar && index >= 0)
        {
                int temphowfar=howfar;
                 --howfar;
                IntElement *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;
                        }

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

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

                        return true;
                }

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

                int t=0;

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


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

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

                return true;
        }

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