C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
					
public class Program
{
	//ex1
	/*
	הפעולה מקבלת מחסנית של מספרים שלמים ומחזירה את המספר הקטן ביותר במחסנית
	הערה: במידה והמחסנית ריקה יוחזר המספר השלם בגדול ביותר שהטיפוס שלם מקבל
	סיבוכיות זמן ריצה: סיבוכיות לינארית
	O(n)
	כאשר המשתנה
	n
	מייצג את כמות האיברים הלא ידועה, לא קבועה ולא חסומה מלמעלה
	של המחסנית
	stk
	ובנוסף, כל אחת מהפעולות המתבצעות כאן הן בסיבוכיות של קבוע
	O(1)
	ובנוסף, אנחנו עוברים כאן בלולאה
	פעם אחת על כל איבר במחסנית
	ולאחר סיום הלולאה כולה, אנחנו שוב פעם עוברים בלולאה פעם אחת על כל איבר במחסנית
	לכן, בעצם עברנו בסה״כ פעמיים על כל איברי המחסנית, שזה
	2n
	ולכן בסה״כ נקבל שהסיבוכיות של כל הפעולה שנרשמה כאן היא
	O(2n)
	שזה בעצם
	O(n)
	*/
	public static int FindMin (Stack<int> stk)
	{
		if (stk.IsEmpty())   // המחסנית ריקה
			return int.MaxValue;
				
		int num, min; 
        Stack<int> temp = new Stack<int>();
			
		min = stk.Pop();
        temp.Push(min);
		
		while (!stk.IsEmpty())
		{
            num = stk.Pop();
			if (num<min)
				min=num;
			temp.Push(num);
		}
		
		while (!temp.IsEmpty())
            stk.Push(temp.Pop());
		
		return min;
	}
	
	//ex2
	/*
	הפעולה מקבלת מחסנית של מספרים שלמים ומספר נוסף
	ומסירה את המופע הראשון של המספר מהמחסנית
	הערה: מבנה המחסנית משתנה
	סיבוכיות זמן ריצה: סיבוכיות לינארית
	O(n)
	כאשר המשתנה
	n
	מייצג את כמות האיברים הלא ידועה, לא קבועה ולא חסומה מלמעלה
	של המחסנית
	stk
	ובנוסף, כל אחת מהפעולות המתבצעות כאן הן בסיבוכיות של קבוע
	O(1)
	ובנוסף, אנחנו עוברים כאן בלולאה
	פעם אחת על כל איבר במחסנית
	ולאחר סיום הלולאה כולה, אנחנו שוב פעם עוברים בלולאה פעם אחת על כל איבר במחסנית
	לכן, בעצם עברנו בסה״כ פעמיים על כל איברי המחסנית, שזה
	2n
	ולכן בסה״כ נקבל שהסיבוכיות של כל הפעולה שנרשמה כאן היא
	O(2n)
	שזה בעצם
	O(n)
	*/
	public static void Remove (Stack<int> stk, int num)
	{
		int item;
		Stack<int> temp = new Stack<int>();
        while (!stk.IsEmpty() && stk.Top()!=num)
			temp.Push(stk.Pop());
		if  (!stk.IsEmpty() && stk.Top()==num)
			item = stk.Pop();
		while (!temp.IsEmpty())
			stk.Push(temp.Pop());
	}
	
	
	//ex3
	/*
	הפעולה מקבלת מחסנית של מספרים שלמים
	וממיינת אותה מהאיבר הקטן ביותר ועד האיבר הגדול ביותר
	כאשר האיבר הקטן ביותר נמצא בראש המחסנית
	והאיבר הגדול ביותר נמצא בתחתית המחסנית
	הפעולה עושה שימוש בפעולות הנ״ל
	סיבוכיות זמן ריצה:
	O(n^3)
	כאשר המשתנה
	n
	מייצג את כמות האיברים הלא ידועה, לא קבועה ולא חסומה מלמעלה
	של המחסנית
	stk
	אנחנו עוברים כאן בלולאה
	פעם אחת על כל איבר במחסנית
	ובין היתר, בכל פעם עושים שימוש בשתי הפעולות הנ״ל אשר כל אחת מהן מתבצעת בסיבוכיות לינארית
	לכן, הלולאה הראשונה בפעולה זו מתבצעת סדר גודל של
	n^3
	פעמים
	בנוסף, לאחר סיום הלולאה כולה, אנחנו שוב פעם עוברים בלולאה פעם אחת על כל איבר במחסנית
	כאשר כל אחת מהפעולות המתבצעות בלולאה זו הן בסיבוכיות של קבוע
	O(1)
    לכן הלולאה השנייה בפעולה זו מתבצעת סדר גודל של
	n
	פעמים
	ולכן בסה״כ נקבל שהסיבוכיות של כל הפעולה כולה שנרשמה כאן היא
	O(n+(n^3))
	שזה בעצם
	O(n^3)
	*/
	public static void Sort (Stack<int> stk)
	{
        int num;
        Stack<int> temp = new Stack<int>();
		
		while (!stk.IsEmpty())
		{
            num = FindMin(stk);
			Remove(stk,num);
			temp.Push(num);
		}
	
		while (!temp.IsEmpty())
			stk.Push(temp.Pop());	
	}
	
