Question

Problem 4: (7 pts)

To understand the value of recursion in a programming language, write a Program in C++ or Python that implements quicksort, first using recursion and then without recursion. Submit your program source code and  screenshot(s) of the output in a separate file (pdf or .docx)

Problem 5: (7 pts)

To understand the value of counting loops, write a program in C++ or Python that implements matrix multiplication using counting loop constructs. Let the user input the size/dimensions of the matrix. Then write the same program using only logical loops—for example, while loops. Submit your program source code and a screenshot of the output in a separate file (pdf or .docx)

Answer 1

--> Quick Sort in Python using recursion

#####################################################################################

# Partition Function
def quickPartition(ar,st,nd):
i = st-1         
my_pivot = ar[nd]   # initializing pivot
for j in range(st,nd):
if ar[j] < my_pivot:
i = i+1
ar[i],ar[j] = ar[j],ar[i]
ar[i+1],ar[nd] = ar[nd],ar[i+1]
return i+1

# main Sorting Function
def quickSort(ar,st,nd):
if st<nd:
my_pi = quickPartition(ar,st,nd)
quickSort(ar, st, my_pi-1)
quickSort(ar, my_pi+1, nd)

ar=list(map(int,input().split()))
n = len(ar)
print ("Initial array is:")
for i in range(n):
print (ar[i],end=' ')
quickSort(ar,0,n-1)
print ("\nSorted array is:")
for i in range(n):
print (ar[i],end=' ')

#######################################################################

Input & Output:

--------------------------------------------------------------------------------------------------------------------

--> Quick Sort in Python using Itertative

###############################################################################

# Partition Function
def quickPartition(ar,st,nd):
i = st-1
x = ar[nd] # initializing pivot
for j in range(st,nd):
if ar[j] <= x:
i = i+1
ar[i],ar[j] = ar[j],ar[i]
ar[i+1],ar[nd] = ar[nd],ar[i+1]
return i+1

def MyIterativeQuickSort(ar,st,nd):
# using Stack
stack_size = nd-st + 1
mystack = [0] * (stack_size) # declaring stack with 0
stack_top = -1 # initializing top=-1

stack_top = stack_top + 1
mystack[stack_top] = st # adding st to stack
stack_top = stack_top + 1
mystack[stack_top] = nd # adding nd to stack
  
while stack_top >= 0: # while stack is not empty
nd = mystack[stack_top] # popping nd
stack_top = stack_top - 1
st = mystack[stack_top] # popping st
stack_top = stack_top-1
p = quickPartition(ar,st,nd ) # setting pivot
if p-1 > st: # if pivot is greater than st
stack_top = stack_top + 1
mystack[stack_top] = st
stack_top = stack_top + 1
mystack[stack_top] = p - 1
if p+1 < nd: # if pivot is less than nd
stack_top = stack_top + 1
mystack[stack_top] = p + 1
stack_top = stack_top + 1
mystack[stack_top] = nd

ar=list(map(int,input().split()))
n = len(ar)
print ("Initial array is:")
for i in range(n):
print (ar[i],end=' ')
MyIterativeQuickSort(ar,0,n-1)
print ("\nSorted array is:")
for i in range(n):
print (ar[i],end=' ')

##############################################################################

Input & Output:

----> Matrix Multiplication using counting loop

###############################################################################

n1,m1=map(int,input("Enter The size of first matrix : n m : ").split())
X=[]
for i in range(n1):
temp=list(map(int,input().split()))
X.append(temp)

n2,m2=map(int,input("Enter The size of second matrix : n m : ").split())
Y=[]
for i in range(n2):
temp=list(map(int,input().split()))
Y.append(temp)

result=[]
for i in range(m1):
temp=[]
for j in range(n2):
temp.append(0)
result.append(temp)

# iterate through rows of X
for i in range(n1):
# iterate through columns of Y
for j in range(n2):
# iterate through rows of Y
for k in range(m1):
result[i][j] += X[i][k] * Y[k][j]
for r in result:
print(r)

################################################################################

Output & Input:

*** If you have any doubt regarding the solution, Please do ask in the comments ***