C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;
		
public class Program
{
	
	//ex3
	/*
	הפעולה מקבלת מצביע לשרשרת חוליות דו-כיוונית של מחרוזות
	ומחזירה אמת אם איברי השרשרת הם פולינדרום
	ושקר אחרת
	*/
	public static bool IsPalindrome (BinNode<string> ls)
	{
        if (ls==null) return true;
		BinNode<string> first = ls;
		BinNode<string> last = ls;
		while (last.GetRight()!=null)
			last=last.GetRight();
		// הערה: אם אורך השרשרת אי-זוגי אז המצביעים ייפגשו באמצע הדרך ואז הלולאה תעצור
		// ואם אורך השרשרת זוגי אז המצביעים ייפגשו לאחר שעברו על כל הרשימה והגיעו לקצותיה ויעצרו בnull
		while (first!=last) 
		{
           if (!(first.GetValue().Equals(last.GetValue())))
			   return false;
			Console.WriteLine(first.GetValue());
		   first=first.GetRight();
		   last=last.GetLeft();
		}
		return true;
	}
	
	
	
	
	//ex1
	/*
	הפעולה מקבלת מצביע לשרשרת חוליות לא ריקה של מספרים שלמים
	הפעולה משנה את סדר האיברים בשרשרת כך שכל האיברים הזוגיים יופיעו בראש השרשרת
	ואחריהם יופיעו כל האיברים האי-זוגיים
	הערה: יש לשמור על סדר פנימי של האיברים הזוגיים, וסדר פנימי של האיברים האי-זוגיים
	הפעולה מחזירה מצביע עדכני לשרשרת
	*/
	public static Node<int> FirstEvenLastOdd (Node<int> ls)
	{
     if (ls==null) return ls;  
	
	 Node<int> first = new Node<int> (-99,ls);
	 ls = first;
		
	 Node<int> prev = ls;
	 
		Node<int> tmp=null;
	
	 while (prev.GetNext()!=null)
		 prev=prev.GetNext();
	
		
		Node<int> last = new Node<int> (-99);
		prev.SetNext(last);
		
		Node<int> p = last;   // המצביע נמצא כעת על האיבר האחרון ברשימה
		
		prev= ls ;
		
	 while (prev.GetNext()!=last)
	 {
         if(prev.GetNext().GetValue()%2!=0)
		 {
            tmp = prev.GetNext();
		    prev.SetNext(prev.GetNext().GetNext());
			tmp.SetNext(null);
			p.SetNext(tmp);
			p = p.GetNext();
		 }
		 else
		    prev=prev.GetNext();
	 }
		
   
		prev.SetNext(last.GetNext());
		last.SetNext(null);
		
	 return ls.GetNext();  


	}
	
	
	
	public static Node<int> Dilul (Node<int> p)
   {
     if (p==null)   // שרשרת ריקה
        return p;    // נחזיר את פי כי בשרשרת ריקה אין כפולים
     if (!p.HasNext())   // אם השרשרת מכילה איבר אחד אז אין כפולים
       return p;
     p.SetNext(Remove1(p.GetNext(),p.GetValue()));
     // בעצם קוראים לפעולת עזר עם אותה שרשרת החל מהמקום של האיבר העוקב
    // של החוליה הנוכחית ובנוסף ערך לחיפוש והסרה אם קיים
    Node<int> temp = p;
    p = Dilul (p.GetNext());
    return temp;
   }
	
	/*
	ex2
	פעולה רקורסיבית המקבלת מצביע לשרשרת חוליות לא ריקה וממוינת
	ומדללת כפולים
	הפעולה מחזירה מצביע עדכני לשרשרת
	*/
	public static Node<int> Dilul2 (Node<int> p)
   {
     if (p==null)   // שרשרת ריקה
        return p;    // נחזיר את פי כי בשרשרת ריקה אין כפולים
     if (!p.HasNext())   // אם השרשרת מכילה איבר אחד אז אין כפולים
       return p;
     Node<int> temp = p;
	 if (p.GetValue()==p.GetNext().GetValue())
	 {
	   p.SetNext(p.GetNext().GetNext());
       p = Dilul2 (p);
	 }
	 else 
        p = Dilul2 (p.GetNext());
     return temp;
   }
	
