C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
namespace Ex
{
	public class Program
	{
		/*
		כתוב פעולה חיצונית שמקבלת שתי מחסניות
		st1,st2
		המכילות מספרים שלמים וגדולים מאפס
		הפעולה תחזיר את הסכום של זוג האיברים הסמוכים הקרוב ביותר לראש המחסנית
		st1
		שסכומם גדול מהסכום של כל זוג איברים סמוכים במחסנית
		st2
		הערה: אם אין זוג כזה, הפעולה תחזיר 0
		הנחה: בכל אחת מהמחסניות יש לפחות שני איברים
		הערה: אין צורך לשמור על תוכנן המקורי של המחסניות
		*/
		
		// תחילה, נרשום פעולת עזר:
		// פעולה שמקבלת מחסנית שלמים ומחזירה את הסכום הגבוה ביותר של זוג איברים סמוכים
		// הנחה: קיימים לפחות 2 איברים במחסנית
		public static int MaxSumPair (Stack<int> s)
		{
			int a,b,sum;	
			a=s.Pop();         // הוצאנו מלכתחילה 2 איברים מהמחסנית ללא בדיקה האם היא ריקה, כי קיימת הנחה שהיא לא ריקה
			b=s.Pop();
			sum=a+b;
			while (!s.IsEmpty())
			{
				a=b;
				b=s.Pop();
				if ((a+b)>sum)
					sum=a+b;
			}
			return sum;
		}
		
		// הפעולה המבוקשת
		public static int MaxCupel (Stack<int> st1, Stack<int> st2)
		{
			int a,b,sum;
			// המחסנית מכילה לפחות שני איברים
			a=st1.Pop();
			b=st1.Pop();
			sum = MaxSumPair(st2);           // הסכום הכי גדול של שני איברים סמוכים במחסנית השניה
			while (!st1.IsEmpty() && (a+b)<=sum)
			{
				a=b;
				b=st1.Pop();
			}
			if (a+b>sum)
				return a+b;
			return 0;
		}
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		
		/*
		הפעולה מקבלת מצביע למחסנית מטיפוס מספר שלם
		ומחזירה את גודל המחסנית
		*/
		public static int Size (Stack<int> st)
		{
			Stack<int> tmp = new Stack<int>();   // בניית מחסנית עזר	
			int cnt=0, item;
			
			while (!st.IsEmpty())   //  כל עוד המחסנית לא ריקה
			{
				cnt++;
				item = st.Pop();
				tmp.Push(item);
				/*
				הערה:
				בימקום שתי השורות האחרונות שרשמנו ניתן לרשום בקצרה שורה אחת בלבד באופן הבא:
				tmp.Push(st.Pop());
				*/
			}
			
			while (!tmp.IsEmpty())
			{
				st.Push(tmp.Pop());	
			}
			
			return cnt;
		}
		
		
		
		/*
		כתוב פעולה שמקבלת תור של מספרים שלמים
		ומחזירה את גודל התור, כלומר מספר האיברים בתור
		הערה: יש לשמור על מבנה התור
		*/
		
		/*
		הפעולה מקבלת מצביע לתור של מספרים שלמים
		ומחזירה את גודל התור
		הערה: יש לשמור על מבנה התור
		*/
		public static int SizeQ (Queue<int> qu)
		{
			Queue<int> tmp = new Queue<int>();   // תור עזר
			int cnt=0;
			while (!qu.IsEmpty())
			{
				cnt++;
				tmp.Insert(qu.Remove());
			}
			while (!tmp.IsEmpty())	
				qu.Insert(tmp.Remove());
			return cnt;
		}
		
		// דרך נוספת לפתרון - באמצעות שימוש ב"חוצץ". הנחה: איברי התור הם חיוביים בלבד
		public static int SizeQOption2 (Queue<int> qu)
		{
			int cnt=0;
			int dummy = -99;
			
			qu.Insert(dummy);         // insert dummy element   הכנסת איבר חוצץ לסוף התור
			
			while (qu.Head()!=dummy)
			{
				cnt++;
				qu.Insert(qu.Remove());
			}
			
			qu.Remove();
			return cnt;
		}
		