	//ex4
	/*
	 הפעולה מקבלת שתי מחסניות ממויינות של מספרים שלמים
	 ומחזירה מחסנית שלישית ממויינת עם כל הערכים
	 (כולל כפולים)
	 משתי מחסניות הקלט
	 המחסניות ממויינות מהאיבר הקטן ביותר (ראש המחסנית) ועד האיבר הגדול ביותר 
	 (תחתית המחסנית)
	הערה: מבנה המחסניות לא נשמר
	סיבוכיות זמן ריצה לינארי
	*/
	public static Stack<int> MergeSort (Stack<int> s1, Stack<int> s2)
	{
	    Stack<int> stk = new Stack<int>();
		Stack<int> temp = new Stack<int>();
		while (!s1.IsEmpty() && !s2.IsEmpty())
		{
			if (s1.Top()<s2.Top())
                temp.Push(s1.Pop());
			else if (s2.Top()<s1.Top())
                temp.Push(s2.Pop());
			else
			{
                temp.Push(s1.Pop());
                temp.Push(s2.Pop());
			}
		}
		while (!s1.IsEmpty())
		   temp.Push(s1.Pop());
		while (!s2.IsEmpty())
		   temp.Push(s2.Pop());
		while (!temp.IsEmpty())
		   stk.Push(temp.Pop());
        return stk;
	}
	
	//ex5
	/*
	כתוב פעולה שמקבלת מחסנית של מחרוזות
	ומחזירה את המחרוזת המתחילה באות הנמוכה ביותר
	הנחה: יש רק אחת כזו
	הערה: מבנה המחסנית נשמר
	הנחה: אם המחסנית ריקה תוחזר מחרוזת ריקה
	הערה: לבדוק!!!!!!!!!!!!!!!!!! המחרוזות מכילות אותיות באנגלית בלבד?גדולות וקטנות
	ואם לא, הכוונה היא פשט לבדוק רק את התו הראשון בכל מחרוזת???????
	*/
	public static string StartWithLowestLetter (Stack<string> stk)
	{
		if (stk.IsEmpty())
			return ""; 
		string st = stk.Pop();
        if(stk.IsEmpty())
          return st;
        string tmp = StartWithLowestLetter(stk);
		if (st[0]<tmp[0])
           return st;
		return tmp;
    }
	
	
	