   // אסור שרשרת ריקה כי אז תהייה שגיאה במקרה זה
	public static void Dilul3 (Node<int> p)
   {/*
     if (p==null)  
        return ;  
     if (!p.HasNext())   
       return ;*/
		if (p.HasNext()){
	 if (p.GetValue()==p.GetNext().GetValue())
	 {
	   p.SetNext(p.GetNext().GetNext());
       Dilul3 (p);
	 }
	 else 
        Dilul3 (p.GetNext());}
   }
	/* התייחסתי כאן גם למקרה שהרשימה ריקה למרות שנתון שלא
public static void Dilul3 (Node<int> p)
   {
     if (p==null)  
        return ;  
     if (!p.HasNext())   
       return ;
		
	 if (p.GetValue()==p.GetNext().GetValue())
	 {
	   p.SetNext(p.GetNext().GetNext());
       Dilul3 (p);
	 }
	 else 
        Dilul3 (p.GetNext());
   }
	*/
	
	// בניית רשימה דו-כיוונית של מספרים שלמים
	// ל-ב-ד-ו-ק
	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<string> lst)
   {
    Console.Write("[");
	BinNode<string> pos = lst;

    while (pos != null)
	{
        Console.Write(pos.ToString());
		//if (pos.HasRight())
			//Console.Write(", ");
		pos = pos.GetRight();
	}
	Console.WriteLine("]");
 }
	
	// בניית שרשרת חוליות דו-כיוונית באמצעות מערך
	public static BinNode<string> BuildBnlistIntByAr (string[] ar)
	{
		BinNode<string> lst = new BinNode<string>(ar[0]);
	    BinNode<string> pos = lst;
		BinNode<string> p;
	
     	for (int i=1;i<ar.Length;i++)
	    {
            p = new BinNode<string> (ar[i]);
			pos.SetRight(p);
			p.SetLeft(pos);
			pos=pos.GetRight();
	   }
	   return lst;
	}
	
	
	
	
	
	//בניית שרשרת חוליות (ללא חוליית דמה) של מספרים שלמים ממערך נתון
	// הפעולה מקבלת מערך של מספרים שלמים ומחזירה שרשרת חוליות עם ערכי המערך
	// תוך שמירה על סדר האיברים
	// הנחה חשובה: המערך לא ריק!!! הוא מכיל לפחות איבר אחד
	public static Node<int> BuildListFromAr (int[] ar)
    {
	    Node<int> lst = new Node<int>(ar[0]);
	    Node<int> pos = lst;
	
     	for (int i=1;i<ar.Length;i++)
	    {
            pos.SetNext(new Node<int>(ar[i]));
			pos=pos.GetNext();
	   }
	   return lst;
     }
	
	
	
	
	//  בניית שרשרת חוליות של מספרים שלמים ללא חוליית דמה
	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(", ");
			Console.Write(",");
		pos = pos.GetNext();
	}
	Console.WriteLine("]");
 }
	
	
	
	
	public static Node<int> Remove1 (Node<int> p, int val)
{
     if (p==null) return p;   
     Node<int> dummy = new Node<int> (-999,p);
	 p=dummy;
	 Node<int> prev = p;
	 while (prev.GetNext()!=null)
	 {
         if(prev.GetNext().GetValue()==val)
		    prev.SetNext(prev.GetNext().GetNext());
		 else
		    prev=prev.GetNext();
	 }
	 return p.GetNext();
}
	
	public static Node<int> Remove (Node<int> p, int val)
{
     if (p==null) return p;   
       Node<int> dummy = new Node<int> (-999,p);
	 p=dummy;
	 Node<int> prev = p;
	 while (prev.GetNext()!=null && prev.GetNext().GetValue()!=val)
		 prev=prev.GetNext();
	 if (prev.GetNext()!=null)
		 if (prev.GetNext().GetValue()==val)
             prev.SetNext(prev.GetNext().GetNext());
	 return p.GetNext();
}
	
	
	
	
	/*
	ניסיון לפתור באופן רקורסיבי אבל לא צלח
	public static Node<int> Remove (Node<int> p, int val)
    {
      if (p==null)              // הרשימה ריקה
        return p;   
	  if (p.GetNext()==null)    // הרשימה מכילה איבר אחד בלבד
		  if (p.GetValue()==val)      // ערך האיבר האחרון שווה לערך שיש להסיר
			  return p.GetNext();
	      else return Remove (p.GetNext(),val);    // ערך האיבר האחרון שונה מהערך שיש להסיר
	  
	  if (p.GetValue()!=val)
		  return Remove (p.GetNext(),val);
	  p.SetNext(p.GetNext().GetNext());
	  
      return Remove (p.GetNext(),val);
	}
	*/
	
	public static void Main()
	{
		Console.WriteLine("Hello World");
		//int[] ar = {10,1,2,1,1,3,3,2,4,5,4,5,1,3,10};
		//int[] ar = {1,1,1,5,5,6,7,8,9,9,20,20,80,80};
		//int[] ar = {1,1,1,2,2,3,3,3};
		//int[] ar = {7,7,8,9,9};
		//int[] ar = {8,8,8,8,8,9,10,11,12,12};
		//int[] ar = {1,6,3,5,8,7,9};
		//int[] ar = {3,5,8};
		//Node<int> lst = BuildListFromAr(ar);
		//Show(lst);
		//lst = Remove1(lst,1);
		//lst = Dilul(lst);
		//lst = Dilul2(lst);
		
		//Dilul3(lst);
		//lst = FirstEvenLastOdd(lst);
		//Show(lst);
		int[] ar = {1,2,3,4,5};
		//string[] a = {"c","b","a","g","b","c"};
		string[] a = {"c"};
		BinNode<string> ls=BuildBnlistIntByAr(a);
		Console.WriteLine(IsPalindrome(ls));
		ShowBnlist(ls);
	}
}

