ScaleFree

DS & A (Lists - Array Based)

By

| CHAPTER 9 |

"The List Data Structure", Yep, that's exactly what today's chapter is gonna be about. So, without any further ado let's have a sneak peek of today's chapter.
  • Intro to Lists
  • List ADT
  • List Implementation (Array-Based)
  • Pros and Cons of Array-Based List
Pre-requisite: C++
Intro to Lists

Credits: <Link 1> <Link 2>

Definition
A list in Data Structures can be defined as a sequence of ordered values.
General Properties:
  • Can be Sorted or Unsorted
  • Can be Finite or Infinite
Note: We will be working with finite lists.
Example

  • The List is of size n.
  • Each element has a datatype
  • The List can be empty. (Empty Lists)
  • List length is the number of elements stored.
  • The beginning of the List is called Head.
  • The end of the List is called Tail.
Basic functions of a List
  1. Retrieve value.
  2. Insert/Delete/Modify value.
  3. Search for a value.
List ADT

  1. template<typename e> class List
  2. {
  3.      //Empty the list
  4.      virtual void clear() = 0;

  6.      //Insert value of e into the list at a position before the current position
  7.      virtual bool insert(const e&) = 0;

  9.      //Append e to the list
  10.      virtual bool append(const e&) = 0;

  12.      //Remove element at the current position
  13.      virtual bool remove(e&) = 0;

  15.      //set current position to the beginning
  16.      virtual void setStart() = 0;

  18.      //Set current position to the end
  19.      virtual void setEnd() = 0;

  21.      //Set current position to the previous element
  22.      virtual void prev() = 0;

  24.      //Set current position to the next element
  25.      virtual void next() = 0;

  27.      //Size of list to the left of current element
  28.      virtual int leftLength() const = 0;

  30.      //Size of list to the right of current element + 1(inclusion of current element)
  31.      virtual int rightLength() const = 0;

  33.      //Set current position to pos
  34.      virtual bool setPos(int pos) = 0;

  36.      //Get value at current position
  37.      virtual bool getValue(e& item) const = 0;

  39.      //Print list
  40.      virtual void print() const = 0;
  41. };

