博客
关于我
强烈建议你试试无所不能的chatGPT,快点击我
C#编写数学集合
阅读量:7100 次
发布时间:2019-06-28

本文共 4889 字,大约阅读时间需要 16 分钟。

 

using System;

using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace 集合

{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)

        {

            string[] strsA = (textBox1.Text+",空集").Split(',');
            string[] strsB = (textBox2.Text + ",空集").Split(',');

            textBox3.Text = 运算工厂(strsA, strsB);

        }

        private void button2_Click(object sender, EventArgs e)

        {
            ;
            string txtC = textBox2.Text;

            textBox2.Text = textBox1.Text;

            textBox1.Text = txtC;

        }

 

        /// <summary>

        /// 工厂
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        //-差集
        //∪并集
        //∩交集
        //∈属于
        //φ空集
        //∉不属于
        //=等于
        //⊆包含
        //⊂真包含
        //P()幂集
        //对称差
        public string 运算工厂(string[] strsA, string[] strsB)
        {
            string str = "请选择";

            switch (comboBox1.Text)

            {
                case "-差集":
                    {
                        str = showstrsC(差集(strsA, strsB));
                        break;
                    }
                case "∪并集":
                    {
                        str = showstrsC(并集(strsA, strsB));
                        break;
                    }
                case "∩交集":
                    {
                        str = showstrsC(交集(strsA, strsB));
                        break;
                    }
                case "φ空集":
                    {
                        str = "集合A是空集吗:" + (textBox1.Text == "").ToString();
                        break;
                    }
                case "∉不属于":
                    {
                        str = "B不属于A的集合吗:" + (!包含(strsA, strsB)).ToString(); ;
                        break;
                    }
                case "=等于":
                    {
                        return (比较数组是否相同(strsA, strsB)).ToString();
                    }
                case "⊆包含":
                    {
                        str = "A包含B吗?" + (包含(strsA, strsB)).ToString();
                        break;
                    }
                case "⊂真包含":
                    {
                        str = "A真包含B:" + 真包含(strsA, strsB);

                        break;

                    }
                case "P()幂集":
                    {
                        str = "集合A的幂集是:" + 幂集(strsA).ToString();
                        break;
                    }
                case "对称差":
                    {
                        str = showstrsC(对称差(strsA, strsB));
                        break;
                    }
            }
            return str;

        }

        /// <summary>
        /// (A-B)U(B-A) 或者(AUB)-(A∩B)
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        public string[] 对称差(string[] strsA, string[] strsB)
        {
            return 并集(差集(strsA, strsB), 差集(strsB, strsA));
        }

        /// <summary>
        /// 在A的基础上,除去A有B的部分
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        public string[] 差集(string[] strsA, string[] strsB)
        {
            string[] strsC = new string[strsA.Length + strsB.Length + 1];
            int strsCi = 0;
            for (int i = 0; i < strsA.Length; i++)
            {
                for (int j = 0; j < strsB.Length; j++)
                {
                    if (strsB[j] != strsA[i])
                    {
                        strsC[strsCi] = strsA[i];
                        strsCi++;
                    }

                }

            }
            return strsC;
        }

        /// <summary>

        /// A!=B,并且B 包含 A
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        public bool 真包含(string[] strsA, string[] strsB)
        {
            if (strsB == null)
            {
                return true;
            }
            if (!比较数组是否相同(strsA, strsB))
            {
                if (包含(strsA, strsB))
                {
                    return true;
                }
                return false;
            }
            return false;
        }

        /// <summary>

        /// 所有元素合并,不重复
        /// </summary>
        /// <param name="?"></param>
        /// <returns></returns>
        public string[] 并集(string[] strsA, string[] strsB)
        {
            int index = 0;
            string[] strsC = new string[strsA.Length + strsB.Length];
            for (int i = 0; i < strsA.Length; i++)
            {
                strsC[index] = strsA[i];
                index++;
            }

            for (int j = 0; j < strsB.Length; j++)

            {
                strsC[index] = strsB[j];
                index++;
            }

            return strsC;

        }

        /// <summary>

        /// 在A中包含B.就是说B有的东西A都有
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        public bool 包含(string[] strsA, string[] strsB)
        {
            if (strsB == null)
            {
                return true;
            }
            bool baohan = true;
            for (int j = 0; j < strsB.Length; j++)
            {
                bool temp = false;
                for (int i = 0; i < strsA.Length; i++)
                {
                    if (strsB[j] == strsA[i])
                    {
                        temp = true;
                    }

                }

                if (temp == true)
                {

                }

                else
                {
                    return false;
                }
            }
            return baohan;
        }

        /// <summary>
        /// 循环每一个元素
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        public bool 比较数组是否相同(string[] strsA, string[] strsB)
        {
            for (int i = 0; i < strsA.Length; i++)
            {
                bool have = false; ;
                for (int j = 0; j < strsB.Length; j++)
                {
                    if (strsA[i] == strsB[j])
                    {
                    have = true;
                    }
 
                }
                if (have == false)
                {
                    return false;
                }
            }
            return true;
        }

        /// <summary>

        /// 2^(数组个数+1)
        /// </summary>
        /// <param name="strsA"></param>
        /// <returns></returns>
        public int 幂集(string[] strsA)
        {
            if (strsA[0] != "")
            {
                return Convert.ToInt32((Math.Pow(((double)2), (double)strsA.Length + 1)));
            }
            else
            {
                return 1;
            }

        }

        /// <summary>

        /// 在A和B中共有的元素
        /// </summary>
        /// <param name="strsA"></param>
        /// <param name="strsB"></param>
        /// <returns></returns>
        public string[] 交集(string[] strsA, string[] strsB)
        {
            string[] strsC = new string[Math.Min(strsA.Length, strsB.Length)];
            int index = 0;
            for (int i = 0; i < strsA.Length; i++)
            {
                for (int j = 0; j < strsB.Length; j++)
                {
                    if (strsA[i] == strsB[j])
                    {
                        strsC[index] = strsA[i];
                        index++;
                    }
                }
            }
            return strsC;
        }

 

 

        /// <summary>

        /// 将数组转化为单行文本
        /// </summary>
        /// <returns></returns>
        public string showstrsC(string[] strsC)
        {
            return string.Join(";", strsC);
        }

        / <summary>
        / 清除重复
        / </summary>
        / <returns></returns>
        //public string[] delectRepeat(string[] strsC)
        //{

        //}

    }

}

 

