Download Advance Data Structure Review of Chapter 2

Advance Data Structure
Review of Chapter 2
張啟中
Review of Chapter 2 Arrays


1.3 Data Abstraction and Encapsulation
2.2 The Array As An abstract Data Type


2.5 The Representation of Arrays
Example



2.3 The Polynomial Abstract Data Type
2.4 The Sparse Matrix Abstract Data Type
2.6 The String Abstract Data Type
定義：Data Type
A data type is a collection of objects
and a set of operations that act on
those objects.
定義：Abstract Data Type
An abstract data type(ADT) is a data type that is
organized in such a way that the specification of
the objects and the operations on the objects is
separated from the representation of the objects
and the implementation of the operations.
資料型態





Data Types
Primitive Data Types
Accumulated Data
Types
- Array
- Structures
- Union
Abstract Data Types
Examples
Example: Data Type of C++
Name of Type
# of bits
Range
char
8
-128 ~ 127
字元
unsigned char
8
0 ~ 255
字元
short
16
-215 ~ 215 - 1
unsigned short
16
0 ~ 216 - 1
int
32
-231 ~ 231 - 1
unsigned
32
0 ~ 231 - 1
正整數
long
32
-231 ~ 231 - 1
長整數
unsigned long
32
0 ~ 231 - 1
float
32
-1037 ~ 1037
double
64
-10308 ~ 10308
Type
短整數
正短整數
整數
正長整數
浮點數
倍準浮點數
表一：C++ 的基本資料型態
Accumulated Data Type

Array

Struct

Union
如何理解 Abstract Data Types


ADTs 是一個物件的型態的抽象定義具有一般
化的特性，其中也包含這個物件相關的操作。
Data Structures 課程，旨在瞭解每一個 ADT，
要用什麼樣的結構來表達與儲存，而這樣的表
達與儲存方式，又對於該物件的操作帶來什麼
樣的優缺點。亦即關注在二個重點：


物件儲存與表達方式（資料結構）
物件操作方式（演算法）
The Array as an Abstract Data Type

Array


A collection of data of the same type
An array is usually implemented as a
consecutive set of memory locations


int list[5], *plist[5]
ADT definition of an Array


More general structure than "a consecutive set
of memory locations.“
An array is a set of pairs, <index, value>, in
mathematical, call correspondence or
mapping
class GeneralArray {
// objects: A set of pairs <index, value> where for each value of index in
// IndexSet there is a value of type float. IndexSet is a finite ordered set of one
// or more dimensions, for example, {0, …, n - 1} for one dimension, {(0, 0),
// (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)} for two dimensions, etc.
public:
GeneralArray(int j, RangeList list, float initValue = defaultValue) ;
// The constructor GeneralArray creates a j dimensional array of floats; the
// range of the kth dimension is given by the kth element of list. For each
// index i in the index set, insert <i, initValue> into the array.
float Retrieve(index i) ;
// if (i is in the index set of the array) return the float associated with i in the
// array; else signal an error.
void Store(index i, float x) ;
// if (i is in the index set of the array) delete any pair of the form <i, y>
// present in the array and insert the new pair <i, x>; else signal an error.
} ; // end of GeneralArray
Array（陣列）

陣列是用來存放同樣型態的資料

陣列的大小必須在程式中預先設定

在程式執行中，陣列的大小無法改變

