Question

The Task:

Create a console application that prompts the user to select either a stack, queue, linked list, or binary search tree. Then prompt the user for a number that will then be passed to a recursive function that will populate an array in ascending order. If user selected binary search tree, they will then be prompted to choose how the data will be received either in-order, preorder, or post-order. If user selected linked list, they will then be prompted to choose if the data will be printed in ascending or descending order. The program will then use the array to create the chosen storage type and then print out the results to the console. (C#)

C#

What You Need to Do:

Implement the code so that the output produced follows as below:

I have included a few examples:

Example 1:

What type of storage would you like to use?

Linked list

What’s the maximum numbers?

17

How would you like the data returned?

Ascending

Here’s your returned number list:

1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17

Example 2:

What type of storage would you like to use?
Stack

What’s the maximum numbers?
9

Here’s your returned number list:

9 8 7 6 5 4 3 2 1

Example 3:

What type of storage would you like to use?
BST

What’s the maximum numbers?
12

How would you like the data returned?
Pre-order

Here’s your returned number list:
1 2 4 8 9 5 10 11 3 6 12 7

Answer 1

//////////////////////// project name is type4

////////////////////////////////////////////////////////////////

class Node
{
private int data;
private Node left;
private Node right;

public Node() {
this.data = 0;
this.left = null;
this.right = null;
}

public Node(int d)
{
this.data = d;
this.left = null;
this.right = null;
}

public void setdata(int a) { this.data = a; }
public void setLeft(Node n) { this.left = n; }
public void setRight(Node n) { this.right = n; }

public int getdata() { return data; }
public Node getLeft() { return left; }
public Node getRight() { return right; }

}

///////////////////////////////////////////////////////////////

class BST
{
private Node root;
private int size;

public BST()
{
this.root =null;
this.size = 0;
}

public void addData(int data)
{
Node node = new Node(data);
if (this.root == null) {
this.root = node;
}
else {
Node ur = this.root;

while (ur != null)
{
if (ur.getdata() > data)
{
if (ur.getLeft() == null)
{
ur.setLeft(node);
break;
}
else
{
ur = ur.getLeft();
}
}
else
{
if (ur.getRight() == null)
{
ur.setRight(node);
break;
}
else
{
ur = ur.getRight();
}
}
}
}
this.size++;
}

public void inorder() { this.inorder(root); }
public void preorder() { this.preorder(root); }
public void postorder() { this.postorder(root); }

public int getSize()
{
return this.size;
}

public void inorder(Node node) {
if (node == null)
{
return;
}
else
{
inorder(node.getLeft());
Console.Write(node.getdata()+" ");
inorder(node.getRight());
}
}
public void preorder(Node node) {
if (node == null)
{
return;
}
else
{

Console.Write(node.getdata() + " ");
inorder(node.getLeft());
inorder(node.getRight());
}
}
public void postorder(Node node) {
if (node == null)
{
return;
}
else
{
inorder(node.getLeft());
inorder(node.getRight());
Console.Write(node.getdata() + " ");
}
}
}

///////////////////////////////////////////////////////////////

class Queue
{
private int[] data;
private int size;
private int index;
private int indexf;

public Queue(int s)
{
this.data = new int[s];
this.size = s;
this.index = 0;
this.indexf = 0;
}

public void push(int d)
{
if (this.index < this.size )
{
this.data[index] = d;
this.index++;
}
}

public int top()
{
return this.data[indexf];
}

public int pop()
{
indexf++; ;
return this.data[indexf-1];
}

public int getSize()
{
return (this.index-this.indexf);
}

public void printData()
{
while (this.getSize() != 0)
{
int data_ = this.pop();
Console.Write(data_ + " ");
}
}

}

/////////////////////////////////////////////////////////////

class Stack
{
private int[] data;
private int size;
private int index;

public Stack(int s)
{
this.data = new int[s];
this.size = s;
this.index = 0;
}

public void push(int d)
{
if (this.index < this.size )
{
this.data[index] = d;
this.index++;
}
}

public int top()
{
return this.data[index-1];
}

public int pop()
{
index--;
return this.data[index];
}

public int getSize()
{
return this.index;
}

public void printData()
{
while (this.getSize() !=0)
{
int data_ = this.pop();
Console.Write(data_ + " ");
}
}

}

////////////////////////////////////////////////////////////

class LinkedList
{
class Node
{
private int data;
private Node next;

public Node(int d)
{
this.data = d;
this.next = null;
}

public void setData(int d) { this.data = d; }
public void setNext(Node n) { this.next = n; }

public int getData() { return data; }
public Node getNext() { return next; }
}

private Node root;

public LinkedList()
{
this.root = null;
}

public void addData(int s)
{
Node node = new Node(s);
if (root == null)
{
this.root = node;
}
else
{
node.setNext(this.root); ;
this.root = node;
}
}

public int getSize()
{
int size = 0;
Node cur = root;
while (cur!=null)
{
size++;
cur = cur.getNext();
}
return size;
}

public void printAcending() {
int[] dataLst = new int[this.getSize()];
int i = 0;
Node cur = this.root;

while (cur != null)
{
dataLst[i++] = cur.getData();
cur = cur.getNext();
}

Array.Sort(dataLst);

for(i = 0; i < dataLst.Length; i++)
{
Console.Write(dataLst[i]+" ");
if (i < dataLst.Length - 1)
{
Console.Write(",");
}
}

}
public void printDecending() {
int[] dataLst = new int[this.getSize()];
int i = 0;
Node cur = this.root;

while (cur != null)
{
dataLst[i++] = cur.getData();
cur = cur.getNext();
}

Array.Sort(dataLst);
Array.Reverse(dataLst);

for (i = 0; i < dataLst.Length; i++)
{
Console.Write(dataLst[i] + " ");
if (i < dataLst.Length - 1)
{
Console.Write(",");
}
}
}
}

//////////////////////////////////////////////////////////////// main function

class Program
{
static void Main(string[] args)
{
Console.WriteLine("What type of storage would you like to use?");
String type=Console.ReadLine();

  
Console.WriteLine("What’s the maximum numbers?");
String number = Console.ReadLine();
int n = Convert.ToInt16(number);

if (type.ToLower().Equals("stack") == true) {
Stack stack = new Stack(n);
for(int i = 1; i <= n; i++)
{
Console.WriteLine("Data "+i);
String data = Console.ReadLine();
stack.push(Convert.ToInt16(data));
}
Console.WriteLine("Here’s your returned number list:");
stack.printData();
}
if (type.ToLower().Equals("queue") == true) {
Queue queue = new Queue(n);
for (int i = 1; i <= n; i++)
{
Console.WriteLine("Data " + i);
String data = Console.ReadLine();
queue.push(Convert.ToInt16(data));
}
Console.WriteLine("Here’s your returned number list:");
queue.printData();
}
if (type.ToLower().Equals("bst") == true) {
BST bst = new BST();
for (int i = 1; i <= n; i++)
{
Console.WriteLine("Data " + i);
String data = Console.ReadLine();
bst.addData(Convert.ToInt16(data));
}
  
Console.WriteLine("How would you like the data returned?");
String rtpe = Console.ReadLine();

Console.WriteLine("Here’s your returned number list:");
if (rtpe.ToLower().Equals("pre-order") == true) {
bst.preorder();
}
if (rtpe.ToLower().Equals("post-order") == true) {
bst.postorder();
}
if (rtpe.ToLower().Equals("in-order") == true) {
bst.inorder();
}

  
}
if (type.ToLower().Equals("linked list") == true) {
LinkedList lnklst = new LinkedList();
for (int i = 1; i <= n; i++)
{
Console.WriteLine("Data " + i);
String data = Console.ReadLine();
lnklst.addData(Convert.ToInt16(data));
}

Console.WriteLine("How would you like the data returned?");
String rtpe = Console.ReadLine();

Console.WriteLine("Here’s your returned number list:");
if (rtpe.ToLower().Equals("ascending") == true)
{
lnklst.printAcending();
}
if (rtpe.ToLower().Equals("decending") == true)
{
lnklst.printDecending();
}

}

Console.ReadKey();

}
}

what type of storage would you like to use? Stack What's the maximum numbers? Data 1 6 Data 2 23 Data 3 33 Data 4 12 Data 5 9 Data 6 34 Data 7 21 Data 8 65 Here's your returned number list: 65 21 34 9 12 33 23 6

What type of storage would you like to use? queue What's the maximum numbers? 11 Data 1 4 Data 2 34 Data 3 91 Data 4 22 Data 5 23 Data 6 145 Data 7 68 Data 8 3 Data 9 21 Data 10 567 Data 11 3 Here's your returned number list: 4 34 91 22 23 45 68 3 21 567 3 S

What type of storage would you like to use? Linked list What's the maximum numbers? 8 Data 1 12 Data 2 45 Data 3 564 Data 4 2 Data 5 54 Data 6 34 Data 7 68 Data 8 42 How would you like the data returned? Ascending Here's your returned number list: 2 ,12 ,34 ,42 ,45 ,54 ,68 ,564

what type of storage would you like to use? Linked List What's the maximum numbers? Data 1 345 Data 2 564 Data 3 754 Data 4 156 Data 5 57 Data 6 577 Data 7 1545 How would you like the data returned? Decending Here's your returned number list: 4545 ,754 ,677 ,564 ,456 ,345 ,67

45 What type of storage would you like to use? BST What's the maximum numbers? 11 Data 1 145 Data 2 75 Data 3 15 Data 4 178 Data 5 345 Data 6 17 Data 7 87 Data 8 145 Data 9 87 Data 10 4 Data 11 16 How would you like the data returned? In-order Here's your returned number list: 4 5 6 7 45 45 75 78 87 87 345

what type of storage would you like to use? BST What's the maximum numbers? 11 Data 1 45 Data 2 75 Data 3 5 Data 4 78 Data 5 345 Data 6 Data 7 37 Data 8 45 Data 9 37 Data 10 4 Data 11 How would you like the data returned? Pre-Order Here's your returned number list: 45 4 5 6 7 45 75 78 87 87 345