		/*
		כתוב פעולה שמקבלת מצביע לתור של מספרים שלמים, ומספר שלם חיובי
		הפעולה מחזירה אמת במידה והמספר קיים בתור, אחרת שקר
		הערה: יש לשמור על מבנה התור
		*/
		/*
		פעולה שמקבלת מצביע לתור של מספרים שלמים, ומספר שלם נוסף
		הפעולה תחזיר אמת אם המספר הנוסף קיים, אחרת שקר
		הערה: יש לשמור על איברי התור
		*/
		public static bool IsExist (Queue<int> qu, int num)
		{
			Queue<int> tmp = new Queue<int>();
			bool flag=false;
			int item;
			
			while (!qu.IsEmpty())
			{
				item = qu.Remove();
				if (item==num)
					flag=true;
				tmp.Insert(item);
			}
			
			while (!tmp.IsEmpty())
				qu.Insert(tmp.Remove());
		
			return flag;
		}
		
		
		
		
		
		
		
		
		
		
		
		public static void Main (string[] args)
		{
			int i;
			Queue<int> qu = new Queue<int>();   // הגדרה ובנייה של תור
			for (i=10; i<=90; i+=10)
			{
				qu.Insert(i);      // הכנסת איברים לתור	
			}
			Console.WriteLine ("before: " + qu.ToString());       // הדפסת איברי התור לפי הסדר מראש התור ועד סוף התור
			
			/*
		    הפלט המתקבל הוא 		
			head[10,20,30,40,50,60,70,80,90]end
			*/
			
			Console.WriteLine("size = " + SizeQOption2(qu));
			Console.WriteLine ("after: " + qu.ToString());
			
			
			
			
			/*
			Stack<int> st = new Stack<int>();   // הגדרה ובנייה של מחסנית
			int i;
			for (i=90; i>=10; i-=10)
			{
				st.Push(i);	     // הכנסת איברים למחסנית
			}
			Console.WriteLine (st.ToString());       // הדפסת איברי המחסנית החל מראש המחסנית ועד לתחתית המחסנית
			*/
			/*
			הפלט המתקבל הוא
			top[10,20,30,40,50,60,70,80,90]bottom
			*/
			//Console.WriteLine(Size(st));    // 9
		}
	}
}