	public static void Main()
	{
		Console.WriteLine("Hello World");
		
		//ex1
		Stack<int> s = new Stack<int> ();
		Console.WriteLine(s.ToString()); // המחסנית ריקה
		Console.WriteLine(FindMin(s));   // המספר הכי גדול של טיפוס שלם כאשר המחסנית ריקה
		s.Push(3);
		Console.WriteLine(s.ToString()); // המחסנית מכילה איבר אחד בלבד
		Console.WriteLine(FindMin(s)); // איבר אחד במחסנית והוא 3
		s.Push(1);
		s.Push(1);
		s.Push(2);
		s.Push(8);
		Console.WriteLine(FindMin(s)); // האיבר הכי קטן במחסנית הוא 1
	    Console.WriteLine(s.ToString()); // top[8,2,1,1,3]bottom
		
		Console.WriteLine("-------------------------");
		
		//ex2
		Stack<int> s1 = new Stack<int> ();
		Remove(s1,3);
		Console.WriteLine(s1.ToString()); // המחסנית ריקה
		// אין שינוי - המחסנית ריקה
		
		s1.Push(1);
		Remove(s1,3);
		Console.WriteLine(s1.ToString()); // 1
		// אין שינוי - המספר לחיפוש לא קיים במחסנית לכן המחסנית נשארת עם האיבר 1 ללא שינוי
		
		Remove(s1,1);
		Console.WriteLine(s1.ToString()); // המחסנית ריקה
		// נקבל מחסנית ריקה כי הוצאנו את האיבר היחיד שהיה שם
		
		s1.Push(8);
		s1.Push(3);
		s1.Push(2);
		s1.Push(3);
		s1.Push(5);
		Console.WriteLine(s1.ToString()); // המחסנית לפני השינוי top[5,3,2,3,8]bottom
		Remove(s1,3);
		Console.WriteLine(s1.ToString()); // המחסנית לאחר השינוי top[5,2,3,8]bottom
		
		Remove(s1,8);
		Console.WriteLine(s1.ToString()); // המחסנית לאחר השינוי top[5,2,3]bottom
		Remove(s1,5);
		Console.WriteLine(s1.ToString());  // המחסנית לאחר השינוי top[2,3]bottom
		
		//ex3
		Sort(s1);
		Console.WriteLine(s1.ToString());
		Console.WriteLine("-------------------------");
		
		//ex4
		Stack<int> s4 = new Stack<int> ();
		Stack<int> s5 = new Stack<int> ();
		s4.Push(10);
		s4.Push(9);
		s4.Push(5);
		s4.Push(3);
		s4.Push(1);
		Console.WriteLine(s4.ToString());   // top[1,3,5,9,10]bottom
		s5.Push(12);
		s5.Push(10);
		s5.Push(8);
		s5.Push(7);
		s5.Push(4);
		s5.Push(2);
		s5.Push(0);
		Console.WriteLine(s5.ToString());   // top[0,2,4,7,8,10,12]bottom
		Stack<int> newS = MergeSort(s4,s5);
		Console.WriteLine(newS.ToString());   // top[0,1,2,3,4,5,7,8,9,10,10,12]bottom
		Console.WriteLine("-------------------------");
		//ex5
		//לבדוק!!!!!!!!!!!!!!!!!!!!!
		Stack<string> sss = new Stack<string> ();
		sss.Push("zat");
		sss.Push("app");
		sss.Push("A");
        Console.WriteLine(StartWithLowestLetter(sss));

	}
	
	
	
	
	// בניית רשימה דו-כיוונית של מספרים שלמים
	// ל-ב-ד-ו-ק
	public static BinNode<int> BuildBnlistInt ()
	{
        BinNode<int> duList = new BinNode<int> (int.Parse(Console.ReadLine()));
		BinNode<int> last = duList;
		int num = int.Parse(Console.ReadLine());
		while (num!=-999)
		{
            BinNode<int> p = new BinNode<int> (num);
			last.SetRight(p);
			p.SetLeft(last);
			last=last.GetRight();
			num = int.Parse(Console.ReadLine());
		}
		return duList;
	}
	
	// פעולה שמציגה על המסך שרשרת חוליות דו-כיוונית של מספרים שלמים
	// ל-ב-ד-ו-ק!!!
	public static void ShowBnlist (BinNode<int> lst)
   {
    Console.Write("[");
	BinNode<int> pos = lst;

    while (pos != null)
	{
        Console.Write(pos.ToString());
		//if (pos.HasRight())
			//Console.Write(", ");
		pos = pos.GetRight();
	}
	Console.WriteLine("]");
 }
	
	// בניית שרשרת חוליות של מספרים שלמים
	public static Node<int> Build (int n)
    {
        int x;
	    Node<int> lst = null;
	    Node<int> pos = null;
	
     	for (int i=0;i<n;i++)
	    {
            Console.WriteLine("enter number");
		    x=int.Parse(Console.ReadLine());
		    if (lst==null)
	     	{
                lst=new Node<int>(x);
		    	pos=lst;
	     	}
            else
	    	{
                pos.SetNext(new Node<int>(x));
			    pos=pos.GetNext();
	    	}
	   }
	   return lst;
   }
	
	// בניית שרשרת חוליות של מספרים שלמים - לבדוק
	public static Node<int> CreateList (int numNodes)
	{
		int i, x;
		Node<int> lst = new Node<int>(-1);   // חוליית דמה
		Node<int> pos = lst;
		
		for (i=1; i<=numNodes; i++)
		{
            Console.WriteLine("enter number");
		    x=int.Parse(Console.ReadLine());
			pos.SetNext(new Node<int>(x));
			pos = pos.GetNext();
		}
		
		return lst.GetNext();
	}
	
		
	
