算法有关问题.怎么用c#实现多项式相加

算法问题.如何用c#实现多项式相加.
最近想学习下关于算法的知识.可是看到例子大部分是c程序,如果用c#实现的话比较困难.不安全代码不太会,
用静态链表也不是很懂.向高手求助..

------解决方案--------------------
有固定输入模式没有?
------解决方案--------------------
C#链表容易
[code=c#]
public class List <T>
{
class Node <T>
{
T data;
public Node <T> next;
public Node(){this.next=null;this.data=defatule(T);}
}
Node <T> root;
public void Add(Node <T> n)
{
n.next=root;
root=n;
}
public IEnumerable <T> GetNodes()
{
Node <T> current = root;
if(current!=null)
{
yield return current;
current=current.next;
}
}
}
[/code]
楼主继续写,如何用链表具体实现,大家一起来学习.
------解决方案--------------------
要下班了,只能写个很简陋的,不过大概的思路不会错的
输出:2*x^0+4*x^1+2*x^2+2*x^3+2*x^5+
格式比较丑陋,楼主可以自己再控制一下输出

C# code


using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication3
{
    class Program
    {
        static void Main(string[] args)
        {
            //新建一个表达式和一些新项,并向表达式中插入这些项
            MyExpression me = new MyExpression();

            MyItem item1 = new MyItem(2, 0);
            MyItem item2 = new MyItem(2, 3);
            MyItem item3 = new MyItem(2, 1);
            MyItem item4 = new MyItem(2, 5);
            MyItem item5 = new MyItem(2, 2);

            me.InsertItem(item1);
            me.InsertItem(item2);
            me.InsertItem(item3);
            me.InsertItem(item3);
            me.InsertItem(item4);
            me.InsertItem(item5);

            foreach (MyItem mi in me.Expression)
            {
                Console.Write(mi.Num + "*x^" + mi.Exp + "+");
            }
            Console.ReadKey();
        }
    }

    /// <summary>
    /// 表达式类,用于存储所有的项
    /// </summary>
    class MyExpression
    {
        private List<MyItem> _expression;//用于存储表达式的项
        internal List<MyItem> Expression
        {
            get { return _expression; }
            set { _expression = value; }
        }
        /// <summary>
        /// 初始化一个表达式
        /// </summary>
        public MyExpression()
        {
            Expression = new List<MyItem>();
            MyItem item = new MyItem(0, 0);
            Expression.Add(item);
        }

        /// <summary>
        /// 插入一个项,根据指数来确定插入新项还是与原有项相加
        /// </summary>
        /// <param name="item"></param>
        public void InsertItem(MyItem item)
        {
            int length = Expression.Count;
            bool hasInserted = false;
            for (int i = 0; i < length; i++)
            {
                if (Expression[i] > item) //当前项指数比插入项大时,插到当前项的位置
                {
                    Expression.Insert(i, item);
                    hasInserted = true;
                    break;
                }
                if (Expression[i].Exp == item.Exp)//指数相等时相加
                {
                    Expression[i].Num += item.Num;
                    hasInserted = true;
                    break;
                }
            }
            if (!hasInserted)
            {
                Expression.Add(item);//指数比已知项都要大,插到表达式尾部
            }
        }

        protected void Sort()
        {
            this.Expression.Sort();
        }
    }

    /// <summary>
    /// 结点类,存储每一项
    /// </summary>
    class MyItem : IComparable<MyItem>
    {
        private int _num;//倍娄
        public int Num
        {
            get { return _num; }
            set { _num = value; }
        }

        private int _exp;//指数
        public int Exp
        {
            get { return _exp; }
            set { _exp = value; }
        }
        /// <summary>
        /// 给定值构造一个新项
        /// </summary>
        /// <param name="num"></param>
        /// <param name="exp"></param>
        public MyItem(int num, int exp)
        {
            Num = num;
            Exp = exp;
        }

        public bool Compare(MyItem left, MyItem right)
        {
            if (left.Exp > right.Exp)
            {
                return true;
            }
            else
                return false;
        }

        public int CompareTo(MyItem item)
        {
            return this.Exp.CompareTo(item.Exp);
        }

        public static bool operator >(MyItem left, MyItem right)
        {
            return left.Exp.CompareTo(right.Exp) > 0;
        }

        public static bool operator <(MyItem left, MyItem right)
        {
            return left.Exp.CompareTo(right.Exp) > 0;
        }

        //public object Clone()
        //{
        //    return new MyItem(this.Num,this.Exp);
        //}
    }
}

算法有关问题.怎么用c#实现多项式相加

相关推荐