List Implementation
  • Array-Based List Implementation
  1. #include <iostream.h>
  2. #include "name_of_the_ListADT_file.h"

  4. template<typename e>
  5. class AList:public List<e>
  6. {
  7. private:
  8.      int maxSize;     // maximum size of list
  9.      int listSize;    // number of stored values in the list
  10.      int fence;       // position of fence
  11.      e* listArray;    // array holding list

  13. public:
  14.      AList(int size = 0)
  15.      {
  16.           maxSize = size;
  17.           listSize = fence = 0;
  18.           listArray = new e[maxSize];
  19.      }
  20.      ~AList()
  21.      {
  22.           delete []listArray;
  23.      }

  25.      //Mandatory redeclaration because these functions are pure virtual in the base class
  26.      void clear() override;
  27.      bool insert(const e&) override;
  28.      bool append(const e&) override;
  29.      bool remove(e&) override;
  30.      void setStart() override;
  31.      void setEnd() override;
  32.      void prev() override;
  33.      void next() override;
  34.      int leftLength() const override;
  35.      int rightLength() const override;
  36.      bool setPos(int pos) override;
  37.      bool getValue(e& item) const override;
  38.      void print() const override;
  39. };

  41. template<typename e>
  42. void AList<e>::clear()
  43. {
  44.      listSize = fence = 0;
  45.      delete []listArray;
  46.      listArray = new e[maxSize];
  47. }

  49. template<typename e>
  50. bool AList<e>::insert(const e& item)
  51. {
  52.      if(maxSize == listSize)
  53.      {
  54.           return false;
  55.      }
  56.      for(int i = listSize; i>fence; i--)
  57.      {
  58.           listArray[i] = listArray[i-1];
  59.      }
  60.      listArray[fence] = item;
  61.      listSize++;
  62.      return true;
  63. }

  65. template<typename e>
  66. bool AList<e>::append(const e& item)
  67. {
  68.     if(listSize == maxSize)
  69.     {
  70.         return false;
  71.     }
  72.     listArray[listSize++] = item;
  73.     return true;
  74. }

  76. template<typename e>
  77. bool AList<e>::remove(e& item)
  78. {
  79.     if(rightLength() == 0)
  80.     {
  81.         return false;
  82.     }
  83.     item = listArray[fence];
  84.     for(int i=fence; i<listSize; i++)
  85.     {
  86.         listArray[i] = listArray[i+1];
  87.     }
  88.     listSize--;
  89.     return true;
  90. }

  92. template<typename e>
  93. void AList<e>::setStart()
  94. {
  95.     fence = 0;
  96. }

  98. template<typename e>
  99. void AList<e>::setEnd()
  100. {
  101.     fence = listSize;
  102. }

  104. template<typename e>
  105. void AList<e>::prev()
  106. {
  107.     if(fence == 0) return;
  108.     fence--;
  109. }

  111. template<typename e>
  112. void AList<e>::next()
  113. {
  114.     if(fence == listSize-1) return;
  115.     fence++;
  116. }

  118. template<typename e>
  119. int AList<e>::leftLength() const
  120. {
  121.     return fence;
  122. }

  124. template<typename e>
  125. int AList<e>::rightLength() const
  126. {
  127.     return listSize-fence;
  128. }

  130. template<typename e>
  131. bool AList<e>::setPos(int pos)
  132. {
  133.     if(pos>=0 && pos<=listSize)
  134.     {
  135.         fence = pos;
  136.         return true;
  137.     }
  138.     return false;
  139. }

  141. template<typename e>
  142. bool AList<e>::getValue(e& item) const
  143. {
  144.     if(listSize == 0)
  145.     {
  146.         return false;
  147.     }
  148.     item = listArray[fence];
  149.     return true;
  150. }

  152. template<typename e>
  153. void AList<e>::print() const
  154. {
  155.     std::cout<<"[ ";
  156.     for(int i=0; i<listSize; i++)
  157.     {
  158.         std::cout<<((i==fence)?"| ":"")<<listArray[i]<<((i==listSize-1)?" ]\n":", ");
  159.     }
  160. }
  • Array-Based List Structure Visualization
  • Testing the Array-Based list implementation
  1. int main()
  2. {
  3.     AList<int> newList(10); //creating a list object

  5.     //Adding values to the list
  6.     newList.append(1);
  7.     newList.append(12);
  8.     newList.append(21);
  9.     newList.append(132);
  10.     newList.append(321);
  11.     newList.append(89);
  12.     newList.append(567);
  13.     newList.append(43);
  14.     newList.append(233);
  15.     newList.append(67);

  17.     //The following values won't be added to the list since maxSize = 10

  19.     newList.append(33);
  20.     newList.append(54);
  21.     newList.append(78);

  23.     newList.print();

  25.     newList.setPos(8);              //changing the position of the fence 
  26.     std::cout<<"\nAfter setting position to 8\n";
  27.     newList.print();
  28.     
  29.     int value;                      //temporary variable to store values
  30.     
  31.     //getting the previous value
  32.     
  33.     newList.prev();                 //setting the fence to the PREVIOUS value     
  34.     newList.getValue(value);        //value is passed by reference     
  35.     std::cout<<"\nAccessing Previous Value: "<<value<<std::endl;      
  36.     
  37.     //getting the next value     
  38.     
  39.     newList.next();                 //setting the fence to the NEXT value     
  40.     newList.getValue(value);        //value is passed by reference     
  41.     std::cout<<"Accessing Next Value    : "<<value<<std::endl;      
  42.     
  43.     //Removing the current value at the fence     
  44.     
  45.     newList.remove(value);          //stores the value of the removed item    
  46.     std::cout<<"\nAfter removing a value: \n";     
  47.     newList.print();     
  48.     std::cout<<"\nDisplaying Removed Value: "<<value<<std::endl;      
  49.     newList.setStart();             //sets the fence to the beginning of the list     
  50.     std::cout<<"\nAfter setting position to the start:\n";     
  51.     newList.print();      
  52.     
  53.     //Inserting the removed value(i.e.,233) at the beginning of the List     
  54.     
  55.     newList.insert(value);     
  56.     std::cout<<"\nAfter Inserting removed value to the list again:\n";     
  57.     newList.print();     
  58.     return 0;
  59. }