//存在问题

//1.这里是否只能自己写对比方法吗?
//2.集合里都会会有一个空集怎样解决
//3.自动长度的数组
//4.不能消除重复

转载于:https://www.cnblogs.com/zihao/archive/2012/03/18/2404406.html

你可能感兴趣的文章
配置ubuntu的mac主题
查看>>
makefile文件的两种常用书写格式(搜索路径式+递归式)
查看>>
eclipse 快捷键大全,eclipse查找类,文件,添加注释
查看>>
Android4.0蓝牙使能的详细解析
查看>>
Freemarker常用技巧(三)
查看>>
Java Gradle入门指南之依赖管理(添加依赖、仓库、版本冲突) (转)
查看>>
使用反射生成并操作对象
查看>>
开源jabber(XMPP)架设内部即时通讯服务的解决方案
查看>>
行为统计学第二章知识总结(未完)
查看>>
关闭注册表编辑器,重新启动计算机后生效。这样资源管理器重启后就不会自动重启了。...
查看>>
Knockout应用开发指南(完整版) 目录索引
查看>>
A example that using JQuery clone
查看>>
随机梯度下降(Stochastic gradient descent)和 批量梯度下降(Batch gradient descent )的公式对比、实现对比...
查看>>
Android 使用JSON格式与服务器交互 中文乱码问题解决
查看>>
_DataStructure_C_Impl:链串
查看>>
openvas
查看>>
SecureCRT同时向多个终端发送命令
查看>>
【IntelliJ】IntelliJ IDEA常用设置及快捷键以及自定义Live templates
查看>>
indexOf 和 lastIndexOf 的区别
查看>>
spring boot整合activemq消息中间件
查看>>