当前位置： 首页 > wzjs >正文

中山 环保 骏域网站建设专家销客多分销小程序价格

wzjs 2025/9/15 3:15:09
中山 环保 骏域网站建设专家,销客多分销小程序价格,制作网站教学设计,网站公司做的网站点击率怎么查在 C# 中，有多种集合类可供使用，它们分别适用于不同的场景,部分代码示例提供了LeetCode相关的代码应用。 1. 数组（Array） 特点 固定大小：在创建数组时需要指定其长度，之后无法动态改变。连续存储&#xf…

在 C# 中，有多种集合类可供使用，它们分别适用于不同的场景,部分代码示例提供了LeetCode相关的代码应用。

1. 数组（Array）

  • 特点
    • 固定大小：在创建数组时需要指定其长度，之后无法动态改变。
    • 连续存储：数组元素在内存中是连续存储的，因此可以通过索引快速访问元素，访问时间复杂度为 O(1)。
    • 类型固定：数组中的所有元素必须是相同类型。
  • 示例代码
  int[] numbers = new int[5] { 1, 5, 2, 3, 4 };numbers[0] = 1;//updateint firstNumber = numbers[0];int lastNumber = numbers[numbers.Length - 1];Array.Sort(numbers);//排序

LeetCode: 106. 从中序与后序遍历序列构造二叉树 - 力扣（LeetCode）

public TreeNode BuildTree(int[] inorder, int[] postorder)
{if (inorder.Length == 0 || postorder.Length == null) return null;int rootValue = postorder.Last();TreeNode root = new TreeNode(rootValue);int delimiterIndex = Array.IndexOf(inorder, rootValue);root.left = BuildTree(inorder.Take(delimiterIndex).ToArray(), postorder.Take(delimiterIndex).ToArray());root.right = BuildTree(inorder.Skip(delimiterIndex + 1).ToArray(), postorder.Skip(delimiterIndex).Take(inorder.Length - delimiterIndex - 1).ToArray());return root;
}

2. 动态数组（List<T>）

  • 特点
    • 动态大小：可以根据需要动态添加或删除元素，无需预先指定大小。
    • 连续存储：内部使用数组实现，元素在内存中连续存储，支持通过索引快速访问，访问时间复杂度为 O(1)。
    • 类型安全：泛型集合，只能存储指定类型的元素。
  • 示例代码
List<int> numberList = new List<int>();
numberList.Add(1);
int firstElement = numberList[0];

3. 链表（LinkedList<T>）

  • 特点
    • 动态大小：可以动态添加或删除元素。
    • 非连续存储：元素在内存中不连续存储，每个元素包含一个指向前一个元素和后一个元素的引用。
    • 插入和删除效率高：在链表的任意位置插入或删除元素的时间复杂度为 O(1)，但随机访问效率低，时间复杂度为O(n) 。
  • 示例代码
            LinkedList<int> numberLinkedList = new LinkedList<int>();numberLinkedList.AddLast(1);numberLinkedList.AddFirst(2);numberLinkedList.AddFirst(3);numberLinkedList.Remove(1);numberLinkedList.RemoveFirst();numberLinkedList.RemoveLast();int count=numberLinkedList.Count;bool isContains= numberLinkedList.Contains(3);

4. 栈（Stack<T>）

  • 特点
    • 后进先出（LIFO）：最后添加的元素最先被移除。
    • 动态大小：可以动态添加或删除元素。
    • 插入和删除操作快：入栈（Push）和出栈（Pop）操作的时间复杂度为O(1) 。
  • 示例代码
            Stack<int> numberStack = new Stack<int>();numberStack.Push(1);// Removes and returns the object at the top of the System.Collections.Generic.Stack`1.int topElement = numberStack.Pop();// Returns the object at the top of the System.Collections.Generic.Stack`1 without removing it.topElement = numberStack.Peek(); int count = numberStack.Count;

LeetCode: 144. 二叉树的前序遍历

