c# window 树
2017-02-27 19:59:30 Godsight 阅读数 190

写了一个函数 可以让点击button1或button2时运行同一个函数

private void A(object sender,EventArgs e)
        {
            if((Button)(sender)==button1)
            {
                label1.Text = "我是按钮1";
            }
            else
            {
                label1.Text = "我是按钮2";
            }
        }

 #region Windows 窗体设计器生成的代码

        /// <summary>
        /// 设计器支持所需的方法 - 不要
        /// 使用代码编辑器修改此方法的内容。
        /// </summary>
        private void InitializeComponent()
        {
            this.button1 = new System.Windows.Forms.Button();
            this.button2 = new System.Windows.Forms.Button();
            this.label1 = new System.Windows.Forms.Label();
            this.SuspendLayout();
            // 
            // button1
            // 
            this.button1.Location = new System.Drawing.Point(44, 58);
            this.button1.Name = "button1";
            this.button1.Size = new System.Drawing.Size(127, 42);
            this.button1.TabIndex = 0;
            this.button1.Text = "button1";
            this.button1.UseVisualStyleBackColor = true;
            this.button1.Click += new System.EventHandler(this.A);//这是自己添加的
            // 
            // button2
            // 
            this.button2.Location = new System.Drawing.Point(295, 60);
            this.button2.Name = "button2";
            this.button2.Size = new System.Drawing.Size(128, 39);
            this.button2.TabIndex = 1;
            this.button2.Text = "button2";
            this.button2.UseVisualStyleBackColor = true;
            this.button2.Click += new System.EventHandler(this.A);//这是自己添加的


2018-08-15 13:57:07 qq_41926120 阅读数 219

打印信息

弹出提示框

MessageBox.Show("hello");

打印输出信息

System.Diagnostics.Debug.WriteLine("hello");

注释函数

///<summary>
///函数信息
///</summary>

 

2018-06-07 10:47:22 qq_36981814 阅读数 1897

C#数据结构——树的实现

树的简单说明:树型结构是一类重要的非线性数据结构,其中以树和二叉树最为常用。直观看来,树是以分支关系定义的层次结构。树结构在客观世界中广泛存在,如人类社会的族谱和各种社会组织机构都可以用树来形象的表示。树在计算机领域中也得到了广泛的应用,如在编译程序中,可以用树来表示源程序的语法结构。又如在数据库系统中,树型结构也是信息的重要组织形式之一。

关键技术

树的抽象数据类型定义包含树的结构定义和基本操作,下面分别进行介绍。
(1)结构定义
树是n(n≥1)个节点的有限集,在任意一棵非空树中,都应该符合以下条件:

  • 有且仅有一个特定的节点称为根的节点;
  • 当n>1时,其余节点可分为m个互不相交的有限集,其中每一个集合本身又是一棵树,并且称为根的子树。

(2)基本操作
树的基本操作主要包括:构造空树、销毁树、清空树、求树的深度、访问结点、插入子树和删除子树等。

设计过程

(1)打开Visual Studio 开发环境,新建一个类库项目,命名为Arbor。
(2)将“Class1.cs”文件重命名为“Ctree.cs”。
(3)程序主要代码如下:

class TravelBinTree : ITravelBinTree, IInsertBinTree
{
    const int INIT_TREE_SIZE = 20;
    private IBinNode tree;
    private BinNodeLine head;    //线索化后的头指针
    private IBinNode prenode;    //指向最近访问过的前驱节点
    public TravelBinTree()
    {
        tree = new BinNodePtr();
    }
    public TravelBinTree(IBinNode INode)
    {
        tree = INode;
    }
    /// <summary>
    /// 先序遍历树,用非递归算法实现
    /// </summary>
    /// <remarks>非递归实现</remarks>
    public void PreOrderTravel()
    {
        IBinNode temptree;
        Stack stk = new Stack(INIT_TREE_SIZE);
        if (tree == null)
            throw (new InvalidOperationException("访问的树为空"));
        temptree = tree;
        stk.Push(tree);
        while (stk.Count != 0)
        {
            while (temptree != null)
            {
                Print(temptree);
                stk.Push(temptree.Left);
                temptree = temptree.Left;
            }
            stk.Pop(); // 空指针退栈
            if (stk.Count != 0)
            {
                temptree = (IBinNode)stk.Pop();
                stk.Push(temptree.Right);
                temptree = temptree.Right;
            }
        }
    }
    public void InOrderTravel()
    {
        InOrderTravel(tree);
    }
    private void InOrderTravel(IBinNode t)
    {
        if (t == null) return;
        InOrderTravel(t.Left);
        Print(t);
        InOrderTravel(t.Right);
    }
    public void RevOrderTravel()
    {
        RevOrderTravel(tree);
    }
    private void RevOrderTravel(IBinNode t)
    {
        if (t == null) return;
        RevOrderTravel(t.Left);
        RevOrderTravel(t.Right);
        Print(t);
    }
    public void Print(IBinNode t)
    {
        Console.Write(t.Element + ",");
    }
    public void Insert(IBinNode node, Position pos)
    {
        if (node == null)
            throw (new InvalidOperationException("不能将空节点插入树"));
        switch (pos)
        {
            case Position.LEFT: tree.Left = node; break;
            case Position.RIGHT: tree.Right = node; break;
        }
    }
    /// <summary>
    /// 按照先序遍历顺序遍历树
    /// </summary>
    public void TreeBuilder()
    {
        Stack stk = new Stack(INIT_TREE_SIZE);
        stk.Push(tree);
        Position pos;
        string para;
        pos = Position.LEFT;
        IBinNode baby, temp;
        while (true)
        {
            para = Console.ReadLine();
            if (para == "")
            {
                if (pos == Position.RIGHT)
                {
                    stk.Pop();
                    while (stk.Count != 0 && ((IBinNode)stk.Peek()).Right != null)
                        stk.Pop();
                    if (stk.Count == 0) break;
                }
                else
                    pos = Position.RIGHT;
            }
            else
            {
                // if (tree.GetType().Equals(baby) == true)
                baby = new BinNodePtr(para);
                temp = (IBinNode)stk.Peek();
                if (pos == Position.LEFT)
                    temp.Left = baby;
                else
                    temp.Right = baby;
                pos = Position.LEFT;
                stk.Push(baby);
            }
        }
    }
    /// <summary>
    /// 中序线索化
    /// </summary>
    public void InOrderThreading()
    {
        head = new BinNodeLine("");
        head.RTag = Tag.THREAD;
        head.Right = head;
        if (tree == null) head.Left = head;
        else
        {
            head.Left = tree; prenode = head;
        }
    }
    /// <summary>
    /// 中序线索化的递归实现
    /// </summary>
    /// <param name="t"></param>
    private void InThreading(IBinNode t)
    {
        if (t == null)
            return;
        else
        {
            InThreading(t.Left);
        }
    }
}

技巧与心得

树在C#中使用TreeView控件来表示,TreeView控件,又称为树视图控件,它可以为用户显示节点层次结构,而每个节点又可以包含子节点,包含子节点的节点叫父节点,其效果就像在Windows操作系统的Windows资源管理器功能的左窗口中显示文件和文件夹一样。

2017-12-11 20:33:17 miku_weilai 阅读数 195

树结构

1.树的定义 树是有n(n>=0 )个结点的有限集。
2.树只有一个根节点(Root),从根节点以外扩散的的集合可以成为根的子树(SubTree)。
3.b,c是a的左 右子节点。a又成为b,c的父节点。
4.度:子节点的个数。
5.树的层次:这个树有四层。 最大层是树的深度。

树的存储结构

1.双亲表示法  data parent 
2.孩子表示  data child1 child2
3. 孩子兄弟表示法 data firstchild rightslib

二叉树

1、二叉树是一种特殊的树,每个结点最多有两个子结点。
2.根节点的左右子树。


2.满二叉树 :除了最后一层 其他的层都有两个结点,满了状态。
3.完全二叉树 最后一层可以有空,但是 有顺序的空。
4.非完全二叉树,10位置是空的,完全二叉树必须 最后一层可以是8, 8,9 8,9,10 不能断开的空

二叉树的存储

1.顺序存储


存储的结果实 a,b,c,d,e,f,g,h,i,j 从上到到下从左到右的方式向看漫画一样。
2.遍历的方式
1, 前序遍历  口诀:先根再左右子结点。       a 找 b,b有左右子结点,b,再找d,d是根,再找h,i,j依次找。
2,中序遍历   左根右。  a有子树,找b,找d,HDIBJEAFCG
3.后序遍历 左右根。 HID JEBFGCA
4.层序遍历 就是abc。。一层从左到右。

2.代码实现

顺序存储只适合完全二叉树
  public class BiTree<T>
    {
        private T[] arr;//存放数据
        private int capacity;//储存的容量
        private int count = 0;
        public BiTree(int count)
        {
            capacity = count;
            arr=new T[count];
        }

        public void AddData(T a)
        {
            arr[count] = a;
            count++;
            if (count >= capacity) return;
        }

       public void FisrtTraversal(int n)
       {
           //首先判断是否遍历完
           int num = n + 1;
           if(num>arr.Length) return;
           Console.Write(arr[n]+" ");
           int leftchild = 2*num;
           int rightchild = 2*num+1;
           FisrtTraversal(leftchild-1);
           FisrtTraversal(rightchild-1);
       }
       public void MiddleTraversal(int n){
           //首先判断是否遍历完
           int num = n + 1;
           if (num > arr.Length) return;
           int leftchild = 2 * num;
           int rightchild = 2 * num + 1;
           MiddleTraversal(leftchild-1);
           Console.Write(arr[n] + " ");
           MiddleTraversal(rightchild-1);
       }
       public void LastTraversal(int n)
       {
           //首先判断是否遍历完
           int num = n + 1;
           if (num > arr.Length) return;
           int leftchild = 2 * num;
           int rightchild = 2 * num + 1;
           LastTraversal(leftchild-1);
           LastTraversal(rightchild-1);
           Console.Write(arr[n] + " ");
       }
       public void LayerTraversal(int n)
       {
           //首先判断是否遍历完
           
           if (n >= arr.Length) return;
           Console.Write(arr[n]+" ");
           LayerTraversal(n+1);
       }  
  static void Main(string[] args)
        {
            char[] arr = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'};
            BiTree<char> tree=new BiTree<char>(10);
            for (int i = 0; i <arr.Length; i++)
            {
                tree.AddData(arr[i]);
            }
            Console.WriteLine("四种方法依次输出");
            tree.FisrtTraversal(0);
            Console.WriteLine();
            tree.MiddleTraversal(0);
            Console.WriteLine();
            tree.LastTraversal(0);
            Console.WriteLine();
            tree.LayerTraversal(0);
            Console.ReadKey();
        }
我们如何理解递归,函数运行在主线程中,是从上到下执行,中序遍历,mid(7)输出mid(14)中断了,执行下一句输出(arr[7]), a(),b() b要等到a返回结果再执行b,协成和多线程就能并行工作。

二叉排序树

左子树的结点小于根结点,右子树的结点大于根结点

 class BSNode
    {
        public BSNode LeftChild { get; set; }
        public BSNode RightChild { get; set; }
        public BSNode Parent { get; set; }
        public int Data { get; set; }
        public BSNode()
        {
        }
        public BSNode(int item)
        {
            this.Data = item;
        }
    }


 class BSTree
    {
        BSNode root = null;

        //添加数据
        public void Add(int item)
        {
            BSNode newNode = new BSNode(item);
            if (root == null)
            {
                root = newNode;
            }
            else
            {
                BSNode temp = root;
                while (true)
                {
                    if (item >= temp.Data)//放在temp的右边
                    {
                        if (temp.RightChild == null)
                        {
                            temp.RightChild = newNode;
                            newNode.Parent = temp;
                            break;
                        }
                        else
                        {
                            temp = temp.RightChild;
                        }
                    }
                    else//放在temp的左边
                    {
                        if (temp.LeftChild == null)
                        {
                            temp.LeftChild = newNode;
                            newNode.Parent = temp;
                            break;
                        }
                        else
                        {
                            temp = temp.LeftChild;
                        }
                    }
                }
            }
        }

        public void MiddleTraversal()
        {
            MiddleTraversal(root);
        }
        private void MiddleTraversal(BSNode node)
        {
            if (node == null) return;

            MiddleTraversal(node.LeftChild);
            Console.Write(node.Data + " ");
            MiddleTraversal(node.RightChild);

        }
        public bool Find(int item)
        {
            //return Find(item, root);

            BSNode temp = root;
            while (true)
            {
                if (temp == null) return false;
                if (temp.Data == item) return true;
                if (item > temp.Data)
                    temp = temp.RightChild;
                else
                    temp = temp.LeftChild;
            }
        }


        private bool Find(int item,BSNode node)
        {
            if (node == null) return false;
            if (node.Data == item)
            {
                return true;
            }
            else
            {
                //if (Find(item, node.LeftChild))
                //{
                //    return true;
                //}
                //if (Find(item, node.RightChild))
                //{
                //    return true;
                //}
                if (item > node.Data)
                {
                    return Find(item, node.RightChild);
                }
                else
                {
                    return Find(item, node.LeftChild);
                }
            }
        }

        public bool Delete(int item)
        {
            BSNode temp = root;
            while (true)
            {
                if (temp == null) return false;
                if (temp.Data == item)
                {
                    Delete(temp);
                    return true;
                }
                if (item > temp.Data)
                    temp = temp.RightChild;
                else
                    temp = temp.LeftChild;
            }
        }
        public void Delete(BSNode node)
        {
            if (node.LeftChild == null && node.RightChild == null)
            {
                if (node.Parent == null)
                {
                    root = null;
                }else if (node.Parent.LeftChild == node)
                {
                    node.Parent.LeftChild = null;
                }
                else if(node.Parent.RightChild==node)
                {
                    node.Parent.RightChild = null;
                }
                return;
            }
            if (node.LeftChild == null && node.RightChild != null)
            {
                node.Data = node.RightChild.Data;
                node.RightChild = null;
                return;
            }
            if (node.LeftChild != null && node.RightChild == null)
            {
                node.Data = node.LeftChild.Data;
                node.LeftChild = null;
                return;
            }

            BSNode temp = node.RightChild;
            while (true)
            {
                if (temp.LeftChild != null)
                {
                    temp = temp.LeftChild;
                }
                else
                {
                    break;
                }
            }
            node.Data = temp.Data;
            Delete(temp);
        }
    }



2010-10-27 15:53:00 leapenemc0907 阅读数 216

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Diagnostics;
using System.Linq;
using System.ServiceProcess;
using System.Text;
using System.IO;

namespace WindowsService1
{
    public partial class Service1 : ServiceBase
    {
        private string fileName = @"C:/发布/log.txt";
        private System.Timers.Timer _timer;

        public Service1()
        {
            MakeFile(fileName, "服务正在初始化");
            InitializeComponent();
        }

        protected override void OnStart(string[] args)
        {
            MakeFile(fileName, "服务开始启动");

            _timer = new System.Timers.Timer();
            _timer.Interval = 2000;
            _timer.Elapsed += new System.Timers.ElapsedEventHandler(_timer_Elapsed);
            _timer.Start();
        }

        void _timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e)
        {
            MakeFile(fileName, "现在时间是:" + DateTime.Now);
        }

        protected override void OnStop()
        {
            MakeFile(fileName, "服务已经结束");
        }


        public static void MakeFile(string FileName, string Content)
        {
            System.IO.StreamWriter sw = new System.IO.StreamWriter(FileName, true, System.Text.Encoding.GetEncoding("gb2312"));
            try
            {
                sw.WriteLine(Content);
                sw.Flush();
            }
            finally
            {
                if (sw != null) sw.Close();
            }
        }
    }
}

 

 

 部署:

 

 1.设计模式下右键-->添加安装程序-->设置serviceProcessInstaller1的Account为LocalSystem

 

2.设置serviceInstaller1的StartType为Automatic

 

 3.编译

 

4.在命令模式下执行:%systemroot%/microsoft.net/framework/v2.0.50727/installUtil.exe D:/项目目录/bin/Debug/可执行文件名.exe

 

 

 

删除服务: 

 

 使用SC命令

sc delete 服务名

c#树控件

阅读数 371

usingSystem;usingSystem.ComponentModel;usingSystem.Drawing;usingSystem.Windows.Forms;namespaceUserControls{//////TreeViewComboBox的摘要说明。///publicclassTr

博文 来自: winddai

C#结束进程树

阅读数 973

ManagementObjectSearcher在System.Management命名空间中。publicstaticclassProcessEx  {    ///    ///结束进程树    ///    ///父进程    publicstaticvoidKillProcessTree(this

博文 来自: id735161977

C#写的树

阅读数 901

       C#的确是一个很好的面向对象语言,我看《数据结构(第二版)》那本书应该出本用C#描述的版本。下面是我用C#写的一棵树。先用接口把节点做了抽象定义,这样在实现遍历,插入等操作的时候只对接口进行操作。在程序中,我尽量使用C#的特性,如接口,属性,玫举,这样代码虽然看起来比较冗长,但是,当代码越来越长的时候,你就会从中看到优点,因为合理的结构让你永远思路清晰。这课树我只能算写了一个开

博文 来自: Tisten

C#创建Window Service

阅读数 390

一、准备条件:安装好的VS2010 二、创建windowservice项目,取项目名为WinService_Test三、在新建好的项目中,找到Service1.cs,右击-->ViewCode(查看源代码)。在源代码中,OnStart方法是在服务启动时执行的,可以在这里编写服务要执行的业务逻辑代码;OnStop方法是在服务停止时执行的,一般在这里编写终止服务线程或停

博文 来自: LanSeTianKong12

C# 创建window服务

阅读数 2926

usingSystem;usingSystem.Threading;usingSystem.ServiceProcess;usingSystem.Collections;usingSystem.Configuration.Install;usingSystem.Diagnostics;usingSystem.Collections.Generic;usingSystem.ComponentModel;usingSystem.Data;usin

博文 来自: fengyarongaa
没有更多推荐了,返回首页