Pros and Cons Of  Pointer-Based List
Pros:
  • No overhead if all array positions are filled. (Overhead is the amount of memory needed to maintain a data structure).
Cons:
  • The array must be allocated in advance.
  • Waste of memory if all array positions are not filled.
( If you like the content here, follow TSP on social media to get notified on future updates)


Comments

Post a Comment

Share on Social Media

Most Viewed Posts

DS & A (Algorithm Analysis - Best, Worst and Average Case)

By
Image
|  CHAPTER 5  | Note: If it's your first time visiting this website I strongly recommend you to read the previous chapter before reading this chapter. Till now we learned about what Data Structures and Algorithms are, some basic terminologies and a few  concepts  of Algorithm analysis.   And continuing our ongoing journey of Data Structures and Algorithms, today we will discuss the Best Case, Average Case and Worst Case of an algorithm. Algorithm Case Analysis In the last chapter, we learned that every algorithm has running time[T(n)] and a growth rate. But that's not the end of it, an algorithm's running time and growth rate are not the only factors that we should consider while designing an algorithm. For some algorithms, different inputs result in different running time. And that brings forth the necessity of the concept of Best, Average, and Worst Case of algorithms. Example Consider we have four boxes tagged 1,2,3 & 4, and the boxes con
Read more

SPACE & DRAGONS

By
Image
Space and Dragons is a top-down endless space shooter where the player takes on the role of a brave space warrior. In the game, the player has to fight against fierce Space Dragons while making the way through other obstacles such as space debris and much more. FEATURES: SPACE DRAGONS MOVING DEBRIS POWER-UPS HEALTH BOOST SHIELD AND much more SCREENSHOTS...... APPLICATIONS USED : QT Creator (A C++ based framework) GIMP (An Image Manipulation Software) AUDACITY (An Audio Manipulation Software) NOTE: The game resources have been collected from the OpenGameArt website and various other online sources. The used game assets are not my property. GAME DOWNLOAD LINK: DOWNLOAD GAME GAME REQUIREMENTS OS : WINDOWS RAM : 1 GB HARD DRIVE : 150 MB CONTROLS: LEFT, RIGHT keys for movements and SPACE to Shoot SPACE SHOOTER IN ACTION UPDATE << Click here to download the source code >> Zip Password: TheSuperProgrammer NOTE: The game
Read more

DS & A(Queue)

By
Image
|  CHAPTER 14  | In this chapter, our topic of discussion will be the "Queue" Data Structure. But, before we get started, I would recommend you to read the previous chapters on Data Structures & Algorithms  (especially the chapters on Array List , Linked List , Array Stack , and Linked Stack ), that is in case it's your first time visiting my blog. Queue: Just like Stacks, Queues also are a restricted version of List but with a few minor differences compared to Stack. The following are some of the notable characteristics of a Queue: Data can only be inserted from the rear/back. Data insertion is referred to as  ENQUEUE . Data can only be deleted from the front. Data deletion is referred to as  DEQUEUE . Alternatively,  ENQUEUE  and  DEQUEUE  should always be executed on the opposite ends of the Queue. A Queue follows the  FIFO (First In First Out)   principle. The first and the last elements are referred to as FRONT and REAR respectively.
Read more