CS3334 Lecture 3

最新推荐文章于 2024-09-12 23:04:59 发布

weixin_30883311

最新推荐文章于 2024-09-12 23:04:59 发布

阅读量235

点赞数

文章标签： c/c++

原文链接：http://www.cnblogs.com/charon922/p/8413176.html

版权

Arrays, Linked Lists, Stacks & Queues

Introduction

How to store and organize data in a computer so that the data can be managed efficiently.

-Representation of data

-Algorithms (methods) for managing data (usually include search, insert, delete, and update)

Efficiency is important

Focus on main memory data storage; data storage in secondary storage (e.g., hard disks and databases) is usually called indexing structures

Array

Array is a data structure that arranges items at equally spaced addresses in computer memory

int foo[7]

Unsorted Arrays

Pros:

Array elements can be accessed by specifying the array name followed by the index in square brackets. Eg foo[2] is 8

Efficient for insertion by appending a new element.

Cons:

Have to scan through the whole array to determine for sure if an item is not there

Sorted Arrays

Pros:

Efficient for searching

Cons:

Have to move all items behind the point of insertion to make room for the new one

Linked Lists

A linked list is a data structure that allows both efficient searching and insertion/deletion.

A collection of items linked in a sequence:

Pros:

Easy to insert/delete items in the middle, provided we know where to insert/delete (a sorted linked list can easily be maintained.)

Cons:

Difficult to access the i-th item, given an arbitrary i

Linked Lists: Node

struct Node {
   Node(): next(NULL) {}
   Node(int newData): data(newData), next(NULL) {}
   Item data;    // Item is a generic data type
   Node* next;
};

Linked Lists: Traversing (non-circular)

// Suppose head points to the 1st node of a list Node* p = head;
while (p!=0)
{
    // process p->data
    p = p->next; 
}

Linked Lists: Insert a Node

// To insert a node after the node pointed to by p.
// newData is a variable of type Item
1. Node *temp = new Node(newData);
2. temp->next = p->next;
3. p->next = temp;

1.2.3.

Linked Lists: Delete a Node

// To delete a node after the node pointed to by p
// var. retData to retrieve content of deleted node
1. Node *temp = p->next;
2. retData = temp->data;
3. p->next = temp->next;
4. delete temp;

1.3.

Variations of Linked Lists

Singly- / doubly-linked
With / without dummy head node
Circular / non-circular

E.g., a circular doubly-linked list with a dummy head node

E.g., a non-circular doubly-linked list without a dummy head node

E.g., a non-circular singly-linked list without a dummy head node

Stacks

A stack is a sequence of elements in which update can only happen at one end of the sequence, called the top.

Operations supported:

– push(x): add an element x to the top

– pop(x): remove the top element and return it in x, i.e., first-in-last-out (FILO)

Array implementation of stack:

– Maintain size, i.e., the number of elements in stack

– Elements stored in A[0..size-1]

The oldest one at A[0] is called bottom of stack
The newest one at A[size-1] is called top of stack

– push(x):

Store x at A[size]; then increase size by 1

– pop(x):

If size = 0, return “Empty Stack”, otherwise decrease size by 1 and store A[size] in x

The method of choosing the size of array A[] (As we insert more and more, eventually the array will be full) - A dynamic array

Maintain capacity of A[]
Double capacity when capacity=size (i.e. full)
Half capacity when size≤capacity/4

Stacks: C++ Code

class Stack {
   public:
      Stack(int initCap=100);
      Stack(const Stack& rhs);
      ~Stack();

　　　 void push(Item x); 
　　　 void pop(Item& x);
   private:
     void realloc(int newCap);
     Item* array;
     int size;
     int cap;
};

void Stack::push(Item x)
{
   if (size==cap) realloc(2*cap);
   array[size++]=x;
}
// An internal func. to support resizing of array
void Stack::realloc(int newCap)
{
   if (newCap < size) return;
　　Item *oldarray = array; //oldarray is “point to” array
　　array = new Item[newCap]; //create new space for array //with a size of newCap
   for (int i=0; i<size; i++)
      array[i] = oldarray[i];
　　cap = newCap;
　　delete [] oldarray; 
}

void Stack::pop(Item& x)
{
    if (size==0)
        x=EmptyStack;
        // assume EmptyStack is a special value
    else {
        x=array[--size];
        if (size <= cap/4)
            realloc(cap/2);
    } 
}

Stack: Time complexity

Let n = current number of elements in the stack; n changes as pushes/pops are performed
Excluding the time for expanding/shrinking the array, push() and pop() need O(1) time in the worst case
Array expanding/shrinking is costly (O(n) time) but is needed once after at least n/2 operations
E.g., initial cap is 4, after 5 push operations
- size = n = 5, cap = 8, n/2 = 2.5
- Need ≥ 4 more push operations to trigger array expanding
- Need ≥ 3 more pop operations to trigger array shrinking

Stacks: Space Complexity

When there are n elements in a stack, the largest required capacity of the stack is 4n. E.g., when size=n=2, the largest required capacity cap=8 (just before shrinking).
Space allocated for array A[0..cap-1] is: ≤ max{100, 4n}

Therefore, the space complexity is S(n) = O(n).

Linked list implementation of stack:

May use a circular doubly-linked list
push(x): call insertFront(x)
pop(x): if stack not empty, call deleteFront(x)

Conclusion:

Both array and linked-list implementations are efficient:

Excluding array expansion/shrinking, all operations take O(1) time in the worst case

Queues

A queue is a list of elements in which insertion can only be done at one end and deletion at the other.

Operations supported:

– EnQueue(x): insert element x at the end

– DeQueue(x): delete the front element and return it in x, i.e., first-in-first-out (FIFO)

Circular array implementation of queue:

Maintain 2 variables: front and size
Elements stored in A[front..front+size-1], the oldest element at A[front], the newest element at A[front+size-1]
Wrap around the array, if necessary, using “%capacity”. (front+size)%capacity

EnQueue(x):
- Store x at A[(front+size)%capacity] and increase size by 1
DeQueue(x):
- If queue is not empty, copy A[front] to x, increase front by 1 and decrease size by 1
Whenever front becomes ≥ capacityof A[], subtract front by capacity, i.e., front=front-capacity.