陣列中的資料是透過索引（index）來存取
const int ArraySize = 100;
int iArray[ArraySize];
一維陣列和記憶體間的對應
Memory
m
m+2
m+4
m+6
int iArray[100];
m + 198
7 51 22
43 9
0
98 99
1
2
假定 sizeof(int) = 2
多維陣列和記憶體間的對應
Memory
m
6
m + 22
5
m + 44
4
m + 66
3
2
m + 88
1
m + 110
0
m + 132
0
1
2
3 4
5
6
7
8
9 10
int mesh[7][11];
mesh[i][j] = mesh +11 i + j
假定 sizeof(int) = 2
多維陣列的宣告
type array_name[arraySize1] ...... [arraySizen];
【範例】
int mesh[7][11];
6
5
4
3
2
1
0
float cube[6][8][3];
5
4
3
2
1
0
0 1 2 3 4 5 6 7 8 9 10
0 1 2 3 4 5 6 7
0
1
2
m
m + 48
m + 96
5
m + 144
4
3
2
1
m + 192
0
0
1
2
3
4
5
6
7 0
1
2
m + 240
m + 288
float cube[6][8][3];
假定 sizeof(int) = 2
cube[i][j][k] = cube + 24i + 8j+ k
struct 和記憶體間的對應
m
struct studentType {
char Name[20];
char Address[30];
char PhoneNumber[10];
int Age;
char Department[4];
int Year;
char Class;
};
m + 20
// 姓名
// 地址
// 電話
// 年齡
// 系別
// 年級
// 班級
m + 50
m + 60
m + 62
m + 66
m + 68
studentType Student1, Student2;
假定 sizeof(int) = 2
Self-Referential Structures
One or more of its components is a pointer to itself.
typedef struct list {
char data;
list *link;
}
Construct a list with three nodes
item1.link=&item2;
item2.link=&item3;
malloc: obtain a node
list item1, item2, item3;
item1.data=‘a’;
a
b
item2.data=‘b’;
item3.data=‘c’;
item1.link=item2.link=item3.link=NULL;
c
union 的宣告
宣告變數
宣告型態
union {
field1 declaration;
field2 declaration;
typedef union {
field1 declaration;
field2 declaration;
} variable_name;
} type_name;
【範例】
union {
char charValue;
int intValue;
float floatValue;
} dataCell;
typedef union {
char charValue;
int intValue;
float floatValue;
} dataCellType;
union 和記憶體間的對應
union {
char charValue; /* 1 byte */
int intValue;
/* 2 byte */
float floatValue; /* 4 byte */
} dataCell;
typedef struct {
char opcode;
union {
int intValue;
char strValue[256];
} data;
} instruction;
m
m+4
m
m+1
m+5
m + 257
Example




Ordered List
Polynomial ADT
Sparse Matrix ADT
String ADT
Ordered List Examples
ordered (linear) list: (item1, item2, item3, …, itemn)

(MONDAY, TUEDSAY, WEDNESDAY, THURSDAY,
FRIDAY, SATURDAYY, SUNDAY)

(2, 3, 4, 5, 6, 7, 8, 9, 10, Jack, Queen, King, ACE)

(1941, 1942, 1943, 1944, 1945)

(a1, a2, a3, …, an-1, an)
()

Operations on Ordered List






Find the length, n , of the list.
Read the items from left to right (or right to left).
Retrieve the i’th element.
Store a new value into the i’th position.
Insert a new element at the position i , causing
elements numbered i, i+1, …, n to become numbered
i+1, i+2, …, n+1
Delete the element at position i , causing elements
numbered i+1, …, n to become numbered i, i+1, …, n-1
array (sequential mapping)? (1)~(4) O
(5)~(6) X
Polynomial（多項式）
P( x )  a n x n  a n 1 x n 1  a1 x  a0
n
  ak x k
k 0
Addition:
6x3  4x 2  2x  1
 7x3  2x 2  x  4
13x 3  2 x 2  x  5
Multiplication:
( 2 x 3  x  2)( 2 x  1)
 4 x 4  2 x 3  2 x 2  (1  4) x  2
 4 x 4  2 x 3  2 x 2  3x  2
