狠狠色丁香婷婷综合尤物/久久精品综合一区二区三区/中国有色金属学报/国产日韩欧美在线观看 - 国产一区二区三区四区五区tv

C#二分查找算法

簡介

二分查找算法是一種在有序數組中查找特定元素的搜索算法。

• 詳細文章描述： https://mp.weixin.qq.com/s/uCuqv0zOI0ZsF48Q1LoCsQ

代碼實現

public class 二分查找算法
    {
        /// <summary>
        /// 二分查找算法
        /// </summary>
        /// <param name="arr">arr是已排序的數組</param>
        /// <param name="target">target是要查找的目標值</param>
        /// <returns>目標值在數組中的索引，如果未找到則返回-1</returns>
        public static int BinarySearch(int[] arr, int target)
        {
            int left = 0; // 定義左指針
            int right = arr.Length - 1; // 定義右指針
            while (left <= right)
            {
                // 計算中間元素的索引
                int mid = left + (right - left) / 2;
                if (arr[mid] == target)
                {
                    // 如果中間元素等于目標值
                    return mid; // 查找成功，返回索引
                }
                else if (arr[mid] < target)
                {
                    // 如果目標值小于中間元素，則在左半部分查找
                    left = mid + 1;
                }
                else
                {
                    // 如果目標值大于中間元素，則在右半部分查找
                    right = mid - 1;
                }
            }
            // 未找到 target，返回-1
            return -1;
        }
        public static void BinarySearchRun()
        {
            int[] arr = { 1, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59 }; //注意：這里的數組是已排序的數組
            int target = 31; //需要要查找的目標值
            int result = BinarySearch(arr, target); //調用二分查找方法
            if (result == -1)
            {
                Console.WriteLine("元素未找到");
            }
            else
            {
                Console.WriteLine($"元素找到，索引為：{result}，值為：{arr[result]}");
            }
        }
    }

C#線性查找算法

簡介

線性查找算法是一種簡單的查找算法，用于在一個數組或列表中查找一個特定的元素。它從數組的第一個元素開始，逐個檢查每個元素，直到找到所需的元素或搜索完整個數組。線性查找的時間復雜度為O(n)，其中n是數組中的元素數量。

• 詳細文章描述： https://mp.weixin.qq.com/s/VKC5lEYCL7SHieNMaPOE3A

代碼實現

  public static void LinearSearchRun()
        {
            int[] arr = { 2, 3, 4, 10, 40, 50, 100, 77, 88, 99 };
            int target = 100;
            int result = LinearSearch(arr, target);
            // 輸出結果
            if (result == -1)
            {
                Console.WriteLine("元素未找到");
            }
            else
            {
                Console.WriteLine($"元素在索引 {result} 處找到，index = {result}");
            }
        }
        /// <summary>
        /// 線性查找函數
        /// </summary>
        /// <param name="arr">arr</param>
        /// <param name="target">target</param>
        /// <returns></returns>
        public static int LinearSearch(int[] arr, int target)
        {
            // 遍歷數組
            for (int i = 0; i < arr.Length; i++)
            {
                // 如果找到目標值，返回其索引
                if (arr[i] == target)
                {
                    return i;
                }
            }
            // 如果沒有找到，則返回-1
            return -1;
        }

C#二叉搜索樹算法

簡介

二叉搜索樹（Binary Search Tree，簡稱BST）是一種節點有序排列的二叉樹數據結構。

• 詳細文章描述： https://mp.weixin.qq.com/s/qs8CZzjtmyXkQhkRWmqllA

代碼實現