	// הצגת שרשרת חוליות של מספרים שלמים
	public static void Show (Node<int> lst)
   {
    Console.Write("[");
	Node<int> pos = lst;

    while (pos != null)
	{
        Console.Write(pos.ToString());
		if (pos.HasNext())
			Console.Write(", ");
		pos = pos.GetNext();
	}
	Console.WriteLine("]");
 }
	
}

// המחלקה מחסנית
public class Stack<T> 
{
	private Node<T> first;
	
	public Stack()
	{
		this.first=null;
	}
	
	public bool IsEmpty()
	{
		return this.first==null;
	}
	
	public void Push (T x)
	{
		this.first=new Node<T> (x,this.first);
	}
	
      public T Pop ()
	{
		T x=this.first.GetValue();
		this.first=this.first.GetNext();
		return x;
	}
	
	public T Top ()
	{
		return this.first.GetValue();
	}
	
	public override String ToString()
	{
		String str="top[";
		Node<T> pos = this.first;
		
		while (pos!=null)
		{
			str=str+pos.GetValue().ToString();
			if (pos.GetNext()!=null)
				str=str+",";
			pos=pos.GetNext();
		}
		str=str+"]bottom";
		return str;
	}
	
}


// המחלקה חוליה
public class Node<T> 
{
	private T value;
	private Node<T> next;
	
	public Node (T value)
	{
		this.value=value;
		this.next=null;
	}
	public Node (T value, Node<T> next)
	{
		this.value=value;
		this.next=next;
	}
	public T GetValue()
	{
		return this.value;
	}

public Node<T> GetNext()
	{
		return this.next;
	}
	public void SetValue (T value)
	{
		this.value=value;
	}
	public void SetNext(Node<T> next)
	{
		this.next=next;
	}

    // הפעולה מחזירה אמת אם קיימת חוליה עוקבת, אחרת מחזירה שקר
	public bool HasNext()
    {
       return this.next != null;
    }
	
	public override String ToString()
	{
		return this.value.ToString() +" ";
	}

}

// המחלקה תור
public class Queue<T> 
{
	private Node<T> first;
	private Node<T> last;
	
	public Queue ()
	{
		this.first=null;
		this.last=null;
	}
	
	public bool IsEmpty()
	{
		return this.first==null;
	}
	
	public void Insert (T x)
	{
		Node<T> temp = new Node<T>(x);
		if (first==null)
			first=temp;
		else
			last.SetNext(temp);
		last=temp;
	}
	
	public T Remove ()
	{
		T x=this.first.GetValue();
		this.first=this.first.GetNext();
		if (first==null)
			last=null;
		return x;
	}
	
	public T Head ()
	{
		return this.first.GetValue();
	}
	
	public override String ToString ()
	{
		String str="head[";
		Node<T> pos = this.first;
		
		while (pos!=null)
		{
			str=str+pos.GetValue().ToString();
			if (pos.GetNext()!=null)
				str=str+",";
			pos=pos.GetNext();
		}
		str=str+"]end";
		return str;
	}
	
	
}

// המחלקה חוליה בינארית
public class BinNode<T>
{
	private T value;             
	private BinNode<T> left;     
	private BinNode<T> right;
	
	public BinNode (T x)
	{
		this.value = x;
		this.left = null;
		this.right = null;
	}
	
	public BinNode (BinNode<T> left, T x, BinNode<T> right)
	{
		this.value = x;
		this.left = left;
		this.right = right;
	}
	
	public T GetValue()
	{
		return this.value;
	}
	
	public BinNode<T> GetLeft()
	{
		return this.left;
	}
	
	public BinNode<T> GetRight()
	{
		return this.right;
	}
	
	public bool HasLeft()
	{
		if (this.left!=null) 
			return true;
		return false;
	}
	
	public bool HasRight()
	{
		if (this.right!=null) 
			return true;
		return false;
	}
	
	public void SetValue(T x)
	{
		this.value = x;
	}
	
	public void SetLeft(BinNode<T> left)
	{
		this.left = left;
	}
	
	public void SetRight(BinNode<T> right)
	{
		this.right = right;
	}
	
	public override String ToString ()
	{
		return "("+this.left+" "+this.value.ToString()+" "+this.right+")";
		/*
		בימקום השורה הקודמת שנראה לי לא עובדת לנסות לרשום את הקוד הזה
		if (this.right != null)
	        return value.ToString() + " <=> " ;
	      else
	        return value.ToString() + "";
		*/
	}
	
}

​x
 
using System;
                    