/*** Definition for a binary tree node.* public class TreeNode {*     public int val;*     public TreeNode left;*     public TreeNode right;*     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
public class Solution {public IList<int> PreorderTraversal(TreeNode root) {var result = new List<int>();if (root == null) return result;Stack<TreeNode> treeNodes = new Stack<TreeNode>();// 栈是先进后出。 中序遍历是：中--》 左--》右treeNodes.Push(root);while (treeNodes.Count > 0){TreeNode current = treeNodes.Pop();result.Add(current.val);// 中if (current.right != null)// 右{treeNodes.Push(current.right);}if (current.left != null)// 左{treeNodes.Push(current.left);}}return result;}
}

5. 队列（Queue<T>）

  • 特点
    • 先进先出（FIFO）：最先添加的元素最先被移除。
    • 动态大小：可以动态添加或删除元素。
    • 插入和删除操作快：入队（Enqueue）和出队（Dequeue）操作的时间复杂度为 O(1)。
  • 示例代码
          Queue<int> numberQueue = new Queue<int>();numberQueue.Enqueue(1);// Removes and returns the object at the beginning of the System.Collections.Generic.Queue`1.int firstElement = numberQueue.Dequeue();//Returns the object at the beginning of the System.Collections.Generic.Queue`1 without removing it.numberQueue.Peek();int count = numberQueue.Count;

LeetCode: 102. 二叉树的层序遍历 - 力扣（LeetCode） 

/*** Definition for a binary tree node.* public class TreeNode {*     public int val;*     public TreeNode left;*     public TreeNode right;*     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
public class Solution {public IList<IList<int>> LevelOrder(TreeNode root) {var result = new List<IList<int>>();Queue<TreeNode> queue = new ();if (root != null) queue.Enqueue(root);while (queue.Count>0){var row=new List<int>();int count=queue.Count;// 需要事先记录Queue的Count，不能直接依靠Queue本身for (int i=0; i < count; i++){var currentNode=queue.Dequeue();row.Add(currentNode.val);if (currentNode.left != null) queue.Enqueue(currentNode.left);if (currentNode.right != null) queue.Enqueue(currentNode.right);}result.Add(row);}return result;}
}

6. 哈希集合（HashSet<T>）

  • 特点
    • 唯一元素：集合中不允许有重复的元素。
    • 无序：元素在集合中没有特定的顺序。
    • 快速查找：插入、删除和查找操作的平均时间复杂度为O(1) 。
  • 示例代码
      HashSet<int> numberHashSet = new HashSet<int>();numberHashSet.Add(1);bool isAddSuccess = numberHashSet.Add(1);// falsebool containsOne = numberHashSet.Contains(1);// true

如LeetCode：491. 非递减子序列

public class Solution {public IList<IList<int>> FindSubsequences(int[] nums) {var result = new List<IList<int>>();var path = new List<int>();if(nums==null || nums.Length == 0) return result;BackTacking(nums,result,path,0);return result;}private void BackTacking(int[] nums,List<IList<int>> result, List<int> path,int startIndex){if (path.Count>=2) result.Add(new List<int>(path));HashSet<int> used =new HashSet<int>();for (int i=startIndex;i<nums.Length;i++){if(path.Count>0 && nums[i]<path[path.Count-1]) continue;bool isUsed=used.Add(nums[i]);// true-添加成功；false-添加失败，证明已经有元素存在了if(!isUsed) continue;// 同一层重复使用path.Add(nums[i]);BackTacking(nums,result,path,i+1);path.RemoveAt(path.Count-1);}}
}

7. 字典（Dictionary<TKey, TValue>）

  • 特点
    • 键值对存储：通过唯一的键来关联对应的值。
    • 快速查找：根据键查找值的平均时间复杂度为  O(1)。
    • 键唯一：字典中的键必须是唯一的，但值可以重复。
  • 示例代码
Dictionary<string, int> scores = new Dictionary<string, int>();
scores.Add("Alice", 90);
int aliceScore = scores["Alice"];

LeetCode: 105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

/*** Definition for a binary tree node.* public class TreeNode {*     public int val;*     public TreeNode left;*     public TreeNode right;*     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {*         this.val = val;*         this.left = left;*         this.right = right;*     }* }*/
public class Solution {public TreeNode BuildTree(int[] preorder, int[] inorder){if (preorder == null || inorder == null){return null;}/*前序遍历   根   左子树 右子树中序遍历   左子树 根   右子树*/if (preorder.Length != inorder.Length){return null;}Dictionary<int, int> keyMap = new Dictionary<int, int>();for (int i = 0; i < inorder.Length; i++){keyMap.Add(inorder[i], i);}return BuildTree(preorder: preorder, keyMap, preleft: 0, preRight: preorder.Length - 1, inLeft: 0, inRight: inorder.Length - 1);}/// <summary>/// /// </summary>/// <param name="preorder"></param>/// <param name="keyMap">用于确定pIndex。Root的Index</param>/// <param name="preleft"></param>/// <param name="preRight"></param>/// <param name="inLeft"></param>/// <param name="inRight"></param>/// <returns></returns>private TreeNode BuildTree(int[] preorder, Dictionary<int, int> keyMap, int preleft, int preRight, int inLeft, int inRight){if (preleft > preRight || inLeft > inRight){return null;}int rootValue = preorder[preleft];TreeNode treeNode = new TreeNode(rootValue);int pIndex = keyMap[rootValue];treeNode.left = BuildTree(preorder, keyMap, preleft: preleft + 1, preRight: pIndex + preleft - inLeft, inLeft, inRight: pIndex - 1);//根据PreOrder去取Left nodetreeNode.right = BuildTree(preorder, keyMap, preleft: pIndex + preleft - inLeft + 1, preRight: preRight, inLeft: pIndex + 1, inRight);//根据inOrder去取Right nodereturn treeNode;}
}