namespace HelloDotNetGuide.常見算法
{
    public class 二叉搜索樹算法
    {
        public static void BinarySearchTreeRun()
        {
            var bst = new BinarySearchTree();
            // 插入一些值到樹中
            bst.Insert(50);
            bst.Insert(30);
            bst.Insert(20);
            bst.Insert(40);
            bst.Insert(70);
            bst.Insert(60);
            bst.Insert(80);
            bst.Insert(750);
            Console.WriteLine("中序遍歷（打印有序數組）：");
            bst.InorderTraversal();
            Console.WriteLine("\n");
            // 查找某些值
            Console.WriteLine("Search for 40: " + bst.Search(40)); // 輸出: True
            Console.WriteLine("Search for 25: " + bst.Search(25)); // 輸出: False
            Console.WriteLine("\n");
            // 刪除某個值
            bst.Delete(50);
            Console.WriteLine("刪除50后：");
            bst.InorderTraversal();
        }
    }
    /// <summary>
    /// 定義二叉搜索樹的節點結構
    /// </summary>
    public class TreeNode
    {
        public int Value;
        public TreeNode Left;
        public TreeNode Right;
        public TreeNode(int value)
        {
            Value = value;
            Left = null;
            Right = null;
        }
    }
    /// <summary>
    /// 定義二叉搜索樹類
    /// </summary>
    public class BinarySearchTree
    {
        private TreeNode root;
        public BinarySearchTree()
        {
            root = null;
        }
        #region 插入節點
        /// <summary>
        /// 插入新值到二叉搜索樹中
        /// </summary>
        /// <param name="value">value</param>
        public void Insert(int value)
        {
            if (root == null)
            {
                root = new TreeNode(value);
            }
            else
            {
                InsertRec(root, value);
            }
        }
        private void InsertRec(TreeNode node, int value)
        {
            if (value < node.Value)
            {
                if (node.Left == null)
                {
                    node.Left = new TreeNode(value);
                }
                else
                {
                    InsertRec(node.Left, value);
                }
            }
            else if (value > node.Value)
            {
                if (node.Right == null)
                {
                    node.Right = new TreeNode(value);
                }
                else
                {
                    InsertRec(node.Right, value);
                }
            }
            else
            {
                //值已經存在于樹中，不再插入
                return;
            }
        }
        #endregion
        #region 查找節點
        /// <summary>
        /// 查找某個值是否存在于二叉搜索樹中
        /// </summary>
        /// <param name="value">value</param>
        /// <returns></returns>
        public bool Search(int value)
        {
            return SearchRec(root, value);
        }
        private bool SearchRec(TreeNode node, int value)
        {
            // 如果當前節點為空，表示未找到目標值
            if (node == null)
            {
                return false;
            }
            // 如果找到目標值，返回true
            if (node.Value == value)
            {
                return true;
            }
            // 遞歸查找左子樹或右子樹
            if (value < node.Value)
            {
                return SearchRec(node.Left, value);
            }
            else
            {
                return SearchRec(node.Right, value);
            }
        }
        #endregion
        #region 中序遍歷
        /// <summary>
        /// 中序遍歷（打印有序數組）
        /// </summary>
        public void InorderTraversal()
        {
            InorderTraversalRec(root);
        }
        private void InorderTraversalRec(TreeNode root)
        {
            if (root != null)
            {
                InorderTraversalRec(root.Left);
                Console.WriteLine(root.Value);
                InorderTraversalRec(root.Right);
            }
        }
        #endregion
        #region 刪除節點
        /// <summary>
        /// 刪除某個值
        /// </summary>
        /// <param name="val">val</param>
        public void Delete(int val)
        {
            root = DeleteNode(root, val);
        }
        private TreeNode DeleteNode(TreeNode node, int val)
        {
            if (node == null)
            {
                return null;
            }
            if (val < node.Value)
            {
                node.Left = DeleteNode(node.Left, val);
            }
            else if (val > node.Value)
            {
                node.Right = DeleteNode(node.Right, val);
            }
            else
            {
                // 節點有兩個子節點
                if (node.Left != null && node.Right != null)
                {
                    // 使用右子樹中的最小節點替換當前節點
                    TreeNode minNode = FindMin(node.Right);
                    node.Value = minNode.Value;
                    node.Right = DeleteNode(node.Right, minNode.Value);
                }
                // 節點有一個子節點或沒有子節點
                else
                {
                    TreeNode? temp = node.Left != null ? node.Left : node.Right;
                    node = temp;
                }
            }
            return node;
        }
        /// <summary>
        /// 找到樹中的最小節點
        /// </summary>
        /// <param name="node"></param>
        /// <returns></returns>
        private TreeNode FindMin(TreeNode node)
        {
            while (node.Left != null)
            {
                node = node.Left;
            }
            return node;
        }
        #endregion
    }
}

C#哈希查找算法

簡介

哈希查找算法是一種高效的查找算法，通過將鍵值映射到哈希表中的位置來實現快速訪問。在C#中，哈希查找通常通過哈希表（Hashtable）或字典（Dictionary）來實現。

• 詳細文章描述： https://mp.weixin.qq.com/s/WaXCFshzuqVQD6YX2Kcw5g

代碼實現

 public class 哈希查找算法
    {
        /// <summary>
        /// 哈希查找函數
        /// </summary>
        /// <param name="target">target</param>
        public static void HashSearchFunctionRun(int target)
        {
            //創建一個字典來存儲鍵值對
            var dic = new Dictionary<int, string>();
            dic.Add(1, "one");
            dic.Add(2, "two");
            dic.Add(3, "three");
            //查找目標值是否在Dictionary中存在
            //TryGetValue方法可以返回一個bool值和值，如果找到了目標值，則返回true和對應的值，否則返回false和默認值
            string value;
            if (dic.TryGetValue(target, out value))
            {
                Console.WriteLine("Found Data: " + value);
            }
            else
            {
                Console.WriteLine("Not Found Data.");
            }
        }
    }

?