public class Program
{
    //ex1
    /*
    הפעולה מקבלת מחסנית של מספרים שלמים ומחזירה את המספר הקטן ביותר במחסנית
    הערה: במידה והמחסנית ריקה יוחזר המספר השלם בגדול ביותר שהטיפוס שלם מקבל
    סיבוכיות זמן ריצה: סיבוכיות לינארית
    O(n)
    כאשר המשתנה
    n
    מייצג את כמות האיברים הלא ידועה, לא קבועה ולא חסומה מלמעלה
    של המחסנית
    stk
    ובנוסף, כל אחת מהפעולות המתבצעות כאן הן בסיבוכיות של קבוע
    O(1)
    ובנוסף, אנחנו עוברים כאן בלולאה
    פעם אחת על כל איבר במחסנית
    ולאחר סיום הלולאה כולה, אנחנו שוב פעם עוברים בלולאה פעם אחת על כל איבר במחסנית
    לכן, בעצם עברנו בסה״כ פעמיים על כל איברי המחסנית, שזה
    2n
    ולכן בסה״כ נקבל שהסיבוכיות של כל הפעולה שנרשמה כאן היא
    O(2n)
    שזה בעצם
    O(n)
    */
    public static int FindMin (Stack<int> stk)
    {
        if (stk.IsEmpty())   // המחסנית ריקה
            return int.MaxValue;
                
        int num, min; 
        Stack<int> temp = new Stack<int>();
            
        min = stk.Pop();
        temp.Push(min);
        
        while (!stk.IsEmpty())
        {
            num = stk.Pop();
            if (num<min)
                min=num;
            temp.Push(num);
        }
        
        while (!temp.IsEmpty())
            stk.Push(temp.Pop());
        
        return min;
    }
    
    //ex2
    /*
    הפעולה מקבלת מחסנית של מספרים שלמים ומספר נוסף
    ומסירה את המופע הראשון של המספר מהמחסנית
    הערה: מבנה המחסנית משתנה
    סיבוכיות זמן ריצה: סיבוכיות לינארית
    O(n)
    כאשר המשתנה
    n
    מייצג את כמות האיברים הלא ידועה, לא קבועה ולא חסומה מלמעלה
    של המחסנית
    stk
    ובנוסף, כל אחת מהפעולות המתבצעות כאן הן בסיבוכיות של קבוע
    O(1)
    ובנוסף, אנחנו עוברים כאן בלולאה
    פעם אחת על כל איבר במחסנית
    ולאחר סיום הלולאה כולה, אנחנו שוב פעם עוברים בלולאה פעם אחת על כל איבר במחסנית
    לכן, בעצם עברנו בסה״כ פעמיים על כל איברי המחסנית, שזה
    2n
    ולכן בסה״כ נקבל שהסיבוכיות של כל הפעולה שנרשמה כאן היא
    O(2n)
    שזה בעצם
    O(n)
    */
    public static void Remove (Stack<int> stk, int num)
    {
        int item;
        Stack<int> temp = new Stack<int>();
        while (!stk.IsEmpty() && stk.Top()!=num)
            temp.Push(stk.Pop());
        if  (!stk.IsEmpty() && stk.Top()==num)
            item = stk.Pop();
        while (!temp.IsEmpty())
            stk.Push(temp.Pop());
    }
    
    
    //ex3
    /*
    הפעולה מקבלת מחסנית של מספרים שלמים
    וממיינת אותה מהאיבר הקטן ביותר ועד האיבר הגדול ביותר
    כאשר האיבר הקטן ביותר נמצא בראש המחסנית
    והאיבר הגדול ביותר נמצא בתחתית המחסנית
    הפעולה עושה שימוש בפעולות הנ״ל
    סיבוכיות זמן ריצה:
    O(n^3)
    כאשר המשתנה
    n
    מייצג את כמות האיברים הלא ידועה, לא קבועה ולא חסומה מלמעלה
    של המחסנית
    stk
    אנחנו עוברים כאן בלולאה
    פעם אחת על כל איבר במחסנית
    ובין היתר, בכל פעם עושים שימוש בשתי הפעולות הנ״ל אשר כל אחת מהן מתבצעת בסיבוכיות לינארית
    לכן, הלולאה הראשונה בפעולה זו מתבצעת סדר גודל של
    n^3
    פעמים
    בנוסף, לאחר סיום הלולאה כולה, אנחנו שוב פעם עוברים בלולאה פעם אחת על כל איבר במחסנית
    כאשר כל אחת מהפעולות המתבצעות בלולאה זו הן בסיבוכיות של קבוע
    O(1)
    לכן הלולאה השנייה בפעולה זו מתבצעת סדר גודל של
    n
    פעמים
    ולכן בסה״כ נקבל שהסיבוכיות של כל הפעולה כולה שנרשמה כאן היא
    O(n+(n^3))
    שזה בעצם
    O(n^3)
    */
    public static void Sort (Stack<int> stk)
    {
        int num;
        Stack<int> temp = new Stack<int>();
        
        while (!stk.IsEmpty())
        {
            num = FindMin(stk);
            Remove(stk,num);
            temp.Push(num);
        }
    
        while (!temp.IsEmpty())
            stk.Push(temp.Pop());   
    }
    
