A Guide for Students in the Helping Professions

by Paul Heppner and Mary J. Heppner

- Where To Begin: The Chapter Road Map
- Chapter Preliminary Components of the Results Chapter
**Data Screening**- (1) Check the accuracy of the data entry
- (2) Check missing data
- (3) Check outliers
- (4) Examine the normality of distributions [
**Skewness**involves the symmetry of the distribution;**Kurtosis**refers to the peakedness of the distribution and has three general types of curves (a. platykurtic (relatively flat), leptokurtic, and mesokurtic (relatively peaked)]. - (5) Determine the appropriateness of the data transformations.

**Preliminary Analysis**- (1) Check if scores on the dependent variable(s) are different across demographic variables
- (2) Assess the reliability coefficients and/or factor structure of the measures [Internal consistency, reliability, factor intercorrelations]
- (3) Analyze and report intercorrelations among variables [Multicollinearity refers to the potential adverse effects of correlated independent variables on the estimation of regression statistics; Zero-order correlations between the PSI (Problem-Solving Inventory) and NA (Negative Affectivity)]

**Descriptive Analysis**(mean and standard deviation)

- Writing Statistical Analyses to Describe the Results

**Chi-Square x**2**

Used when the research question is aimed at examining the frequency of a certain categorical or discontinuous variable (e.g., sex, race) or, more technically, the extent in which an observed or actual frequency count differs from the expected frequency count

- Writing the Results Using Chi-Square

**t Tests t**

Used when a research wants to compare the mean differences on a dependent variable [which should be a continuous variable (e.g., reading scores)] between two groups [i.e., the independent variable, which should be a discrete (or categorical) variable (e.g., sex)].

- Writing the Results Using t Tests

**Analysis of Variance (ANOVA)**

Used when a researcher wants to examine the mean differences of two or more levels of an independent variable on one dependent variable.

__One-Way ANOVA__(examine mean differences across multiple levels of one independent variable on one dependent variable)- Writing the Results Using One-Way ANOVA
__Two-Way ANOVA__(examine mean differences across multiple levels of two independent variable on one dependent variable)__Analysis of Covariance (ANCOVA)__- Used when a researcher wants to control for the effects of a third variable that potentially is confounded with the effect of independent variable(s).
- Writing the Results Using Two-Way ANCOVA
__Repeated Measures ANOVA__- Writing the Results Using Repeated Measures ANOVA

**Three Types of Multiple Regression**__Simultaneous Regression__- Used when a researcher is interested in examining the unique effects of each predictor on a criterion at the same time.
- Writing the Results Using Simultaneous Regression
__Stepwise Regression__- Used to identify which predictors account for the most variance, as well as the significance level for each predictor.
- Writing the Results Using the Stepwise Regression
__Hierarchical Regression__- Used when a researched is interested in the effects of the specific order of the predictors as determined by a priori theory or hypotheses.
- Writing the Results Using the Hierarchical Regression
- Testing Moderating Effect in a Hierarchical Multiple Regression
- Writing the Results of Testing a Moderator in a Hierarchical Multiple Regression

**Multivariate Analysis of Variance (MANOVA)**- Used when a researched wants to compare the mean differences among two or more groups on multiple dependent variables simultaneously.
- Writing the Results Using a MANOVA

**Cluster Analysis**- Used when a researcher is interested in grouping members (e.g., people or objects) on the basis of their common characteristics.
- Writing the Results Using Cluster Analysis

**Factor Analysis**__Exploratory Factor Analysis__(internal consistency, convergent validity)- Writing the Results Using Exploratory Factor Analysis
__Confirmatory Factor Analysis__(reliability, concurrent validity)- Writing the Results Using Confirmatory Factor Analysis

**Structural Equation Modeling (SEM)**- Used when a researcher wants to test the plausibility of a theory or a model about the predictive relationships among variables (e.g., variable A->B->C; note arrow represents hypothesized predictive effects)
- Writing the Results Using Structural Equation
__Modeling__(SEM)

- Grounded Theory
- Consensual Qualitative Research
- Phenomenology/Hermeneutics

]]>

Divide and conquer algorithm design paradigm

Randomization in algorithm design

Primitives for reasoning about graphs

Use and implementation of data structures

Vocabulary for design and analysis of algorithms

-E.g., “Big-Oh” notation

-“Sweet spot” for high-level reasoning about algorithms

-General analysis methods (“Master Method/Theorem”)

-Dynamic programming algorithm design paradigm

-NP-complete problems and what to do about them

-Fast heuristics with provable guarantees

-Fast exact algorithms for special cases

-Exact algorithms that beat brute-force search

-Sharpen your mathematical and analytical skills

-Start “thinking algorithmically”

-Literacy with computer science’s “greatest hits”

-Ace your technical interviews

Excellent free reference: “Mathematics for Computer Science” by Eric Lehman

*Good introduction to divide & conquer

-Improves over Selection, Insertion, Bubble sorts

*Calibrate your preparation