/*
תור
Queue
תור הוא מבנה נתונים המכיל אוסף סדור של איברים מאותו סוג.
בתור מוגדרים ראש התור וסוף התור.
הכנסה של איברים נעשית רק בסוף התור (כל איבר חדש מוכנס לתור אחרי האיבר הקודם שהוכנס, כלומר סדר הכנסת האיברים לתור נשמר כל הזמן), 
והוצאה של איברים נעשית רק מראש התור.
שיטת הניהול של ההכנסה וההוצאה מתור נקראת שיטת
FIFO
First In First Out
כלומר, הראשון שנכנס הוא גם הראשון שיוצא

התור (בדומה למחסנית, ולשרשרת חוליות) אינו מוגבל בזיכרון המוקצה עבור איבריו.
כלומר, הקצאת השטח שלו מאפשרת כמה שנרצה להוסיף איברים, ולהוציא איברים מהתור.
תור שאין בו איברים הוא תור ריק.

בתור אין אפשרות גישה לאיברים בתוכו - ניתן לגשת רק אל האיבר המופיע בראשו.
כדי להגיע אל האיבר הנמצא בתוך התור יש להוציא תחילה את כל האיברים הנמצאים לפניו.
מאחר וניתנת גישה רק לראש התור, סריקה של תור יכולה להתבצע בשני אופנים:
-ע"י הוצאה של כל הערכים של התור,
ולכן תהייה כרוכה בשלב הראשון בשימוש במבנה עזר לצורך שמירת הערכים שמוציאים מן התור,
ובשלב שני בהעברה של הערכים ממבנה העזר חזרה אל התור המקורי.
-ע"י "גלגול" של איברי התור,
כלומר האיבר בראש התור יוצא ונכנס לסוף התור.
מהלך זה חוזר על עצמו עד שהאיבר שהיה בראש התור חוזר להופיע שוב בראש התור.

הערה: ברוב המקרים נרצה לשמור על התור המקורי!


דוגמה לתור של מספרים שלמים:
סוף התור - הכנסה                                            ראש התור - הוצאה
   <-----     25     10      20    50      5    -8    35     <-----  

המחלקה
Queue<T>
מייצגת את מבנה הנתונים תור שהערכים בו הם מטיפוס
T

(מחלקה גנרית, כלומר כללית)

הפעולות המוגדרות על תור הן:
הכנסת איבר (לסוף התור)
הוצאת איבר (מראש התור, והחזרת ערכו)
הצצה לאיבר הנמצא בראש התור והחזרת ערכו מבלי להוציאו (לאחר פעולה זו התור נשאר ללא שינוי, להבדיל מפעולת הוצאת איבר מתור)

בנוסף, קיימת פעולה בונה תור, פעולה המחזירה אמת אם התור ריק אחרת שקר, ופעולה המחזירה מחרוזת המתארת את איברי התור (מראשה ועד סופה)

הערה חשובה: לפני שימוש בפעולות של הוצאת איבר ו/או הצצה לראש התור,
חובה לבדוק תחילה האם התור אינו ריק.
אך ורק במידה והתור אינו ריק, נוכל לבצע פעולות אלו.
ניסיון גישה למבנה נתונים ריק לשם הוצאת איבר או הצצה לראש המבנה הוא שגיאה!!!

נראה כעת ממשק של המחלקה תור.
מימוש נראה בהמשך.




דוגמאות:
כתוב פעולה ראשית אשר מגדירה ובונה תור של מספרים שלמים.
הפעולה תכניס לתור את האיברים הבאים (משמאל לימין):
10,20,30,...,90
ותדפיס את איברי התור.
כלומר, האיבר בראש התור יהיה 10, והאיבר בסוף התור יהיה 90.

































































*/




// המחלקה חוליה
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 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 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.value.ToString();
	}
	
}

​x
 
using System;
namespace Ex
{
    public class Program
    {
        /*
        כתוב פעולה חיצונית שמקבלת שתי מחסניות
        st1,st2
        המכילות מספרים שלמים וגדולים מאפס
        הפעולה תחזיר את הסכום של זוג האיברים הסמוכים הקרוב ביותר לראש המחסנית
        st1
        שסכומם גדול מהסכום של כל זוג איברים סמוכים במחסנית
        st2
        הערה: אם אין זוג כזה, הפעולה תחזיר 0
        הנחה: בכל אחת מהמחסניות יש לפחות שני איברים
        הערה: אין צורך לשמור על תוכנן המקורי של המחסניות
        */
        
        // תחילה, נרשום פעולת עזר:
        // פעולה שמקבלת מחסנית שלמים ומחזירה את הסכום הגבוה ביותר של זוג איברים סמוכים
        // הנחה: קיימים לפחות 2 איברים במחסנית
        public static int MaxSumPair (Stack<int> s)
        {
            int a,b,sum;    
            a=s.Pop();         // הוצאנו מלכתחילה 2 איברים מהמחסנית ללא בדיקה האם היא ריקה, כי קיימת הנחה שהיא לא ריקה
            b=s.Pop();
            sum=a+b;
            while (!s.IsEmpty())
            {
                a=b;
                b=s.Pop();
                if ((a+b)>sum)
                    sum=a+b;
            }
            return sum;
        }
        
