算法：搜索

顺序搜索

• 在无序记录集中搜索关键词为K的记录在记录集中的位置
• 代码实现

        public static int SeqSearch(int[] Record,int Key) 
        {
            int i;
            for(i = 0;i < Record.Length; i++) 
            {
                if (Record[i] == Key)
                    break;
            }
            return (i == Record.Length) ? -1 : i;
        }
        static void Main(string[] args)
        {
            int[] nums = new int[] { 12, 23, 26, 37, 54, 60, 68, 75, 82, 96 };
            double[] nums1 = new double[] { 12.02, 23.20, 26.51, 37.54, 54.98, 60.2, 68.3, 75.4, 82.1, 96.2 };
            int res = Search.SeqSearch(nums, 26);
            int res1 = Search.SeqSearch(nums, 70);
            Console.WriteLine(res);
            Console.WriteLine(res1);
        }
//
2
-1

二分搜索

• 在有序记录集中，每次把待查区间中间位置记录的关键词与要查找的关键词进行比较，若不等则缩小搜索区间并在新的区间内重复上述过程，直到搜索成功或者搜索区间长度为0(搜索不成功)为止
  
• 代码实现

        public static int BinSearch<T>(T[] Record,T key)where T : IComparable<T> 
        {
            int left = 0;
            int right = Record.Length - 1;
            while(left <= right) 
            {
                int mid = (left + right) / 2;
                if (Record[mid].CompareTo(key) == 0)
                    return mid;
                if (Record[mid].CompareTo(key) < 0)
                    left = mid + 1;
                else
                    right = mid - 1;
            }
            return -1;
        }
        static void Main(string[] args)
        {
            int[] nums = new int[] { 12, 23, 26, 37, 54, 60, 68, 75, 82, 96 };
            double[] nums1 = new double[] { 12.02, 23.20, 26.51, 37.54, 54.98, 60.2, 68.3, 75.4, 82.1, 96.2 };
            int res = Search.BinSearch(nums, 26);
            Console.WriteLine(res);
        }
//
2

搜索二叉树

• 二叉搜索树中任意节点的关键字大于其左子树节点的关键字，小于其右子树节点的关键字，且左右子树也是一颗二叉搜索树
• 对于一颗二叉搜索树来说，对其做中序遍历是一个递增序列

ex1

//中序遍历的结果为
9 17 23 45 53 65 67 78 81 87

• 代码实现

    public class BinSearchTree
    {
        private BinTree<int> _binTree;

        public BinSearchTree(int value) //构造函数
        {
            BinTreeNode<int> root = new BinTreeNode<int>(value);
            _binTree = new BinTree<int>(root);
        }
        public void Insert(int value) //把值挂到二叉树上
        {
            BinTreeNode<int> p = _binTree.Root;

            while (true) 
            {
                if (p.Data == value)//挂主关键词,一样的话忽略
                    return;
                if (value > p.Data)
                {
                    if (p.RightChild == null)
                    {
                        p.RightChild = new BinTreeNode<int>(value);
                        return;
                    }
                    else
                    {
                        p = p.RightChild;
                    }
                }
                else
                {
                    if(p.LeftChild == null) 
                    {
                        p.LeftChild = new BinTreeNode<int>(value);
                        return;
                    }
                    else 
                    {
                        p = p.LeftChild;
                    }

                }
            }
        }
        public string Ascend() 
        {
            return _binTree.MidOrderTraversal();
        }
        public BinTreeNode<int> Search(int value) 
        {
            BinTreeNode<int> current = _binTree.Root;
            while(current != null) 
            {
                if (current.Data == value)
                    break;
                else if(current.Data < value) 
                {
                    current = current.RightChild;
                }
                else 
                {
                    current = current.LeftChild;
                }
            }
            return current;
        }
        public void Delete(int value) 
        {
            BinTreeNode<int> current = Search(value);
            if (current == null) return;//要摘下的节点不在搜索二叉树

            BinTreeNode<int> parent = _binTree.GetParent(current);//找到父亲节点

            if(current.LeftChild == null) 
            {
                if(parent == null) //删除的节点是根节点
                {
                    _binTree.Root = current.RightChild;
                }
                else if(parent.LeftChild == current) 
                {
                    parent.LeftChild = current.RightChild;
                }
                else 
                {
                    parent.RightChild = current.RightChild;
                }
            }
            else 
            {
                BinTreeNode<int> temp = current.LeftChild;//左孩子不为空找到左子树中的最大的节点
                while (temp.RightChild != null)
                    temp = temp.RightChild;
                
                temp.RightChild = current.RightChild;//把删除节点的右子树挂上
                if(parent == null) 
                {
                    _binTree.Root = current.LeftChild;
                }
                else if(parent.LeftChild == current) 
                {
                    parent.LeftChild = current.LeftChild;
                }
                else 
                {
                    parent.RightChild = current.LeftChild;
                }
            }
        }   
        
    }

• 利用中序遍历，观察搜索二叉树Insert方法是否正确(中序遍历在树的部分介绍过了)

        static void Main(string[] args)
        {
            BinSearchTree tree = new BinSearchTree(53);
            tree.Insert(65);
            tree.Insert(17);
            tree.Insert(87);
            tree.Insert(9);
            tree.Insert(81);
            tree.Insert(45);
            tree.Insert(23);
            tree.Insert(67);
            BinTreeNode<int> r = tree.Search(45);
            BinTreeNode<int> r2 = tree.Search(25);
            string midOrder = tree.Ascend();
            Console.WriteLine(midOrder);
            
        }
//9 17 23 45 53 65 67 78 81 87