    //ex4
    /*
     הפעולה מקבלת שתי מחסניות ממויינות של מספרים שלמים
     ומחזירה מחסנית שלישית ממויינת עם כל הערכים
     (כולל כפולים)
     משתי מחסניות הקלט
     המחסניות ממויינות מהאיבר הקטן ביותר (ראש המחסנית) ועד האיבר הגדול ביותר 
     (תחתית המחסנית)
    הערה: מבנה המחסניות לא נשמר
    סיבוכיות זמן ריצה לינארי
    */
    public static Stack<int> MergeSort (Stack<int> s1, Stack<int> s2)
    {
        Stack<int> stk = new Stack<int>();
        Stack<int> temp = new Stack<int>();
        while (!s1.IsEmpty() && !s2.IsEmpty())
        {
            if (s1.Top()<s2.Top())
                temp.Push(s1.Pop());
            else if (s2.Top()<s1.Top())
                temp.Push(s2.Pop());
            else
            {
                temp.Push(s1.Pop());
                temp.Push(s2.Pop());
            }
        }
        while (!s1.IsEmpty())
           temp.Push(s1.Pop());
        while (!s2.IsEmpty())
           temp.Push(s2.Pop());
        while (!temp.IsEmpty())
           stk.Push(temp.Pop());
        return stk;
    }
    
    //ex5
    /*
    כתוב פעולה שמקבלת מחסנית של מחרוזות
    ומחזירה את המחרוזת המתחילה באות הנמוכה ביותר
    הנחה: יש רק אחת כזו
    הערה: מבנה המחסנית נשמר
    הנחה: אם המחסנית ריקה תוחזר מחרוזת ריקה
    הערה: לבדוק!!!!!!!!!!!!!!!!!! המחרוזות מכילות אותיות באנגלית בלבד?גדולות וקטנות
    ואם לא, הכוונה היא פשט לבדוק רק את התו הראשון בכל מחרוזת???????
    */
    public static string StartWithLowestLetter (Stack<string> stk)
    {
        if (stk.IsEmpty())
            return ""; 
        string st = stk.Pop();
        if(stk.IsEmpty())
          return st;
        string tmp = StartWithLowestLetter(stk);
        if (st[0]<tmp[0])
           return st;
        return tmp;
    }
    
    
    