        // הפעולה המבוקשת
        public static int MaxCupel (Stack<int> st1, Stack<int> st2)
        {
            int a,b,sum;
            // המחסנית מכילה לפחות שני איברים
            a=st1.Pop();
            b=st1.Pop();
            sum = MaxSumPair(st2);           // הסכום הכי גדול של שני איברים סמוכים במחסנית השניה
            while (!st1.IsEmpty() && (a+b)<=sum)
            {
                a=b;
                b=st1.Pop();
            }
            if (a+b>sum)
                return a+b;
            return 0;
        }
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        /*
        הפעולה מקבלת מצביע למחסנית מטיפוס מספר שלם
        ומחזירה את גודל המחסנית
        */
        public static int Size (Stack<int> st)
        {
            Stack<int> tmp = new Stack<int>();   // בניית מחסנית עזר    
            int cnt=0, item;
            
            while (!st.IsEmpty())   //  כל עוד המחסנית לא ריקה
            {
                cnt++;
                item = st.Pop();
                tmp.Push(item);
                /*
                הערה:
                בימקום שתי השורות האחרונות שרשמנו ניתן לרשום בקצרה שורה אחת בלבד באופן הבא:
                tmp.Push(st.Pop());
                */
            }
            
            while (!tmp.IsEmpty())
            {
                st.Push(tmp.Pop()); 
            }
            
            return cnt;
        }
        
        
        
        /*
        כתוב פעולה שמקבלת תור של מספרים שלמים
        ומחזירה את גודל התור, כלומר מספר האיברים בתור
        הערה: יש לשמור על מבנה התור
        */
        
        /*
        הפעולה מקבלת מצביע לתור של מספרים שלמים
        ומחזירה את גודל התור
        הערה: יש לשמור על מבנה התור
        */
        public static int SizeQ (Queue<int> qu)
        {
            Queue<int> tmp = new Queue<int>();   // תור עזר
            int cnt=0;
            while (!qu.IsEmpty())
            {
                cnt++;
                tmp.Insert(qu.Remove());
            }
            while (!tmp.IsEmpty())  
                qu.Insert(tmp.Remove());
            return cnt;
        }
        
        // דרך נוספת לפתרון - באמצעות שימוש ב"חוצץ". הנחה: איברי התור הם חיוביים בלבד
        public static int SizeQOption2 (Queue<int> qu)
        {
            int cnt=0;
            int dummy = -99;
            
            qu.Insert(dummy);         // insert dummy element   הכנסת איבר חוצץ לסוף התור
            
            while (qu.Head()!=dummy)
            {
                cnt++;
                qu.Insert(qu.Remove());
            }
            
            qu.Remove();
            return cnt;
        }
        
        /*
        כתוב פעולה שמקבלת מצביע לתור של מספרים שלמים, ומספר שלם חיובי
        הפעולה מחזירה אמת במידה והמספר קיים בתור, אחרת שקר
        הערה: יש לשמור על מבנה התור
        */
        /*
        פעולה שמקבלת מצביע לתור של מספרים שלמים, ומספר שלם נוסף
        הפעולה תחזיר אמת אם המספר הנוסף קיים, אחרת שקר
        הערה: יש לשמור על איברי התור
        */
        public static bool IsExist (Queue<int> qu, int num)
        {
            Queue<int> tmp = new Queue<int>();
            bool flag=false;
            int item;
            
            while (!qu.IsEmpty())
            {
                item = qu.Remove();
                if (item==num)
                    flag=true;
                tmp.Insert(item);
            }
            
            while (!tmp.IsEmpty())
                qu.Insert(tmp.Remove());
        
            return flag;
        }
        
        
        
        
        
        
        
        
        
        
        