8. 排序集合（SortedSet<T>）

  • 特点
    • 唯一元素：集合中不允许有重复的元素。
    • 有序：元素会根据元素的自然顺序或指定的比较器进行排序。
    • 查找和插入操作：插入、删除和查找操作的时间复杂度为 O(logn)。
  • 示例代码
SortedSet<int> sortedNumbers = new SortedSet<int>();
sortedNumbers.Add(3);
sortedNumbers.Add(1);
// 元素会自动排序，遍历输出为 1, 3
foreach (int number in sortedNumbers)
{Console.WriteLine(number);
}

9. 排序字典（SortedDictionary<TKey, TValue>）

  • 特点
    • 键值对存储：通过唯一的键来关联对应的值。
    • 有序：元素会根据键的自然顺序或指定的比较器进行排序。
    • 查找和插入操作：根据键查找值、插入和删除操作的时间复杂度为  O(logn)。
  • 示例代码
SortedDictionary<string, int> sortedScores = new SortedDictionary<string, int>();
sortedScores.Add("Evan", 38);
sortedScores.Add("Alice", 30);
// 会根据键排序，遍历输出 Alice: 30, Evan: 38
foreach (KeyValuePair<string, int> pair in sortedScores)
{Console.WriteLine($"{pair.Key}: {pair.Value}");
}


文章转载自：

http://50PxklyS.wjhnx.cn
http://WoYKWIlz.wjhnx.cn
http://63X117VW.wjhnx.cn
http://zNkEbpux.wjhnx.cn
http://txXFu4IY.wjhnx.cn
http://C8EDBdUR.wjhnx.cn
http://dCwrn6m4.wjhnx.cn
http://FFdT07NP.wjhnx.cn
http://6EYxTmNG.wjhnx.cn
http://mdW5VwPf.wjhnx.cn
http://yQcacKyc.wjhnx.cn
http://UogzUcIK.wjhnx.cn
http://iiBccVzc.wjhnx.cn
http://AqNV5wEW.wjhnx.cn
http://REHbVEG9.wjhnx.cn
http://Xgwqcu7v.wjhnx.cn
http://yzqubEF5.wjhnx.cn
http://6ULpPYuh.wjhnx.cn
http://xhmkdkzT.wjhnx.cn
http://sWNZDlXZ.wjhnx.cn
http://87EEBWdV.wjhnx.cn
http://MG8Ys0fM.wjhnx.cn
http://pbQQBFzV.wjhnx.cn
http://zm2Aax5I.wjhnx.cn
http://rMt1ODAG.wjhnx.cn
http://G4fU1Kl1.wjhnx.cn
http://dJdKPOVv.wjhnx.cn
http://Csq7oD3g.wjhnx.cn
http://IwXx1p62.wjhnx.cn
http://6rHdUfFZ.wjhnx.cn
http://www.dtcms.com/wzjs/737430.html

相关文章：

  • 网站优化推广哪家好深喘旋磨做紧夹断妖精网站
  • 大网站服务器维护费用怎么制作ppt 教程
  • 企业网站建设费用属于什么科目平台推广方案模板
  • python手机编程软件长沙网站优化指导
  • 新河网站快排seo建筑网课平台
  • 山东 网站建设 公司太原市住房与城乡建设厅网站
  • 南阳理工网站建设私人可以有官方网址吗
  • 深圳网站建设 宝华大厦泰兴网页定制
  • 网站后台策划书2024年还会封城吗
  • 开网站需要哪些程序莆田网站建设方案优化
  • 什么样的资质做电子商务网站python 网站建设
  • 广东装饰公司网站建设国家企业信用信息查询系统
  • 建设银行 福州招聘网站湖北seo服务
  • 贵港市网站建设搭建企业网站公司
  • 专门做搞笑视频的网站遮罩层怎么做网页
  • 建立用模板建立网站html超链接
  • 门户网站优化报价江苏省网站建设哪家好
  • 网站开发平台的公司dede如何制作网站地图
  • 南京网站建设小程酒店网站建设方案结束语
  • 温州建设工程信息网站做的最好的本地生活网站
  • 黄山网站建设哪家好企业网站建设专业精准丨 鸣远科技
  • 网站维护服务内容淘宝客api调用到网站
  • 做5173这样的网站要多少人微信公众号怎么推广和引流
  • 如何写网站优化目标免费注册网站云空间
  • 境内境外网站区别企业宣传
  • 北京南站在哪个街道网站建设的几个阶段
  • 如何在交易网站做电子印章济南网站建设就选搜点网络ok
  • 建筑设计招标网站湖南响应式网站哪家好
  • 导航网站怎么做湖北百度seo厂家
  • 别人的网站是怎么找到的合肥电信网站备案