class Polynomial {
// objects: p(x) = a0xe0 + … + anxen; a set of ordered pairs of <ei, ai>, where
// ai ∈ Coefficient and ei ∈ Exponent
// We assume that Exponent consists of integer ≥０
public:
Polynomial() ;
// return the polynomial p(x) = 0
int operator!() ;
// if *this is the zero polynomial, return 1; else return 0;
Coefficient Coef(Exponent e) ;
// return the coefficient of e in *this
Exponent LeadExp() ;
// return the largest exponent in *this
Polynomial Add(Polynomial poly) ;
// return the sum of the polynomials *this and poly
Polynomial Mult(Polynomial poly);
// return the product of the polynomials *this and poly
float Eval(float f) ;
//Evaluate the polynomial *this at f and return the result.
}; // end of Polynomial
Polynomial: Representation 1

Representation by Degrees
private
int degree; // degree  MaxDegree
float coef [MaxDegree + 1];

Example:
Let A(x)=Σaixi , then
a.degree= n,
a.coef[i]=an-i, ,0<= i<= n
Polynomial: Representation 1
P( x )  an x    a1 x  a0
n
degree
n
coef a n
0
an1 an2
1
2
a1
a0
n-1
n
Polynomial: Representation 2

Representation by Degrees, but dynamic
allocation space
private:
int degree; //degree <= MaxDegree
float *coef;
polynomial::polynomial(int d)
{
degree= d,
coef=new float[degree+1];
}
Polynomial: Representation 3

Representation by Terms.
Class polynomial;
Class term {
Friend polynomial;
private:
int exp
float coef;
};

In polynomial class
private:
static term termArray[MaxTerms]; // MaxTerms is a constant.
// termArray[MaxTerms] shared by all polynomial objects.
static int free;
int start, finish;

In Implement file of polynomial class
term Polynomial::termArray[MaxTerms];
int polynomial::free = 0;
Polynomial: Representation 3-1
A(X)=2X1000+1
B(X)=X4+10X3+3X2+1
A.start A.finish B.start
coef
exp
B. finish free
2
1
1
10
3
1
1000
0
4
3
2
0
0
1
2
3
4
5
In general, A.Finish = A.Start + n –1.
For zero polynomial, A.Finish = A.Start – 1
6
Polynomial: Representation 3-2
P( x )  c1 x e1  c2 x e2   ck x ek , e1  e2    ek
numTerm
k
coef
c1
c2
c3
ck
0
1
2
k-1
e1
e2
e3
ek
0
1
2
k-1
expon
?
?
The Representations of Polynomials Compare
Representation 1 Representation 2 Representation 3
Advantages
Disadvantages
Simply algorithms for
most operations
Waste spaces
if a.degree <<
MaxDegree
Save space than R1
Save space when
polynomial is sparse
than R1, R2
Waste spaces when
polynomial is sparse
Waste twice space
when all terms are
nonzero than R2，
and algorithms is
complex than R1, R2
操作分析

多項式相加


As Representation 3，we take O(m+n) at time complexity，if
A(x) has m terms, B(x) has n terms. See Book pp.83-84
多項式相乘
Sparse Matrix
col1 col2
row0
row1
row2
row3
row4
5*3
(a)
row5
15/15
*Figure 2.3:Two matrices
col3
col4 col5 col6
15 0 0 22 0  15
 0 11 3

0
0
0


 0 0 0 6 0
0


0
0
0
0
0
0


91 0 0
0 0
0


0 0
0
 0 0 28