// המחלקה מחסנית
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() +" ";
		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
{
    
    //ex3
    /*
    הפעולה מקבלת מצביע לשרשרת חוליות דו-כיוונית של מחרוזות
    ומחזירה אמת אם איברי השרשרת הם פולינדרום
    ושקר אחרת
    */
    public static bool IsPalindrome (BinNode<string> ls)
    {
        if (ls==null) return true;
        BinNode<string> first = ls;
        BinNode<string> last = ls;
        while (last.GetRight()!=null)
            last=last.GetRight();
        // הערה: אם אורך השרשרת אי-זוגי אז המצביעים ייפגשו באמצע הדרך ואז הלולאה תעצור
        // ואם אורך השרשרת זוגי אז המצביעים ייפגשו לאחר שעברו על כל הרשימה והגיעו לקצותיה ויעצרו בnull
        while (first!=last) 
        {
           if (!(first.GetValue().Equals(last.GetValue())))
               return false;
            Console.WriteLine(first.GetValue());
           first=first.GetRight();
           last=last.GetLeft();
        }
        return true;
    }
    
    
    
    
    //ex1
    /*
    הפעולה מקבלת מצביע לשרשרת חוליות לא ריקה של מספרים שלמים
    הפעולה משנה את סדר האיברים בשרשרת כך שכל האיברים הזוגיים יופיעו בראש השרשרת
    ואחריהם יופיעו כל האיברים האי-זוגיים
    הערה: יש לשמור על סדר פנימי של האיברים הזוגיים, וסדר פנימי של האיברים האי-זוגיים
    הפעולה מחזירה מצביע עדכני לשרשרת
    */
    public static Node<int> FirstEvenLastOdd (Node<int> ls)
    {
     if (ls==null) return ls;  
    
     Node<int> first = new Node<int> (-99,ls);
     ls = first;
        
     Node<int> prev = ls;
     
        Node<int> tmp=null;
    
     while (prev.GetNext()!=null)
         prev=prev.GetNext();
    
        
        Node<int> last = new Node<int> (-99);
        prev.SetNext(last);
        
        Node<int> p = last;   // המצביע נמצא כעת על האיבר האחרון ברשימה
        
        prev= ls ;
        
     while (prev.GetNext()!=last)
     {
         if(prev.GetNext().GetValue()%2!=0)
         {
            tmp = prev.GetNext();
            prev.SetNext(prev.GetNext().GetNext());
            tmp.SetNext(null);
            p.SetNext(tmp);
            p = p.GetNext();
         }
         else
            prev=prev.GetNext();
     }
        
   
        prev.SetNext(last.GetNext());
        last.SetNext(null);
        
     return ls.GetNext();  
​
​
    }
    
    
    
    public static Node<int> Dilul (Node<int> p)
   {
     if (p==null)   // שרשרת ריקה
        return p;    // נחזיר את פי כי בשרשרת ריקה אין כפולים
     if (!p.HasNext())   // אם השרשרת מכילה איבר אחד אז אין כפולים
       return p;
     p.SetNext(Remove1(p.GetNext(),p.GetValue()));
     // בעצם קוראים לפעולת עזר עם אותה שרשרת החל מהמקום של האיבר העוקב
    // של החוליה הנוכחית ובנוסף ערך לחיפוש והסרה אם קיים
    Node<int> temp = p;
    p = Dilul (p.GetNext());
    return temp;
   }
    
    /*
    ex2
    פעולה רקורסיבית המקבלת מצביע לשרשרת חוליות לא ריקה וממוינת
    ומדללת כפולים
    הפעולה מחזירה מצביע עדכני לשרשרת
    */
    public static Node<int> Dilul2 (Node<int> p)
   {
     if (p==null)   // שרשרת ריקה
        return p;    // נחזיר את פי כי בשרשרת ריקה אין כפולים
     if (!p.HasNext())   // אם השרשרת מכילה איבר אחד אז אין כפולים
       return p;
     Node<int> temp = p;
     if (p.GetValue()==p.GetNext().GetValue())
     {
       p.SetNext(p.GetNext().GetNext());
       p = Dilul2 (p);
     }
     else 
        p = Dilul2 (p.GetNext());
     return temp;
   }
    
   // אסור שרשרת ריקה כי אז תהייה שגיאה במקרה זה
    public static void Dilul3 (Node<int> p)
   {/*
     if (p==null)  
        return ;  
     if (!p.HasNext())   
       return ;*/
        if (p.HasNext()){
     if (p.GetValue()==p.GetNext().GetValue())
     {
       p.SetNext(p.GetNext().GetNext());
       Dilul3 (p);
     }
     else 
        Dilul3 (p.GetNext());}
   }
    /* התייחסתי כאן גם למקרה שהרשימה ריקה למרות שנתון שלא
public static void Dilul3 (Node<int> p)
   {
     if (p==null)  
        return ;  
     if (!p.HasNext())   
       return ;
        
     if (p.GetValue()==p.GetNext().GetValue())
     {
       p.SetNext(p.GetNext().GetNext());
       Dilul3 (p);
     }
     else 
        Dilul3 (p.GetNext());
   }
    */
    
    // בניית רשימה דו-כיוונית של מספרים שלמים
    // ל-ב-ד-ו-ק
    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<string> lst)
   {
    Console.Write("[");
    BinNode<string> pos = lst;
​
    while (pos != null)
    {
        Console.Write(pos.ToString());
        //if (pos.HasRight())
            //Console.Write(", ");
        pos = pos.GetRight();
    }
    Console.WriteLine("]");
 }
    
    // בניית שרשרת חוליות דו-כיוונית באמצעות מערך
    public static BinNode<string> BuildBnlistIntByAr (string[] ar)
    {
        BinNode<string> lst = new BinNode<string>(ar[0]);
        BinNode<string> pos = lst;
        BinNode<string> p;
    
        for (int i=1;i<ar.Length;i++)
        {
            p = new BinNode<string> (ar[i]);
            pos.SetRight(p);
            p.SetLeft(pos);
            pos=pos.GetRight();
       }
       return lst;
    }
    
    
    
    
    
    //בניית שרשרת חוליות (ללא חוליית דמה) של מספרים שלמים ממערך נתון
    // הפעולה מקבלת מערך של מספרים שלמים ומחזירה שרשרת חוליות עם ערכי המערך
    // תוך שמירה על סדר האיברים
    // הנחה חשובה: המערך לא ריק!!! הוא מכיל לפחות איבר אחד
    public static Node<int> BuildListFromAr (int[] ar)
    {
        Node<int> lst = new Node<int>(ar[0]);
        Node<int> pos = lst;
    
        for (int i=1;i<ar.Length;i++)
        {
            pos.SetNext(new Node<int>(ar[i]));
            pos=pos.GetNext();
       }
       return lst;
     }
    
    
    
    
    //  בניית שרשרת חוליות של מספרים שלמים ללא חוליית דמה
    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(", ");
            Console.Write(",");
        pos = pos.GetNext();
    }
    Console.WriteLine("]");
 }
    
    
    
    
    public static Node<int> Remove1 (Node<int> p, int val)
{
     if (p==null) return p;   
     Node<int> dummy = new Node<int> (-999,p);
     p=dummy;
     Node<int> prev = p;
     while (prev.GetNext()!=null)
     {
         if(prev.GetNext().GetValue()==val)
            prev.SetNext(prev.GetNext().GetNext());
         else
            prev=prev.GetNext();
     }
     return p.GetNext();
}
    
    public static Node<int> Remove (Node<int> p, int val)
{
     if (p==null) return p;   
       Node<int> dummy = new Node<int> (-999,p);
     p=dummy;
     Node<int> prev = p;
     while (prev.GetNext()!=null && prev.GetNext().GetValue()!=val)
         prev=prev.GetNext();
     if (prev.GetNext()!=null)
         if (prev.GetNext().GetValue()==val)
             prev.SetNext(prev.GetNext().GetNext());
     return p.GetNext();
}
    
    
    
    
    /*
    ניסיון לפתור באופן רקורסיבי אבל לא צלח
    public static Node<int> Remove (Node<int> p, int val)
    {
      if (p==null)              // הרשימה ריקה
        return p;   
      if (p.GetNext()==null)    // הרשימה מכילה איבר אחד בלבד
          if (p.GetValue()==val)      // ערך האיבר האחרון שווה לערך שיש להסיר
              return p.GetNext();
          else return Remove (p.GetNext(),val);    // ערך האיבר האחרון שונה מהערך שיש להסיר
      
      if (p.GetValue()!=val)
          return Remove (p.GetNext(),val);
      p.SetNext(p.GetNext().GetNext());
      
      return Remove (p.GetNext(),val);
    }
    */
    
    public static void Main()
    {
        Console.WriteLine("Hello World");
        //int[] ar = {10,1,2,1,1,3,3,2,4,5,4,5,1,3,10};
        //int[] ar = {1,1,1,5,5,6,7,8,9,9,20,20,80,80};
        //int[] ar = {1,1,1,2,2,3,3,3};
        //int[] ar = {7,7,8,9,9};
        //int[] ar = {8,8,8,8,8,9,10,11,12,12};
        //int[] ar = {1,6,3,5,8,7,9};
        //int[] ar = {3,5,8};
        //Node<int> lst = BuildListFromAr(ar);
        //Show(lst);
        //lst = Remove1(lst,1);
        //lst = Dilul(lst);
        //lst = Dilul2(lst);
        
        //Dilul3(lst);
        //lst = FirstEvenLastOdd(lst);
        //Show(lst);
        int[] ar = {1,2,3,4,5};
        //string[] a = {"c","b","a","g","b","c"};
        string[] a = {"c"};
        BinNode<string> ls=BuildBnlistIntByAr(a);
        Console.WriteLine(IsPalindrome(ls));
        ShowBnlist(ls);
    }
}
​
// המחלקה מחסנית
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() +" ";
        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() + "";
        
    }
    
}
​
​
​
​

UTC Start:(Diff) 10/20/2021 02:00:00, (Same) 10/20/2021 22:00:00
EST Start:(Diff) 10/19/2021 22:00:00, (Same) 10/20/2021 18:00:00
EST Range:(Diff) 10/18/2021 00:00:00 - 10/19/2021 23:59:59, (Same) 10/19/2021 00:00:00 - 10/20/2021 23:59:59

Cached Result
Last Run:	1:40:08 pm
Compile:	0.008s
Execute:	0.07s
Memory:	3.47Mb
CPU:	0.078s

View IL Code