*Motivates guiding principles for algorithm analysis (worst-caseand asymptotic analysis)

*Analysis generalizes to “Master Method”

Output: same numbers, sorted in increasing order

Merge Sort: Example

Recursive algorithm

54187263

1 – 5418 -> 1458

2 – 7263 -> 2367

1 <> 2

===MERGE====

12345678

Recursively sort 1st half of input array -> merge two sorted sublists into one

Pseudocode for Merge:

C = output array [length=n]

A = 1st sorted array [n/2]

B = 2nd sorted array [n/2]

i = 1

J = 1

for k=1 to n

if A(i) < B(j)

C(k) =A(i)

i++

else [B(j)<A(i)]

C(k) = B(j)

j++

end

Key Question: running time of MergeSort on array of n numbers

Running time ~ #of lines of code executed]

Claim: Merge Sort requires <= 6 log2n + 6n operations to sort n numbers

2 * 2 * 2 =8 == 2**3 = 8

log2(8) = 3

Proof of claim (assuming n = power of 2)

[will use “recursion tree”]

The tree has the bottom recursive tree value:

(log2n +1) to be exact

base cases = single-element arrays

2*j and n/2*j -> number of subproblems

at each level = j =0,1,2,.., log2, there are 2*j subproblems, each of size n/2*j

Total # of operations at level j:

[each j =0,1,2,..log2n]

<=2*j

6n -> independent of level j

Claim: For every input of n numbers, Merge Sort produces a sorted output array and uses at most 6nlog2n+6n operations

As opposed to

-“Average-case” analysis (requires domain knowledge)

-Benchmarks (requires domain knowledge)

Won’t pay much attention to constant factors, lower-order terms

1 – way easier

2 – constants depend on architecture /compiler /programmer anyways

3 – lose very little predictive power

E.g. 6nlog2n+6n (merge sort) “better than” 1/2n**2 (insertion sort)

Adopt these 3 guiding principles:

II. ASYMPTOTIC ANALYSIS

The Gist

- ‘Sweet Spot’ for high-level seasoning about algorithms
- Coarse enough to suppress architecture /language compiler-dependent details

- Sharp enough to make useful comparisons between different algorithms, especially on large inputs (e.g., sorting or integer multiplication)

Lower-order returns become irrelevant for large inputs

Constant factors – too system-dependent

Where n = input size (e.g., length

Given A (array of length n)

And t (an integer)

For i= 1 to n

If A[i] ==t return True

Return False

- O(1)
- O(logn)
- O(n). Correct == Linear of input N
- O(n**2)

And t (an integer)

For I = 1 to n

If A[I] == t return True

For I = 1 to n

If B[i] == t return True

Return False

Question: Running Time?

- O(1)
- O(logn)
- O(n). Correct
- O(n**2)

Given arrays A,B of length n

For I =1 to n

For j =1 to n

If A[I] == B[j] return True

Return False

Question: Running Time?

- O(1)
- O(logn)
- O(n)
- O(n**2). Correct. Quadratic time algorithm

Given array A of length n

For I = 1 to n

For j = I + 1 to n

If A[i]==A[j] return True

Return False

Question: Running Time?

O(n**2). Correct. Quadratic time algorithm

]]>

*Important for all branches of computer science

*Plays a key role in modern technological innovation

*Provides novel ‘lens’ outside of computer science and technology

-quantum mechanics, economic markets, evolution

*Challenging (i.e., good for the brain!)

*Fun

Input: two n-digit numbers x and y

Output: the product x.y

“Primitive Operation”: add or multiply

2 single-digit numbers

Upshot: #operations overall <= constant * n**2

Can we do better?

Example:

X = 5678

Y = 1234

56 = a

78 = b

12 = c

34 = d

Step 1: Compute a * c = 672

Step 2: Compute b * d = 2652

Step 3: Compute (a+b)*(c+d) = 134*46 = 6164

Step 4: Compute (3) – (2) – (1) = 2840

Step 5: Pad (1) with 4 zeroes at the end * (2) * pad (3) with 2 zeroes

6720000 * 2652 * 284000 = 7006652

Write x = 10(n/2)a + b and y = 10(n/2)c + d

Where a, b, c, d are n/2 – digit numbers

[example a =56, b =78, c=12, d=34]

x*y = (10(n/2)a+b) (10(n/2)c+d)

Idea: recursively compute ac, ad, bc, bd, then compute (*) in the straightforward way

Step 1: Recursively compute ac

Step 2: Recursively compute bd

Step 3: Recursively compute (a+b) (cd) = ac + ad + bc + bd

Step 4: (3) – (1) – (2) = ad + bc

]]>

- Why Study Algorithms ? (4 min)
- Integer Multiplication (9 min)
- Karatsuba Multiplication (13 min)
- About the Course (17 min)
- Merge Sort: Motivation and Example (9 min)
- Merge Sort: Pseudocode (13 min)
- Merge Sort: Analysis (9 min)