        public static void Main (string[] args)
        {
            int i;
            Queue<int> qu = new Queue<int>();   // הגדרה ובנייה של תור
            for (i=10; i<=90; i+=10)
            {
                qu.Insert(i);      // הכנסת איברים לתור 
            }
            Console.WriteLine ("before: " + qu.ToString());       // הדפסת איברי התור לפי הסדר מראש התור ועד סוף התור
            
            /*
            הפלט המתקבל הוא         
            head[10,20,30,40,50,60,70,80,90]end
            */
            
            Console.WriteLine("size = " + SizeQOption2(qu));
            Console.WriteLine ("after: " + qu.ToString());
            
            
            
            
            /*
            Stack<int> st = new Stack<int>();   // הגדרה ובנייה של מחסנית
            int i;
            for (i=90; i>=10; i-=10)
            {
                st.Push(i);      // הכנסת איברים למחסנית
            }
            Console.WriteLine (st.ToString());       // הדפסת איברי המחסנית החל מראש המחסנית ועד לתחתית המחסנית
            */
            /*
            הפלט המתקבל הוא
            top[10,20,30,40,50,60,70,80,90]bottom
            */
            //Console.WriteLine(Size(st));    // 9
        }
    }
}
​
​
​
​
​
​
​
/*
תור
Queue
תור הוא מבנה נתונים המכיל אוסף סדור של איברים מאותו סוג.
בתור מוגדרים ראש התור וסוף התור.
הכנסה של איברים נעשית רק בסוף התור (כל איבר חדש מוכנס לתור אחרי האיבר הקודם שהוכנס, כלומר סדר הכנסת האיברים לתור נשמר כל הזמן), 
והוצאה של איברים נעשית רק מראש התור.
שיטת הניהול של ההכנסה וההוצאה מתור נקראת שיטת
FIFO
First In First Out
כלומר, הראשון שנכנס הוא גם הראשון שיוצא
​
התור (בדומה למחסנית, ולשרשרת חוליות) אינו מוגבל בזיכרון המוקצה עבור איבריו.
כלומר, הקצאת השטח שלו מאפשרת כמה שנרצה להוסיף איברים, ולהוציא איברים מהתור.
תור שאין בו איברים הוא תור ריק.
​
בתור אין אפשרות גישה לאיברים בתוכו - ניתן לגשת רק אל האיבר המופיע בראשו.
כדי להגיע אל האיבר הנמצא בתוך התור יש להוציא תחילה את כל האיברים הנמצאים לפניו.
מאחר וניתנת גישה רק לראש התור, סריקה של תור יכולה להתבצע בשני אופנים:
-ע"י הוצאה של כל הערכים של התור,
ולכן תהייה כרוכה בשלב הראשון בשימוש במבנה עזר לצורך שמירת הערכים שמוציאים מן התור,
ובשלב שני בהעברה של הערכים ממבנה העזר חזרה אל התור המקורי.
-ע"י "גלגול" של איברי התור,
כלומר האיבר בראש התור יוצא ונכנס לסוף התור.
מהלך זה חוזר על עצמו עד שהאיבר שהיה בראש התור חוזר להופיע שוב בראש התור.
​
הערה: ברוב המקרים נרצה לשמור על התור המקורי!
​
​
דוגמה לתור של מספרים שלמים:
סוף התור - הכנסה                                            ראש התור - הוצאה
   <-----     25     10      20    50      5    -8    35     <-----  
​
המחלקה
Queue<T>
מייצגת את מבנה הנתונים תור שהערכים בו הם מטיפוס
T
​
(מחלקה גנרית, כלומר כללית)
​
הפעולות המוגדרות על תור הן:
הכנסת איבר (לסוף התור)
הוצאת איבר (מראש התור, והחזרת ערכו)
הצצה לאיבר הנמצא בראש התור והחזרת ערכו מבלי להוציאו (לאחר פעולה זו התור נשאר ללא שינוי, להבדיל מפעולת הוצאת איבר מתור)
​
בנוסף, קיימת פעולה בונה תור, פעולה המחזירה אמת אם התור ריק אחרת שקר, ופעולה המחזירה מחרוזת המתארת את איברי התור (מראשה ועד סופה)
​
הערה חשובה: לפני שימוש בפעולות של הוצאת איבר ו/או הצצה לראש התור,
חובה לבדוק תחילה האם התור אינו ריק.
אך ורק במידה והתור אינו ריק, נוכל לבצע פעולות אלו.
ניסיון גישה למבנה נתונים ריק לשם הוצאת איבר או הצצה לראש המבנה הוא שגיאה!!!
​
נראה כעת ממשק של המחלקה תור.
מימוש נראה בהמשך.
​
​
​
​
דוגמאות:
כתוב פעולה ראשית אשר מגדירה ובונה תור של מספרים שלמים.
הפעולה תכניס לתור את האיברים הבאים (משמאל לימין):
10,20,30,...,90
ותדפיס את איברי התור.
כלומר, האיבר בראש התור יהיה 10, והאיבר בסוף התור יהיה 90.
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
​
*/
​
​
​
​
// המחלקה חוליה
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 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 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.value.ToString();
    }
    
}
​
​
​
​
​
​
​

View IL Code