6*6
(b)
8/36
sparse matrix
data structure?
若以二維陣列的表示法：
#define MAX_ROW 100
#define MAX_COL 100
typedef int matrix[MAX_ROW][MAX_COL];
matrix m1, m2;
來儲存稀疏矩陣，那麼，矩陣中含有許多的 0。有沒有必要
儲存這些 0 呢？有沒有比較節省記憶體空間的另類表示法？
Abstract Data Type Sparse Matrix
class SparseMatrix
{
//objects: a set of triples, <row, column, value>, where row and column are integers and
// form a unique combination, and value comes from the set item.
public:
SparseMatrix(int MaxRow, int MaxCol);
//create a SparseMatrix that can hold up to MaxItems= MaxRow*MaxCol and whose
//maximum row size is MaxRow
and whose maximum column size is MaxCol
SparseMatrix Transpose();
// return the matrix produced by interchanging the row and column value of every triple.
SparseMatrix Add(SparseMatrix b);
//if the dimensions of a(*this) and b are the same, return the matrix produced by adding
//corresponding items, namely those with identical row and column values. else return
//error.
SparseMatrix Multiply(a, b);
//if number of columns in a equals number of rows in b return the matrix d produced by
//multiplying a by b according to the formula: d[i][j]= Sum(a[i][k](b[k][j]),
//where d(i, j) is the (i, j)th element, k=0 ~ ((columns of a) –1) else return error.
};
Representation of Sparse Matrix
class SparseMatrix;
class MatrixTerm {
friend class SparseMatrix
private:
int col, row, value;
};

In class SparseMatrix
private:
int col, row,Terms;
MatrixTerm smArray[MaxTerms];
// Note: triples are ordered by row and within rows by columns
row 0
row 1
row 2
row 3
row 4
row 5
col 0
1
2
3
15
0
0
0
91
0
0
11
0
0
0
0
0
3
0
0
0
28
22
0
-6
0
0
0
a[0]
a[1]
a[2]
a[3]
a[4]
a[5]
a[6]
a[7]
row
0
0
0
1
1
2
4
5
4
5
term
0 -15
0
0
0
0
0
0
0
0
0
0
col
0
3
5
1
2
3
0
2
value
15
22
-15
11
3
-6
91
28
Sparse Matrix 運算分析



轉置 (transpose)
相加
相乘
Abstract Data Type String
Class String
{
//objects: a finite set of zero or more characters.
public:
String (char *init, int m);
//Constructor that initializes *this to string init of length is m.
int operator==(string t);
// if the string represented by *this equal string t return 1(true) else return 0(false)
int operator!();
// if *this is empty then return 1(TRUE); else return 0 (FALSE).
int Length();
//return the number of characters in *this.
String Concat(String t);
//return a string whose elements are those of *this followed by those of t.
String Substr(int i, int j);
//return the string containing j characters of *this at positions i, i+1, ..., i+j-1,
//if these are valid positions of *this; else return empty string.
int Find(String pat);
//return an index i such that pat matches the substring of *this that begins at
//position i. Return –1 if pat is either empty or not a substring of *this.
};
Pattern Matching


Given two strings, string and pat, where pat is a pattern
to be searched for in string
Two methods


a simple algorithm
 O(S*P)  O(n2)
optimal algorithm (by Knuth-Morris-Pratt)


Linear complexity
O(S+P)  O(n)
A simple algorithm
a
a
b
a
a
a
b
a
b
a
b
a
b
b
a
pattern
a
a
a
a
no match
b
a
a
match
pattern
b
b
a
a
O(n*m)
The Failure Function

Definition


If p= p0p1. . .pn-1 is a pattern, then its failure function, f is defined as:
f(j) = largest i< j such that p0p1. . .pi= pj-ipj-i+1. . .pj , i>= 0
= -1, otherwise
Example
j
pat
f
0 1 2 3 4 5 6 7 8 9
a b c a b c a c a b
-1 -1 -1 0 1 2 3 -1 0 1
Rule for Optimal Pattern Matching

If a partial match is found such that si-j. . .si-1= p0p1. . .pj-1
and si<>pj then matching may be resumed by comparing
si and pf(j-1)+1 if j<>0. If j= 0, continue by comparing si+1
and p0
string a b c a ? ? . . . ?
pat a b c a b c a c a b
f -1 -1 -1 0 1 2 3 -1 0 1
Continue here
Example of Optimal Pattern Matching
j 0 1 2 3 4 5 6 7 8 9
pat a b c a b c a c a b
f -1 -1 -1 0 1 2 3 -1 0 1
str
cbabcaabcabcabcacab