- 
- 
- 
- 
- 
-
+ 
+ 
+ 
+ 
+
diff --git a/Regression Techniques/Bayesian_Regression.py b/Regression Techniques/Bayesian_Regression.py
new file mode 100644
index 0000000..09c97a2
--- /dev/null
+++ b/Regression Techniques/Bayesian_Regression.py
@@ -0,0 +1,106 @@
+#Import the necessary libraries
+import torch
+import pyro
+import pyro.distributions as dist
+from pyro.infer import SVI, Trace_ELBO, Predictive
+from pyro.optim import Adam
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+
+# Generate some sample data
+torch.manual_seed(0)
+X = torch.linspace(0, 10, 100)
+true_slope = 2
+true_intercept = 1
+Y = true_intercept + true_slope * X + torch.randn(100)
+
+# Define the Bayesian regression model
+def model(X, Y):
+ # Priors for the parameters
+ slope = pyro.sample("slope", dist.Normal(0, 10))
+ intercept = pyro.sample("intercept", dist.Normal(0, 10))
+ sigma = pyro.sample("sigma", dist.HalfNormal(1))
+
+ # Expected value of the outcome
+ mu = intercept + slope * X
+
+ # Likelihood (sampling distribution) of the observations
+ with pyro.plate("data", len(X)):
+ pyro.sample("obs", dist.Normal(mu, sigma), obs=Y)
+
+# Run Bayesian inference using SVI (Stochastic Variational Inference)
+def guide(X, Y):
+ # Approximate posterior distributions for the parameters
+ slope_loc = pyro.param("slope_loc", torch.tensor(0.0))
+ slope_scale = pyro.param("slope_scale", torch.tensor(1.0),
+ constraint=dist.constraints.positive)
+ intercept_loc = pyro.param("intercept_loc", torch.tensor(0.0))
+ intercept_scale = pyro.param("intercept_scale", torch.tensor(1.0),
+ constraint=dist.constraints.positive)
+ sigma_loc = pyro.param("sigma_loc", torch.tensor(1.0),
+ constraint=dist.constraints.positive)
+
+ # Sample from the approximate posterior distributions
+ slope = pyro.sample("slope", dist.Normal(slope_loc, slope_scale))
+ intercept = pyro.sample("intercept", dist.Normal(intercept_loc,
+ intercept_scale))
+ sigma = pyro.sample("sigma", dist.HalfNormal(sigma_loc))
+
+# Initialize the SVI and optimizer
+optim = Adam({"lr": 0.01})
+svi = SVI(model, guide, optim, loss=Trace_ELBO())
+
+# Run the inference loop
+num_iterations = 1000
+for i in range(num_iterations):
+ loss = svi.step(X, Y)
+ if (i + 1) % 100 == 0:
+ print(f"Iteration {i + 1}/{num_iterations} - Loss: {loss}")
+
+# Obtain posterior samples using Predictive
+predictive = Predictive(model, guide=guide, num_samples=1000)
+posterior = predictive(X, Y)
+
+# Extract the parameter samples
+slope_samples = posterior["slope"]
+intercept_samples = posterior["intercept"]
+sigma_samples = posterior["sigma"]
+
+# Compute the posterior means
+slope_mean = slope_samples.mean()
+intercept_mean = intercept_samples.mean()
+sigma_mean = sigma_samples.mean()
+
+# Print the estimated parameters
+print("Estimated Slope:", slope_mean.item())
+print("Estimated Intercept:", intercept_mean.item())
+print("Estimated Sigma:", sigma_mean.item())
+
+
+# Create subplots
+fig, axs = plt.subplots(1, 3, figsize=(15, 5))
+
+# Plot the posterior distribution of the slope
+sns.kdeplot(slope_samples, shade=True, ax=axs[0])
+axs[0].set_title("Posterior Distribution of Slope")
+axs[0].set_xlabel("Slope")
+axs[0].set_ylabel("Density")
+
+# Plot the posterior distribution of the intercept
+sns.kdeplot(intercept_samples, shade=True, ax=axs[1])
+axs[1].set_title("Posterior Distribution of Intercept")
+axs[1].set_xlabel("Intercept")
+axs[1].set_ylabel("Density")
+
+# Plot the posterior distribution of sigma
+sns.kdeplot(sigma_samples, shade=True, ax=axs[2])
+axs[2].set_title("Posterior Distribution of Sigma")
+axs[2].set_xlabel("Sigma")
+axs[2].set_ylabel("Density")
+
+# Adjust the layout
+plt.tight_layout()
+
+# Show the plot
+plt.show()
diff --git a/Regression Techniques/Isotonic_Regression.py b/Regression Techniques/Isotonic_Regression.py
new file mode 100644
index 0000000..b2fc215
--- /dev/null
+++ b/Regression Techniques/Isotonic_Regression.py
@@ -0,0 +1,23 @@
+from sklearn.isotonic import IsotonicRegression
+import matplotlib.pyplot as plt
+from matplotlib.collections import LineCollection
+
+ir = IsotonicRegression() # create an instance of the IsotonicRegression class
+
+# Fit isotonic regression model
+y_ir = ir.fit_transform(x, y) # fit the model and transform the data
+print('Isotonic Regression Predictions :\n',y_ir)
+
+# Create LineCollection for the isotonic regression line
+lines = [[[i, y_ir[i]] for i in range(n)]]
+
+# Line to measure the difference between actual and target value
+lc = LineCollection(lines)
+
+plt.plot(x, y_ir, '-', markersize=10, label='isotonic regression')
+
+plt.gca().add_collection(lc)
+plt.legend() # add a legend
+
+plt.title("Isotonic Regression")
+plt.show()
diff --git a/Regression Techniques/Lasso_Regression.py b/Regression Techniques/Lasso_Regression.py
new file mode 100644
index 0000000..7b9626b
--- /dev/null
+++ b/Regression Techniques/Lasso_Regression.py
@@ -0,0 +1,140 @@
+# Importing libraries
+
+import numpy as np
+
+import pandas as pd
+
+from sklearn.model_selection import train_test_split
+
+import matplotlib.pyplot as plt
+
+# Lasso Regression
+
+class LassoRegression() :
+
+ def __init__( self, learning_rate, iterations, l1_penality ) :
+
+ self.learning_rate = learning_rate
+
+ self.iterations = iterations
+
+ self.l1_penality = l1_penality
+
+ # Function for model training
+
+ def fit( self, X, Y ) :
+
+ # no_of_training_examples, no_of_features
+
+ self.m, self.n = X.shape
+
+ # weight initialization
+
+ self.W = np.zeros( self.n )
+
+ self.b = 0
+
+ self.X = X
+
+ self.Y = Y
+
+ # gradient descent learning
+
+ for i in range( self.iterations ) :
+
+ self.update_weights()
+
+ return self
+
+ # Helper function to update weights in gradient descent
+
+ def update_weights( self ) :
+
+ Y_pred = self.predict( self.X )
+
+ # calculate gradients
+
+ dW = np.zeros( self.n )
+
+ for j in range( self.n ) :
+
+ if self.W[j] > 0 :
+
+ dW[j] = ( - ( 2 * ( self.X[:, j] ).dot( self.Y - Y_pred ) )
+
+ + self.l1_penality ) / self.m
+
+ else :
+
+ dW[j] = ( - ( 2 * ( self.X[:, j] ).dot( self.Y - Y_pred ) )
+
+ - self.l1_penality ) / self.m
+
+
+ db = - 2 * np.sum( self.Y - Y_pred ) / self.m
+
+ # update weights
+
+ self.W = self.W - self.learning_rate * dW
+
+ self.b = self.b - self.learning_rate * db
+
+ return self
+
+ # Hypothetical function h( x )
+
+ def predict( self, X ) :
+
+ return X.dot( self.W ) + self.b
+
+
+def main() :
+
+ # Importing dataset
+
+ df = pd.read_csv( "salary_data.csv" )
+
+ X = df.iloc[:, :-1].values
+
+ Y = df.iloc[:, 1].values
+
+ # Splitting dataset into train and test set
+
+ X_train, X_test, Y_train, Y_test = train_test_split( X, Y, test_size = 1 / 3, random_state = 0 )
+
+ # Model training
+
+ model = LassoRegression( iterations = 1000, learning_rate = 0.01, l1_penality = 500 )
+
+ model.fit( X_train, Y_train )
+
+ # Prediction on test set
+
+ Y_pred = model.predict( X_test )
+
+ print( "Predicted values ", np.round( Y_pred[:3], 2 ) )
+
+ print( "Real values ", Y_test[:3] )
+
+ print( "Trained W ", round( model.W[0], 2 ) )
+
+ print( "Trained b ", round( model.b, 2 ) )
+
+ # Visualization on test set
+
+ plt.scatter( X_test, Y_test, color = 'blue' )
+
+ plt.plot( X_test, Y_pred, color = 'orange' )
+
+ plt.title( 'Salary vs Experience' )
+
+ plt.xlabel( 'Years of Experience' )
+
+ plt.ylabel( 'Salary' )
+
+ plt.show()
+
+
+if __name__ == "__main__" :
+
+ main()
diff --git a/Regression Techniques/Least_Angle_Regression.py b/Regression Techniques/Least_Angle_Regression.py
new file mode 100644
index 0000000..f5d3593
--- /dev/null
+++ b/Regression Techniques/Least_Angle_Regression.py
@@ -0,0 +1,25 @@
+# Importing modules that are required
+
+from sklearn.datasets import load_boston
+from sklearn.linear_model import LassoLars
+from sklearn.metrics import r2_score
+from sklearn.model_selection import train_test_split
+
+# Loading dataset
+dataset = load_boston()
+X = dataset.data
+y = dataset.target
+
+# Splitting training and testing data
+X_train, X_test, y_train, y_test = train_test_split(X, y,
+ test_size = 0.15, random_state = 42)
+
+# Creating and fitting the regressor
+regressor = LassoLars(alpha = 0.1)
+regressor.fit(X_train, y_train)
+
+
+# Evaluating model
+prediction = regressor.predict(X_test)
+
+print(f"r2 Score of test set : {r2_score(y_test, prediction)}")
diff --git a/Regression Techniques/Linear_Regression.py b/Regression Techniques/Linear_Regression.py
new file mode 100644
index 0000000..e2904fe
--- /dev/null
+++ b/Regression Techniques/Linear_Regression.py
@@ -0,0 +1,49 @@
+def mse(coef, x, y):
+ return np.mean((np.dot(x, coef) - y)**2)/2
+
+
+def gradients(coef, x, y):
+ return np.mean(x.transpose()*(np.dot(x, coef) - y), axis=1)
+
+
+def multilinear_regression(coef, x, y, lr, b1=0.9, b2=0.999, epsilon=1e-8):
+ prev_error = 0
+ m_coef = np.zeros(coef.shape)
+ v_coef = np.zeros(coef.shape)
+ moment_m_coef = np.zeros(coef.shape)
+ moment_v_coef = np.zeros(coef.shape)
+ t = 0
+
+ while True:
+ error = mse(coef, x, y)
+ if abs(error - prev_error) <= epsilon:
+ break
+ prev_error = error
+ grad = gradients(coef, x, y)
+ t += 1
+ m_coef = b1 * m_coef + (1-b1)*grad
+ v_coef = b2 * v_coef + (1-b2)*grad**2
+ moment_m_coef = m_coef / (1-b1**t)
+ moment_v_coef = v_coef / (1-b2**t)
+
+ delta = ((lr / moment_v_coef**0.5 + 1e-8) *
+ (b1 * moment_m_coef + (1-b1)*grad/(1-b1**t)))
+
+ coef = np.subtract(coef, delta)
+ return coef
+
+
+coef = np.array([0, 0, 0])
+c = multilinear_regression(coef, x, y, 1e-1)
+fig = plt.figure()
+ax = fig.add_subplot(projection='3d')
+
+ax.scatter(x[:, 1], x[:, 2], y, label='y',
+ s=5, color="dodgerblue")
+
+ax.scatter(x[:, 1], x[:, 2], c[0] + c[1]*x[:, 1] + c[2]*x[:, 2],
+ label='regression', s=5, color="orange")
+
+ax.view_init(45, 0)
+ax.legend()
+plt.show()
diff --git a/Regression Techniques/Logistic_Regression.py b/Regression Techniques/Logistic_Regression.py
new file mode 100644
index 0000000..807d40a
--- /dev/null
+++ b/Regression Techniques/Logistic_Regression.py
@@ -0,0 +1,20 @@
+# import the necessary libraries
+from sklearn.datasets import load_breast_cancer
+from sklearn.linear_model import LogisticRegression
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+# load the breast cancer dataset
+X, y = load_breast_cancer(return_X_y=True)
+# split the train and test dataset
+X_train, X_test,\
+ y_train, y_test = train_test_split(X, y,
+ test_size=0.20,
+ random_state=23)
+# LogisticRegression
+clf = LogisticRegression(random_state=0)
+clf.fit(X_train, y_train)
+# Prediction
+y_pred = clf.predict(X_test)
+
+acc = accuracy_score(y_test, y_pred)
+print("Logistic Regression model accuracy (in %):", acc*100)
diff --git a/Regression Techniques/Polynomial_Regression.py b/Regression Techniques/Polynomial_Regression.py
new file mode 100644
index 0000000..d56f243
--- /dev/null
+++ b/Regression Techniques/Polynomial_Regression.py
@@ -0,0 +1,137 @@
+# Importing libraries
+
+import numpy as np
+
+import math
+
+import matplotlib.pyplot as plt
+
+# Univariate Polynomial Regression
+
+class PolynomailRegression() :
+
+ def __init__( self, degree, learning_rate, iterations ) :
+
+ self.degree = degree
+
+ self.learning_rate = learning_rate
+
+ self.iterations = iterations
+
+ # function to transform X
+
+ def transform( self, X ) :
+
+ # initialize X_transform
+
+ X_transform = np.ones( ( self.m, 1 ) )
+
+ j = 0
+
+ for j in range( self.degree + 1 ) :
+
+ if j != 0 :
+
+ x_pow = np.power( X, j )
+
+ # append x_pow to X_transform
+
+ X_transform = np.append( X_transform, x_pow.reshape( -1, 1 ), axis = 1 )
+
+ return X_transform
+
+ # function to normalize X_transform
+
+ def normalize( self, X ) :
+
+ X[:, 1:] = ( X[:, 1:] - np.mean( X[:, 1:], axis = 0 ) ) / np.std( X[:, 1:], axis = 0 )
+
+ return X
+
+ # model training
+
+ def fit( self, X, Y ) :
+
+ self.X = X
+
+ self.Y = Y
+
+ self.m, self.n = self.X.shape
+
+ # weight initialization
+
+ self.W = np.zeros( self.degree + 1 )
+
+ # transform X for polynomial h( x ) = w0 * x^0 + w1 * x^1 + w2 * x^2 + ........+ wn * x^n
+
+ X_transform = self.transform( self.X )
+
+ # normalize X_transform
+
+ X_normalize = self.normalize( X_transform )
+
+ # gradient descent learning
+
+ for i in range( self.iterations ) :
+
+ h = self.predict( self.X )
+
+ error = h - self.Y
+
+ # update weights
+
+ self.W = self.W - self.learning_rate * ( 1 / self.m ) * np.dot( X_normalize.T, error )
+
+ return self
+
+ # predict
+
+ def predict( self, X ) :
+
+ # transform X for polynomial h( x ) = w0 * x^0 + w1 * x^1 + w2 * x^2 + ........+ wn * x^n
+
+ X_transform = self.transform( X )
+
+ X_normalize = self.normalize( X_transform )
+
+ return np.dot( X_transform, self.W )
+
+
+# Driver code
+
+def main() :
+
+ # Create dataset
+
+ X = np.array( [ [1], [2], [3], [4], [5], [6], [7] ] )
+
+ Y = np.array( [ 45000, 50000, 60000, 80000, 110000, 150000, 200000 ] )
+
+ # model training
+
+ model = PolynomailRegression( degree = 2, learning_rate = 0.01, iterations = 500 )
+
+ model.fit( X, Y )
+
+ # Prediction on training set
+
+ Y_pred = model.predict( X )
+
+ # Visualization
+
+ plt.scatter( X, Y, color = 'blue' )
+
+ plt.plot( X, Y_pred, color = 'orange' )
+
+ plt.title( 'X vs Y' )
+
+ plt.xlabel( 'X' )
+
+ plt.ylabel( 'Y' )
+
+ plt.show()
+
+
+if __name__ == "__main__" :
+
+ main()
diff --git a/Regression Techniques/Quantile_Regression.py b/Regression Techniques/Quantile_Regression.py
new file mode 100644
index 0000000..7429810
--- /dev/null
+++ b/Regression Techniques/Quantile_Regression.py
@@ -0,0 +1,47 @@
+# Python program to visualize quantile regression
+
+# Importing libraries
+import numpy as np
+import pandas as pd
+import statsmodels.api as sm
+import statsmodels.formula.api as smf
+import matplotlib.pyplot as plt
+
+np.random.seed(0)
+
+# Number of rows
+rows = 20
+
+# Constructing Distance column
+Distance = np.random.uniform(1, 10, rows)
+
+# Constructing Emission column
+Emission = 40 + Distance + np.random.normal(loc=0,
+ scale=.25*Distance,
+ size=20)
+
+# Creating a dataset
+df = pd.DataFrame({'Distance': Distance,
+ 'Emission': Emission})
+
+# #fit the model
+model = smf.quantreg('Emission ~ Distance',
+ df).fit(q=0.7)
+
+# define figure and axis
+fig, ax = plt.subplots(figsize=(10, 8))
+
+# get y values
+y_line = lambda a, b: a + Distance
+y = y_line(model.params['Intercept'],
+ model.params['Distance'])
+
+# Plotting data points with the help
+# pf quantile regression equation
+ax.plot(Distance, y, color='black')
+ax.scatter(Distance, Emission, alpha=.3)
+ax.set_xlabel('Distance Traveled', fontsize=20)
+ax.set_ylabel('Emission Generated', fontsize=20)
+
+# Save the plot
+fig.savefig('quantile_regression.png')
diff --git a/Regression Techniques/Ridge_Regression.py b/Regression Techniques/Ridge_Regression.py
new file mode 100644
index 0000000..4f3df50
--- /dev/null
+++ b/Regression Techniques/Ridge_Regression.py
@@ -0,0 +1,91 @@
+# Importing libraries
+
+import numpy as np
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import matplotlib.pyplot as plt
+
+# Ridge Regression
+
+class RidgeRegression() :
+
+ def __init__( self, learning_rate, iterations, l2_penality ) :
+
+ self.learning_rate = learning_rate
+ self.iterations = iterations
+ self.l2_penality = l2_penality
+
+ # Function for model training
+ def fit( self, X, Y ) :
+
+ # no_of_training_examples, no_of_features
+ self.m, self.n = X.shape
+
+ # weight initialization
+ self.W = np.zeros( self.n )
+
+ self.b = 0
+ self.X = X
+ self.Y = Y
+
+ # gradient descent learning
+
+ for i in range( self.iterations ) :
+ self.update_weights()
+ return self
+
+ # Helper function to update weights in gradient descent
+
+ def update_weights( self ) :
+ Y_pred = self.predict( self.X )
+
+ # calculate gradients
+ dW = ( - ( 2 * ( self.X.T ).dot( self.Y - Y_pred ) ) +
+ ( 2 * self.l2_penality * self.W ) ) / self.m
+ db = - 2 * np.sum( self.Y - Y_pred ) / self.m
+
+ # update weights
+ self.W = self.W - self.learning_rate * dW
+ self.b = self.b - self.learning_rate * db
+ return self
+
+ # Hypothetical function h( x )
+ def predict( self, X ) :
+ return X.dot( self.W ) + self.b
+
+# Driver code
+
+def main() :
+
+ # Importing dataset
+ df = pd.read_csv( "salary_data.csv" )
+ X = df.iloc[:, :-1].values
+ Y = df.iloc[:, 1].values
+
+ # Splitting dataset into train and test set
+ X_train, X_test, Y_train, Y_test = train_test_split( X, Y,
+
+ test_size = 1 / 3, random_state = 0 )
+
+ # Model training
+ model = RidgeRegression( iterations = 1000,
+ learning_rate = 0.01, l2_penality = 1 )
+ model.fit( X_train, Y_train )
+
+ # Prediction on test set
+ Y_pred = model.predict( X_test )
+ print( "Predicted values ", np.round( Y_pred[:3], 2 ) )
+ print( "Real values ", Y_test[:3] )
+ print( "Trained W ", round( model.W[0], 2 ) )
+ print( "Trained b ", round( model.b, 2 ) )
+
+ # Visualization on test set
+ plt.scatter( X_test, Y_test, color = 'blue' )
+ plt.plot( X_test, Y_pred, color = 'orange' )
+ plt.title( 'Salary vs Experience' )
+ plt.xlabel( 'Years of Experience' )
+ plt.ylabel( 'Salary' )
+ plt.show()
+
+if __name__ == "__main__" :
+ main()
diff --git a/Regression Techniques/Simple_Linear_Regression.py b/Regression Techniques/Simple_Linear_Regression.py
new file mode 100644
index 0000000..0f6da43
--- /dev/null
+++ b/Regression Techniques/Simple_Linear_Regression.py
@@ -0,0 +1,54 @@
+import numpy as np
+import matplotlib.pyplot as plt
+
+def estimate_coef(x, y):
+ # number of observations/points
+ n = np.size(x)
+
+ # mean of x and y vector
+ m_x = np.mean(x)
+ m_y = np.mean(y)
+
+ # calculating cross-deviation and deviation about x
+ SS_xy = np.sum(y*x) - n*m_y*m_x
+ SS_xx = np.sum(x*x) - n*m_x*m_x
+
+ # calculating regression coefficients
+ b_1 = SS_xy / SS_xx
+ b_0 = m_y - b_1*m_x
+
+ return (b_0, b_1)
+
+def plot_regression_line(x, y, b):
+ # plotting the actual points as scatter plot
+ plt.scatter(x, y, color = "m",
+ marker = "o", s = 30)
+
+ # predicted response vector
+ y_pred = b[0] + b[1]*x
+
+ # plotting the regression line
+ plt.plot(x, y_pred, color = "g")
+
+ # putting labels
+ plt.xlabel('x')
+ plt.ylabel('y')
+
+ # function to show plot
+ plt.show()
+
+def main():
+ # observations / data
+ x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+ y = np.array([1, 3, 2, 5, 7, 8, 8, 9, 10, 12])
+
+ # estimating coefficients
+ b = estimate_coef(x, y)
+ print("Estimated coefficients:\nb_0 = {} \
+ \nb_1 = {}".format(b[0], b[1]))
+
+ # plotting regression line
+ plot_regression_line(x, y, b)
+
+if __name__ == "__main__":
+ main()
diff --git a/Regression Techniques/Stepwise_Regression.py b/Regression Techniques/Stepwise_Regression.py
new file mode 100644
index 0000000..3c91866
--- /dev/null
+++ b/Regression Techniques/Stepwise_Regression.py
@@ -0,0 +1,48 @@
+import pandas as pd
+import numpy as np
+from sklearn import linear_model
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+from mlxtend.feature_selection import SequentialFeatureSelector
+
+# Define the array of data
+data = np.array([[1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12]])
+
+# Convert the array into a dataframe
+df = pd.DataFrame(data)
+
+# Select the features and target
+X = df.iloc[:, :-1]
+y = df.iloc[:, -1]
+
+# Perform stepwise regression
+sfs = SequentialFeatureSelector(linear_model.LogisticRegression(),
+ k_features=3,
+ forward=True,
+ scoring='accuracy',
+ cv=None)
+selected_features = sfs.fit(X, y)
+
+# Create a dataframe with only the selected features
+selected_columns = [0, 1, 2, 3]
+df_selected = df[selected_columns]
+
+# Split the data into train and test sets
+X_train, X_test,\
+ y_train, y_test = train_test_split(
+ df_selected, y,
+ test_size=0.3,
+ random_state=42)
+
+# Fit a logistic regression model using the selected features
+logreg = linear_model.LogisticRegression()
+logreg.fit(X_train, y_train)
+
+# Make predictions using the test set
+y_pred = logreg.predict(X_test)
+
+# Evaluate the model performance
+print(y_pred)
+
diff --git a/Searching Techniques/Boyer_Moore_Algorithm.py b/Searching Techniques/Boyer_Moore_Algorithm.py
new file mode 100644
index 0000000..1b2df13
--- /dev/null
+++ b/Searching Techniques/Boyer_Moore_Algorithm.py
@@ -0,0 +1,74 @@
+"""Program for Bad Character Heuristic
+of Boyer Moore String Matching Algorithm"""
+
+
+NO_OF_CHARS = 256
+
+def badCharHeuristic(string, size):
+ '''
+ The preprocessing function for
+ Boyer Moore's bad character heuristic
+ '''
+ # Initialize all occurrences as -1
+ badChar = [-1] * NO_OF_CHARS
+
+ # Fill the actual value of the last occurrence
+ for i in range(size):
+ badChar[ord(string[i])] = i
+
+ # Return the initialized list
+ return badChar
+
+def search(txt, pat):
+ '''
+ A pattern searching function that uses the Bad Character
+ Heuristic of the Boyer Moore Algorithm
+ '''
+ m = len(pat)
+ n = len(txt)
+
+ # Create the bad character list by calling
+ # the preprocessing function badCharHeuristic()
+ # for the given pattern
+ badChar = badCharHeuristic(pat, m)
+
+ # s is the shift of the pattern with respect to the text
+ s = 0
+ while s <= n - m:
+ j = m - 1
+
+ # Keep reducing index j of the pattern while
+ # characters of the pattern and text are matching
+ # at this shift s
+ while j >= 0 and pat[j] == txt[s + j]:
+ j -= 1
+
+ # If the pattern is present at the current shift,
+ # then index j will become -1 after the above loop
+ if j < 0:
+ print("Pattern occurs at shift =", s)
+
+ '''
+ Shift the pattern so that the next character in the text
+ aligns with the last occurrence of it in the pattern.
+ The condition s+m < n is necessary for the case when
+ the pattern occurs at the end of the text
+ '''
+ s += (m - badChar[ord(txt[s + m])] if s + m < n else 1)
+ else:
+ '''
+ Shift the pattern so that the bad character in the text
+ aligns with the last occurrence of it in the pattern. The
+ max function is used to make sure that we get a positive
+ shift. We may get a negative shift if the last occurrence
+ of the bad character in the pattern is on the right side of the
+ current character.
+ '''
+ s += max(1, j - badChar[ord(txt[s + j])])
+
+while True:
+ txt = input('Enter the text (or press Enter to exit): ')
+ if not txt:
+ break
+ pat = input('Enter the pattern to search for: ')
+ search(txt, pat)
diff --git a/Searching Techniques/Naive_Pattern_Searching.py b/Searching Techniques/Naive_Pattern_Searching.py
new file mode 100644
index 0000000..cc955c3
--- /dev/null
+++ b/Searching Techniques/Naive_Pattern_Searching.py
@@ -0,0 +1,39 @@
+# Python3 program for Naive Pattern
+# Searching algorithm
+
+
+def search(pat, txt):
+ M = len(pat)
+ N = len(txt)
+
+ # A loop to slide pat[] one by one */
+ for i in range(N - M + 1):
+ j = 0
+
+ # For current index i, check
+ # for pattern match */
+ while(j < M):
+ if (txt[i + j] != pat[j]):
+ break
+ j += 1
+
+ if (j == M):
+ print("Pattern found at index ", i)
+
+
+# Driver's Code
+if __name__ == '__main__':
+ txt = "AABAACAADAABAAABAA"
+ pat = "AABA"
+
+ # Function call
+ print('Below iis an` example of Naive Pattern Searching Algorithm\n')
+ print('It is being implemented for the following text and pattern: \n')
+ print(' Text = "AABAACAADAABAAABAA" pattern = "AABA"')
+
+ search(pat, txt)
+ #try it yourself
+ print('\nNow try it yourself\n')
+ txt = input("Enter the text: ")
+ pat = input("Enter the pattern: ")
+ search(pat, txt)
\ No newline at end of file
diff --git a/Sorting Techniques/Tim_Sort.py b/Sorting Techniques/Tim_Sort.py
new file mode 100644
index 0000000..f66b307
--- /dev/null
+++ b/Sorting Techniques/Tim_Sort.py
@@ -0,0 +1,110 @@
+# Python : Timsort algorithm
+####################################################################################################################
+# TimSort is a hybrid sorting algorithm that combines the strengths of merge sort and insertion sort.
+# It is designed to efficiently sort a wide range of real-world data types. It maintains the relative order of equal elements in the sorted output.
+# Divide into Runs: TimSort starts by dividing the input array into small, already sorted subsequences called "runs."
+# Merge Runs: It then merges these runs together using a combination of merge sort and insertion sort. This merging process optimizes performance, especially for data with pre-existing order.
+####################################################################################################################
+
+
+MIN_MERGE = 32
+
+
+def calcMinRun(n):
+ """Returns the minimum length of a run from 23 - 64 so that
+ the len(array)/minrun is less than or equal to a power of 2.
+
+ e.g. 1=>1, ..., 63=>63, 64=>32, 65=>33,
+ ..., 127=>64, 128=>32, ...
+ """
+ r = 0
+ while n >= MIN_MERGE:
+ r |= n & 1
+ n >>= 1
+ return n + r
+
+
+# This function sorts array from left index to
+# to right index which is of size atmost RUN
+def insertionSort(arr, left, right):
+ for i in range(left + 1, right + 1):
+ j = i
+ while j > left and arr[j] < arr[j - 1]:
+ arr[j], arr[j - 1] = arr[j - 1], arr[j]
+ j -= 1
+
+
+# Merge function merges the sorted runs
+def merge(arr, l, m, r):
+
+ # original array is broken in two parts
+ # left and right array
+ len1, len2 = m - l + 1, r - m
+ left, right = [], []
+ for i in range(0, len1):
+ left.append(arr[l + i])
+ for i in range(0, len2):
+ right.append(arr[m + 1 + i])
+
+ i, j, k = 0, 0, l
+
+ # after comparing, we merge those two array
+ # in larger sub array
+ while i < len1 and j < len2:
+ if left[i] <= right[j]:
+ arr[k] = left[i]
+ i += 1
+
+ else:
+ arr[k] = right[j]
+ j += 1
+
+ k += 1
+
+ # Copy remaining elements of left, if any
+ while i < len1:
+ arr[k] = left[i]
+ k += 1
+ i += 1
+
+ # Copy remaining element of right, if any
+ while j < len2:
+ arr[k] = right[j]
+ k += 1
+ j += 1
+
+
+# Iterative Timsort function to sort the
+# array[0...n-1] (similar to merge sort)
+def timSort(arr):
+ n = len(arr)
+ minRun = calcMinRun(n)
+
+ # Sort individual subarrays of size RUN
+ for start in range(0, n, minRun):
+ end = min(start + minRun - 1, n - 1)
+ insertionSort(arr, start, end)
+
+ # Start merging from size RUN (or 32). It will merge
+ # to form size 64, then 128, 256 and so on ....
+ size = minRun
+ while size < n:
+
+ # Pick starting point of left sub array. We
+ # are going to merge arr[left..left+size-1]
+ # and arr[left+size, left+2*size-1]
+ # After every merge, we increase left by 2*size
+ for left in range(0, n, 2 * size):
+
+ # Find ending point of left sub array
+ # mid+1 is starting point of right sub array
+ mid = min(n - 1, left + size - 1)
+ right = min((left + 2 * size - 1), (n - 1))
+
+ # Merge sub array arr[left.....mid] &
+ # arr[mid+1....right]
+ if mid < right:
+ merge(arr, left, mid, right)
+
+ size = 2 * size
+
diff --git a/Tree/AVL_tree.py b/Tree/AVL_tree.py
new file mode 100644
index 0000000..b4a8ed8
--- /dev/null
+++ b/Tree/AVL_tree.py
@@ -0,0 +1,146 @@
+class TreeNode:
+ def __init__(self, key):
+ self.key = key
+ self.left = None
+ self.right = None
+ self.height = 1
+
+
+class AVLTree:
+ def insert(self, root, key):
+ if not root:
+ return TreeNode(key)
+ if key < root.key:
+ root.left = self.insert(root.left, key)
+ else:
+ root.right = self.insert(root.right, key)
+ root.height = 1 + max(self.get_height(root.left), self.get_height(root.right))
+ return self.balance(root)
+
+ def delete(self, root, key):
+ if not root:
+ return root
+ if key < root.key:
+ root.left = self.delete(root.left, key)
+ elif key > root.key:
+ root.right = self.delete(root.right, key)
+ else:
+ if not root.left:
+ temp = root.right
+ root = None
+ return temp
+ elif not root.right:
+ temp = root.left
+ root = None
+ return temp
+ temp = self.get_min_value_node(root.right)
+ root.key = temp.key
+ root.right = self.delete(root.right, temp.key)
+ root.height = 1 + max(self.get_height(root.left), self.get_height(root.right))
+ return self.balance(root)
+
+ def get_height(self, node):
+ if not node:
+ return 0
+ return node.height
+
+ def get_balance(self, node):
+ if not node:
+ return 0
+ return self.get_height(node.left) - self.get_height(node.right)
+
+ def balance(self, node):
+ if not node:
+ return node
+ balance = self.get_balance(node)
+ if balance > 1:
+ if self.get_balance(node.left) < 0:
+ node.left = self.left_rotate(node.left)
+ return self.right_rotate(node)
+ if balance < -1:
+ if self.get_balance(node.right) > 0:
+ node.right = self.right_rotate(node.right)
+ return self.left_rotate(node)
+ return node
+
+ def left_rotate(self, z):
+ y = z.right
+ T2 = y.left
+ y.left = z
+ z.right = T2
+ z.height = 1 + max(self.get_height(z.left), self.get_height(z.right))
+ y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))
+ return y
+
+ def right_rotate(self, y):
+ x = y.left
+ T2 = x.right
+ x.right = y
+ y.left = T2
+ y.height = 1 + max(self.get_height(y.left), self.get_height(y.right))
+ x.height = 1 + max(self.get_height(x.left), self.get_height(x.right))
+ return x
+
+ def get_min_value_node(self, node):
+ if node is None or node.left is None:
+ return node
+ return self.get_min_value_node(node.left)
+
+ def inorder_traversal(self, root):
+ if root:
+ self.inorder_traversal(root.left)
+ print(root.key, end=" ")
+ self.inorder_traversal(root.right)
+
+# Example usage:
+if __name__ == "__main__":
+ avl_tree = AVLTree()
+ root = None
+ keys = [9, 5, 10, 0, 6, 11, -1, 1, 2]
+ for key in keys:
+ root = avl_tree.insert(root, key)
+
+ print("Inorder Traversal of AVL tree:")
+ avl_tree.inorder_traversal(root)
+
+ key_to_delete = 10
+ root = avl_tree.delete(root, key_to_delete)
+ print("\nAfter deleting", key_to_delete)
+ avl_tree.inorder_traversal(root)
+
+class AVLTreeMenu:
+ def __init__(self):
+ self.avl_tree = AVLTree()
+ self.root = None
+
+ def display_menu(self):
+ print("AVL Tree Menu:")
+ print("1. Insert a key")
+ print("2. Delete a key")
+ print("3. Display the AVL tree")
+ print("4. Exit")
+
+ def run(self):
+ while True:
+ self.display_menu()
+ choice = input("Enter your choice: ")
+ if choice == "1":
+ key = int(input("Enter the key to insert: "))
+ self.root = self.avl_tree.insert(self.root, key)
+ print(f"Key {key} inserted.")
+ elif choice == "2":
+ key = int(input("Enter the key to delete: "))
+ self.root = self.avl_tree.delete(self.root, key)
+ print(f"Key {key} deleted.")
+ elif choice == "3":
+ print("Inorder Traversal of AVL tree:")
+ self.avl_tree.inorder_traversal(self.root)
+ elif choice == "4":
+ print("Exiting the AVL Tree Menu.")
+ break
+ else:
+ print("Invalid choice. Please enter a valid option.")
+
+if __name__ == "__main__":
+ avl_tree_menu = AVLTreeMenu()
+ avl_tree_menu.run()
diff --git a/Trie/Menu_Driven_Code_for_Tries.py b/Tree/Menu_Driven_Code_for_Tries.py
similarity index 100%
rename from Trie/Menu_Driven_Code_for_Tries.py
rename to Tree/Menu_Driven_Code_for_Tries.py
diff --git a/Tree/Morris_Traversal.py b/Tree/Morris_Traversal.py
new file mode 100644
index 0000000..46d3c91
--- /dev/null
+++ b/Tree/Morris_Traversal.py
@@ -0,0 +1,70 @@
+# Morris Traversal
+# Time Complexity = O(n)
+# Space Complexity = O(1) (Main advantage of using this traversal. Uses only constant space)
+# 1
+# / \
+# / \
+# 2 3
+# / \
+# / \
+# 4 5
+# \
+# \
+# 6
+#
+# Output --> 4 2 5 6 1 3
+
+class TreeNode:
+ def __init__(self, val=0, left=None, right=None):
+ self.val = val
+ self.left = left
+ self.right = right
+
+# Morris-inorder traversal
+def Morris_Traversal(root):
+ morris = []
+ cur = root
+
+ while cur:
+ if cur.left is None:
+ morris.append(cur.val)
+ cur = cur.right
+ else:
+ temp = cur.left
+ while temp.right and temp.right != cur:
+ temp = temp.right
+
+ if temp.right is None:
+ temp.right = cur
+ cur = cur.left
+ else:
+ temp.right = None
+ morris.append(cur.val)
+ cur = cur.right
+
+ return morris
+
+if __name__ == '__main__':
+ print("\033c", end='', flush=True)
+ # Input tree elements
+ root_val = int(input("Enter the value for the root: "))
+ root = TreeNode(root_val)
+
+ print('\n')
+ queue = [root]
+ while queue:
+ current = queue.pop(0)
+ left_val = int(input(f"Enter the value for the left child of {current.val} (Enter -1 for no child): "))
+ if left_val != -1:
+ current.left = TreeNode(left_val)
+ queue.append(current.left)
+ right_val = int(input(f"Enter the value for the right child of {current.val} (Enter -1 for no child): "))
+ if right_val != -1:
+ current.right = TreeNode(right_val)
+ queue.append(current.right)
+ print('\n')
+
+ # Morris Traversal starts
+ morris = Morris_Traversal(root)
+ print(' '.join([str(i) for i in morris]))
+