Basic info about how to create class of list.

1. List ADT
April 25, 2012

2. Definition
A collection of contiguous elements or
items
a1, a2, a3, …, an
n is the size
a2 precedes a3
a3 succeeds a2

3. Definition
Operations
insert
deleteItem/erase
access

4. void main(){
Humble Numbers
List<int> l;
srand((unsigned int)time(NULL));
for(int i=0; i<10; i++)
l.insert(rand()%50,rand()%10+1);
int count=0;
for(int i=1; i<=l.getSize(); i++){
int item = l.itemAt(i);
bool flag = true;
for(int cd=2; cd*cd<=item; cd++){
if(item%cd==0 && prime(cd) && cd>7){
flag = false;
break;
}
}
if(flag)
count++;
}
}

5. Implementation
Array
Dynamic Array
Linked-list

6. Array Implementation
 Array for storage
 Size
class List{
private:
int items[MAX];
int size;
public:
List();
bool append(int);
bool insertFront(int);
bool insert(int,int);
bool erase(int);
int itemAt(int);
};

7. Array Implementation

8. Append
10

9. Append
10 8

10. Append
10 8 -7

11. Append
bool List::append(int x){
if(size==MAX)
return false;
items[size++] = x;
return true;
}

12. Insert At Position 2
10 8 -7

13. Insert At Position 2
10 8 -7 -7

14. Insert At Position 2
10 8 8 -7

15. Insert At Position 2
10 23 8 -7

16. General Insert
bool List::insert(int x, int pos){
if(pos<1 || pos > size+1 || size==MAX)
return false;
for(int i=size; i>pos-1; i--)
items[i] = items[i-1];
items[pos-1] = x;
size++;
return true;
}

17. Insert at Front
10 23 8 -7

18. Insert at Front
10 23 8 -7 -7

19. Insert at Front
10 23 8 8 -7

20. Insert at Front
10 23 23 8 -7

21. Insert at Front
10 10 23 8 -7

22. Insert at Front
49 10 23 8 -7

23. Insert Front
bool List::insertFront(T x){
if(size==MAX)
return false;
for(int i=size; i>0; i--)
items[i] = items[i-1];
items[0] = x;
size++;
return true;
}

24. Delete Item at Position 2
49 10 23 8 -7

25. Delete Item at Position 2
49 23 23 8 -7

26. Delete Item at Position 2
49 23 8 8 -7

27. Delete Item at Position 2
49 23 8 -7 -7

28. DeleteItem/Erase
bool List::erase(int pos){
if(pos < 1 || pos > size)
return false;
for(int i=pos-1; i<size-1; i++)
items[i] = items[i+1];
size--;
return true;
}

29. Appending 13
49 23 8 -7 -7

30. Appending 13
49 23 8 -7 13

31. Accessing an Item
49 23 8 -7 13

32. itemAt
int List::itemAt(int pos){
return items[pos-1];
}
int List::itemAt(int pos){
if(pos<1 || pos>size)
throw “Invalid Position.”;
return items[pos-1];
}

33. Advantages
Running time
Access

34. Downside
Static storage
Solution
Dynamic Array

35. Dynamic Array Implementation
class template<T>;
class List{
private:
int *items;
int size;
void expand();
public:
List();
bool append(int);
bool insertFront(int);
bool insert(int,int);
bool erase(int);
int itemAt(int);
};

36. Constructor
List::List(){
items = new int[10];
size = 0;
}
List::~List(){
delete items;
}

37. Expand
void List::expand(){
int *copy = new int[size];
for(int i=0; i<size; i++)
copy[i] = items[i];
delete items;
items = new int[size+10];
for(int i=0; i<size; i++)
items[i] = copy[i];
delete copy;
}

38. Linked List Implementation
9

39. Linked List Implementation
9 17

40. Linked List Implementation
49 9 17

41. Linked List Implementation
49 -2 9 17

42. Memory Allocation (Heap)
0
32 17 NULL
64 9 32
96
128 49 182
150
182 -2 64

43. Linked List Implementation
class node{
public:
int item;
node *next;
node(int x){
item = x;
next = NULL;
}
};

44. Linked List Implementation
class List{
private:
node *head, *tail;
int size;
public:
List();
~List();
void append(int);
void insertFront(int);
bool insert(int,int);
int itemAt(int);
bool erase(int);
};

45. Constructor
List::List(){
head = tail = NULL;
size = 0;
}

46. Append
49 -2 9 17
23

47. Append
49 -2 9 17
23

48. Append
49 -2 9 17
23

49. Append
void List::append(int x);
node * n = new node(x);
tail->next = n;
tail = n;
size++;
}

50. Append
void List::append(int x);
node * n = new node(x);
if(size==0)
head = tail = n;
else{
tail->next = n;
tail = n;
}
size++;
}

51. insertFront
49 -2 9 17
23
103

52. insertFront
49 -2 9 17
23
103

53. insertFront
49 -2 9 17
23
103

54. insertFront
void List::insertFront(int x){
node *n = new node(x);
if(size==0)
head = tail = n;
else{
n->next = head;
head = n;
}
size++;
}

55. Insert at Position 6
49 -2 9 17
23
103
67

56. Insert at Position 6
49 -2 9 17
23
103
67

57. Insert at Position 6
49 -2 9 17
23
103
67

58. Insert at Position 6
49 -2 9 17
23
103
67

59. Insert at Position 6
49 -2 9 17
23
103
67

60. Insert at Position 6
49 -2 9 17
23
103
67

61. Insert at Position 6
49 -2 9 17
23
103
67

62. Insert at Position 6
49 -2 9 17
23
103
67

63. Insert at Position 6
49 -2 9 17
23
103
67

64. Insert at Position 6
49 -2 9 17
23
103
67

65. General Insert
bool List::insert(int x, int pos){
if(pos < 1 || pos > size+1)
return false;
if(pos==1)
insertFront(x);
else
if(pos==size+1)
append(x);
else{
node * tmp = head;
for(int i=1; i<pos-1;i++)
tmp = tmp->next;
n->next = tmp->next;
tmp->next = n;
size++;
}
return true;
}

66. Delete Item at Position 3
49 -2 9 17

67. Delete Item at Position 3
49 -2 9 17

68. Delete Item at Position 3
49 -2 9 17

69. Delete Item at Position 3
49 -2 9 17

70. Delete Item at Position 3
49 -2 9 17

71. Delete Item at Position 3
49 -2 9 17

72. Delete Item at Position 3
49 -2 9 17

73. Delete Item at Position 3
49 -2 17

74. deleteItem/erase
bool List::erase(int p){
if(p < 1 || p > size)
return false;
else{
node *del;
if(pos==1){
del = head;
head = head->next;
if(head==NULL)
tail = NULL;
}
else{
node * tmp = head;
for(int i=1; i<pos-1;i++)
tmp =tmp->next;
del = tmp->next;
tmp->next = del->next;
if(del==tail)
tail = tmp;
}
delete del; size--; return true;
}
}

75. itemAt
int List::itemAt(int pos){
try{
node *tmp=head;
for(int i=1; i<pos; i++)
tmp = tmp->next;
return tmp->item;
}
catch(…){
throw “Invalid Position.”
}
}