Classes/LinkedList/StringLinkedList.cpp

#include "StringLinkedList.h"
#include "../System/SystemDefine.h"
#include "../String/StringTools.h"
#include "../Sort/StringLinkedListQuickSort.h"

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

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

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

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


void StringLinkedList::removeAllElement()
{

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

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

}

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

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

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

void StringLinkedList::addLast(String &iString)
{
        addLastMain(iString.buffer,iString.length);
}

void StringLinkedList::addLast(String *iString)
{
        addLastMain(iString->buffer,iString->length);
}

void StringLinkedList::addLast(char *iBuffer)
{
        StringTools stringTools;
        addLastMain(iBuffer,stringTools.sizeOfStringWithOutEndNull(iBuffer));
}


void StringLinkedList::addLastMain(char *iBuffer, int length)
{
        if (howfar == 0)
        {
          first = new StringElement(iBuffer,length);
          last=first;
        }
        else
        {
          last->next = new StringElement(iBuffer,length);       
      last->next->previos=last;
          last=last->next;
        }
        
        howfar++;

}

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

char *StringLinkedList::getElement(int index)
{

        if ( index >= 0 && index < howfar)
        {
                StringElement *element=first;

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

                stringLength=element->length;

                return element->buffer;
        }

        return null;
}


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

void StringLinkedList::setElement( char *iBuffer, int iLength, int index)
{
    if ( index < howfar && index >= 0)
    {
                StringElement *element=first;

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

                char *tempBuffer=element->buffer;
                element->createElement(iBuffer,iLength);
                free(tempBuffer);
        }
}

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

void StringLinkedList::sortLargestOrder()
{
        StringLinkedListQuickSort::setStatement(1);
        StringLinkedListQuickSort::sortLargestOrder(this,0,howfar-1);
}

void StringLinkedList::sortSmallestOrder()
{
        StringLinkedListQuickSort::setStatement(0);
        StringLinkedListQuickSort::sortSmallestOrder(this,0,howfar-1);
}

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

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

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

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

                        return true;
                }

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

                int t=0;

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


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