    public static void Main()
    {
        Console.WriteLine("Hello World");
        
        //ex1
        Stack<int> s = new Stack<int> ();
        Console.WriteLine(s.ToString()); // המחסנית ריקה
        Console.WriteLine(FindMin(s));   // המספר הכי גדול של טיפוס שלם כאשר המחסנית ריקה
        s.Push(3);
        Console.WriteLine(s.ToString()); // המחסנית מכילה איבר אחד בלבד
        Console.WriteLine(FindMin(s)); // איבר אחד במחסנית והוא 3
        s.Push(1);
        s.Push(1);
        s.Push(2);
        s.Push(8);
        Console.WriteLine(FindMin(s)); // האיבר הכי קטן במחסנית הוא 1
        Console.WriteLine(s.ToString()); // top[8,2,1,1,3]bottom
        
        Console.WriteLine("-------------------------");
        
        //ex2
        Stack<int> s1 = new Stack<int> ();
        Remove(s1,3);
        Console.WriteLine(s1.ToString()); // המחסנית ריקה
        // אין שינוי - המחסנית ריקה
        
        s1.Push(1);
        Remove(s1,3);
        Console.WriteLine(s1.ToString()); // 1
        // אין שינוי - המספר לחיפוש לא קיים במחסנית לכן המחסנית נשארת עם האיבר 1 ללא שינוי
        
        Remove(s1,1);
        Console.WriteLine(s1.ToString()); // המחסנית ריקה
        // נקבל מחסנית ריקה כי הוצאנו את האיבר היחיד שהיה שם
        
        s1.Push(8);
        s1.Push(3);
        s1.Push(2);
        s1.Push(3);
        s1.Push(5);
        Console.WriteLine(s1.ToString()); // המחסנית לפני השינוי top[5,3,2,3,8]bottom
        Remove(s1,3);
        Console.WriteLine(s1.ToString()); // המחסנית לאחר השינוי top[5,2,3,8]bottom
        
        Remove(s1,8);
        Console.WriteLine(s1.ToString()); // המחסנית לאחר השינוי top[5,2,3]bottom
        Remove(s1,5);
        Console.WriteLine(s1.ToString());  // המחסנית לאחר השינוי top[2,3]bottom
        
        //ex3
        Sort(s1);
        Console.WriteLine(s1.ToString());
        Console.WriteLine("-------------------------");
        
        //ex4
        Stack<int> s4 = new Stack<int> ();
        Stack<int> s5 = new Stack<int> ();
        s4.Push(10);
        s4.Push(9);
        s4.Push(5);
        s4.Push(3);
        s4.Push(1);
        Console.WriteLine(s4.ToString());   // top[1,3,5,9,10]bottom
        s5.Push(12);
        s5.Push(10);
        s5.Push(8);
        s5.Push(7);
        s5.Push(4);
        s5.Push(2);
        s5.Push(0);
        Console.WriteLine(s5.ToString());   // top[0,2,4,7,8,10,12]bottom
        Stack<int> newS = MergeSort(s4,s5);
        Console.WriteLine(newS.ToString());   // top[0,1,2,3,4,5,7,8,9,10,10,12]bottom
        Console.WriteLine("-------------------------");
        //ex5
        //לבדוק!!!!!!!!!!!!!!!!!!!!!
        Stack<string> sss = new Stack<string> ();
        sss.Push("zat");
        sss.Push("app");
        sss.Push("A");
        Console.WriteLine(StartWithLowestLetter(sss));
​
    }
    
    
    
    
    // בניית רשימה דו-כיוונית של מספרים שלמים
    // ל-ב-ד-ו-ק
    public static BinNode<int> BuildBnlistInt ()
    {
        BinNode<int> duList = new BinNode<int> (int.Parse(Console.ReadLine()));
        BinNode<int> last = duList;
        int num = int.Parse(Console.ReadLine());
        while (num!=-999)
        {
            BinNode<int> p = new BinNode<int> (num);
            last.SetRight(p);
            p.SetLeft(last);
            last=last.GetRight();
            num = int.Parse(Console.ReadLine());
        }
        return duList;
    }
    
    // פעולה שמציגה על המסך שרשרת חוליות דו-כיוונית של מספרים שלמים
    // ל-ב-ד-ו-ק!!!
    public static void ShowBnlist (BinNode<int> lst)
   {
    Console.Write("[");
    BinNode<int> pos = lst;
​
    while (pos != null)
    {
        Console.Write(pos.ToString());
        //if (pos.HasRight())
            //Console.Write(", ");
        pos = pos.GetRight();
    }
    Console.WriteLine("]");
 }
    
    // בניית שרשרת חוליות של מספרים שלמים
    public static Node<int> Build (int n)
    {
        int x;
        Node<int> lst = null;
        Node<int> pos = null;
    
        for (int i=0;i<n;i++)
        {
            Console.WriteLine("enter number");
            x=int.Parse(Console.ReadLine());
            if (lst==null)
            {
                lst=new Node<int>(x);
                pos=lst;
            }
            else
            {
                pos.SetNext(new Node<int>(x));
                pos=pos.GetNext();
            }
       }
       return lst;
   }
    
    // בניית שרשרת חוליות של מספרים שלמים - לבדוק
    public static Node<int> CreateList (int numNodes)
    {
        int i, x;
        Node<int> lst = new Node<int>(-1);   // חוליית דמה
        Node<int> pos = lst;
        
        for (i=1; i<=numNodes; i++)
        {
            Console.WriteLine("enter number");
            x=int.Parse(Console.ReadLine());
            pos.SetNext(new Node<int>(x));
            pos = pos.GetNext();
        }
        
        return lst.GetNext();
    }
    
        
    
    // הצגת שרשרת חוליות של מספרים שלמים
    public static void Show (Node<int> lst)
   {
    Console.Write("[");
    Node<int> pos = lst;
​
    while (pos != null)
    {
        Console.Write(pos.ToString());
        if (pos.HasNext())
            Console.Write(", ");
        pos = pos.GetNext();
    }
    Console.WriteLine("]");
 }
    
}
​
// המחלקה מחסנית
public class Stack<T> 
{
    private Node<T> first;
    
    public Stack()
    {
        this.first=null;
    }
    
    public bool IsEmpty()
    {
        return this.first==null;
    }
    
    public void Push (T x)
    {
        this.first=new Node<T> (x,this.first);
    }
    
      public T Pop ()
    {
        T x=this.first.GetValue();
        this.first=this.first.GetNext();
        return x;
    }
    
    public T Top ()
    {
        return this.first.GetValue();
    }
    
    public override String ToString()
    {
        String str="top[";
        Node<T> pos = this.first;
        
        while (pos!=null)
        {
            str=str+pos.GetValue().ToString();
            if (pos.GetNext()!=null)
                str=str+",";
            pos=pos.GetNext();
        }
        str=str+"]bottom";
        return str;
    }
    
}
​
​
// המחלקה חוליה
public class Node<T> 
{
    private T value;
    private Node<T> next;
    
    public Node (T value)
    {
        this.value=value;
        this.next=null;
    }
    public Node (T value, Node<T> next)
    {
        this.value=value;
        this.next=next;
    }
    public T GetValue()
    {
        return this.value;
    }
​
public Node<T> GetNext()
    {
        return this.next;
    }
    public void SetValue (T value)
    {
        this.value=value;
    }
    public void SetNext(Node<T> next)
    {
        this.next=next;
    }
​
    // הפעולה מחזירה אמת אם קיימת חוליה עוקבת, אחרת מחזירה שקר
    public bool HasNext()
    {
       return this.next != null;
    }
    
    public override String ToString()
    {
        return this.value.ToString() +" ";
    }
​
}
​
// המחלקה תור
public class Queue<T> 
{
    private Node<T> first;
    private Node<T> last;
    
    public Queue ()
    {
        this.first=null;
        this.last=null;
    }
    
    public bool IsEmpty()
    {
        return this.first==null;
    }
    
    public void Insert (T x)
    {
        Node<T> temp = new Node<T>(x);
        if (first==null)
            first=temp;
        else
            last.SetNext(temp);
        last=temp;
    }
    
    public T Remove ()
    {
        T x=this.first.GetValue();
        this.first=this.first.GetNext();
        if (first==null)
            last=null;
        return x;
    }
    
    public T Head ()
    {
        return this.first.GetValue();
    }
    
    public override String ToString ()
    {
        String str="head[";
        Node<T> pos = this.first;
        
        while (pos!=null)
        {
            str=str+pos.GetValue().ToString();
            if (pos.GetNext()!=null)
                str=str+",";
            pos=pos.GetNext();
        }
        str=str+"]end";
        return str;
    }
    
    
}
​
// המחלקה חוליה בינארית
public class BinNode<T>
{
    private T value;             
    private BinNode<T> left;     
    private BinNode<T> right;
    
    public BinNode (T x)
    {
        this.value = x;
        this.left = null;
        this.right = null;
    }
    
    public BinNode (BinNode<T> left, T x, BinNode<T> right)
    {
        this.value = x;
        this.left = left;
        this.right = right;
    }
    
    public T GetValue()
    {
        return this.value;
    }
    
    public BinNode<T> GetLeft()
    {
        return this.left;
    }
    
    public BinNode<T> GetRight()
    {
        return this.right;
    }
    
    public bool HasLeft()
    {
        if (this.left!=null) 
            return true;
        return false;
    }
    
    public bool HasRight()
    {
        if (this.right!=null) 
            return true;
        return false;
    }
    
    public void SetValue(T x)
    {
        this.value = x;
    }
    
    public void SetLeft(BinNode<T> left)
    {
        this.left = left;
    }
    
    public void SetRight(BinNode<T> right)
    {
        this.right = right;
    }
    
    public override String ToString ()
    {
        return "("+this.left+" "+this.value.ToString()+" "+this.right+")";
        /*
        בימקום השורה הקודמת שנראה לי לא עובדת לנסות לרשום את הקוד הזה
        if (this.right != null)
            return value.ToString() + " <=> " ;
          else
            return value.ToString() + "";
        */
    }
    
}
​
​
​
​

Cached Result
Last Run:	1:59:05 pm
Compile:	0.267s
Execute:	3.524s
Memory:	1.81Mb
CPU:	0.578s

View IL Code