Unity知识总结——算法

1.常见排序算法

1.冒泡排序

   简介：冒泡排序算法是一种底子的排序算法，它的实现原理比较简单。焦点思想是通过相邻元素的比较和交换来将最大（或最小）的元素逐步"冒泡"到数列的末尾。
  

• 重复地走访过要排序的数列，一次比较两个元素，假如他们的顺序错误就把他们交换过来
  
• 时间复杂度：平均环境和最坏环境下均为O(n^2)。
  
• 空间复杂度：O(1).
  

  具体文章描述

1.         /// <summary>
2.         /// 递归方式实现冒泡排序
3.         /// </summary>
4.         /// <param name="arr">arr</param>
5.         /// <param name="arrLength">arrLength</param>
6.         public static void RecursiveBubbleSort(int[] arr, int arrLength)
7.         {
8.             if (arrLength == 1)
9.                 return;
11.             for (int i = 0; i < arrLength - 1; i++)
12.             {
13.                 if (arr[i] > arr[i + 1])
14.                 {
15.                     //交换arr[i]和arr[i+1]的值
16.                     int temp = arr[i];
17.                     arr[i] = arr[i + 1];
18.                     arr[i + 1] = temp;
19.                 }
20.             }
22.             RecursiveBubbleSort(arr, arrLength - 1);
23.         }
25.         public static void RecursiveBubbleSortRun()
26.         {
27.             int[] arr = { 1, 8, 9, 5, 6, 2, 3, 4, 7 };
28.             int arrLength = arr.Length;
29.             RecursiveBubbleSort(arr, arrLength);
30.             Console.WriteLine("排序后结果：" + string.Join(", ", arr));
31.         }

复制代码

2.选择排序

   简介：选择排序算法的基本思想是每一次从待排序的数据元素中选出最小或最大的一个元素，存放在序列的起始位置，然而，再从剩余未排序元素中继承探求最小或最大元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。
  

• 每次从未排序的部分选择最小（或最大）的元素，放到已排序部分的末尾
  
• 时间复杂度：平均环境和最坏环境下均为 O(n^2)。
  
• 空间复杂度：O(1)。
  

  具体文章描述

1.         /// <summary>
2.         /// 选择排序算法
3.         /// </summary>
4.         public static void SelectionSortAlgorithmMain()
5.         {
6.             int[] array = { 64, 25, 12, 22, 11, 99, 3, 100 };
8.             Console.WriteLine("原始数组: ");
9.             PrintArray(array);
11.             SelectionSortAlgorithm(array);
13.             Console.WriteLine("排序后的数组: ");
14.             PrintArray(array);
15.         }
17.         static void SelectionSortAlgorithm(int[] arr)
18.         {
19.             int n = arr.Length;
21.             for (int i = 0; i < n - 1; i++)
22.             {
23.                 // 在未排序部分中找到最小元素的索引
24.                 int minIndex = i;
25.                 for (int j = i + 1; j < n; j++)
26.                 {
27.                     if (arr[j] < arr[minIndex])
28.                     {
29.                         minIndex = j;
30.                     }
31.                 }
33.                 // 将最小元素与未排序部分的第一个元素交换位置
34.                 int temp = arr[minIndex];
35.                 arr[minIndex] = arr[i];
36.                 arr[i] = temp;
37.             }
38.         }
40.         static void PrintArray(int[] arr)
41.         {
42.             int n = arr.Length;
43.             for (int i = 0; i < n; ++i)
44.             {
45.                 Console.Write(arr[i] + " ");
46.             }
47.             Console.WriteLine();
48.         }

复制代码

3.插入排序

   简介：插入排序算法是一种简单、直观的排序算法，其原理是将一个待排序的元素逐个地插入到已经排好序的部分中。
  

• 将未排序的元素逐个插入到已排序部分的符合位置。
  
• 时间复杂度：平均环境和最坏环境下均为 O(n^2)。
  
• 空间复杂度：O(1)。
  

  具体文章描述

1.                 public static void InsertionSort(int[] array)
2.         {
3.             int arrayLength = array.Length;//数组长度（时间复杂度为O(n^2)）
4.             for (int i = 1; i < arrayLength; ++i)
5.             {
6.                 //定义临时变量
7.                 int temp = array[i];
8.                 int j = i - 1;
10.                 while (j >= 0 && array[j] > temp)
11.                 {
12.                     array[j + 1] = array[j];
13.                     j--;
14.                 }
16.                 array[j + 1] = temp;
17.             }
18.         }
20.         public static void InsertionSortRun()
21.         {
22.             int[] array = { 26, 15, 5, 3, 38, 36, 44, 27, 47, 2, 46, 4, 50, 19, 48 };
24.             Console.WriteLine("排序前:" + string.Join(", ", array));
26.             InsertionSort(array);
28.             Console.WriteLine("排序后:" + string.Join(", ", array));
29.         }

复制代码

4.快速排序

   简介：快速排序是一种常用的排序算法，它基于分治的思想，通过将一个无序的序列分割成两个子序列，并递归地对子序列进行排序，终极完成整个序列的排序。
  

• 选择一个基准元素，将小于基准的元素放到左侧，大于基准的元素放到右侧，再对左右两部分递归进行快排。
  
• 时间复杂度：平均环境下为 O(nlogn)，最坏环境下为 O(n^2)。
  
• 空间复杂度：O(logn)。
  

  具体文章描述

1. public class 快速排序算法
2.     {
3.         public static void Sort(int[] array, int low, int high)
4.         {
5.             if (low < high)
6.             {
7.                 //将数组分割为两部分，并返回分割点的索引
8.                 int pivotIndex = Partition(array, low, high);
10.                 //递归对分割后的两部分进行排序
11.                 Sort(array, low, pivotIndex - 1);
12.                 Sort(array, pivotIndex + 1, high);
13.             }
14.         }
16.         private static int Partition(int[] array, int low, int high)
17.         {
18.             //选择最后一个元素作为基准元素
19.             int pivot = array[high];
20.             int i = low - 1;
22.             for (int j = low; j <= high - 1; j++)
23.             {
24.                 //如果当前元素小于等于基准元素，则将它与i+1位置的元素交换
25.                 if (array[j] <= pivot)
26.                 {
27.                     i++;
28.                     Swap(array, i, j);
29.                 }
30.             }
32.             //将基准元素放置到正确的位置上
33.             Swap(array, i + 1, high);
35.             return i + 1; //返回基准元素的索引
36.         }
38.         private static void Swap(int[] array, int i, int j)
39.         {
40.             int temp = array[i];
41.             array[i] = array[j];
42.             array[j] = temp;
43.         }
45.         public static void QuickSortRun()
46.         {
47.             int[] array = { 2, 3, 5, 38, 19, 15, 26, 27, 36, 44, 47, 46, 50, 48, 4 };
48.             Sort(array, 0, array.Length - 1);
49.             Console.WriteLine("排序后结果：" + string.Join(", ", array));
50.         }
51.     }

复制代码

5.归并排序

   简介：归并排序是一种常见的排序算法，它采用分治法的思想，在排序过程中不停将待排序序列分割成更小的子序列，直到每个子序列中只剩下一个元素，然后将这些子序列两两合并排序，终极得到一个有序的序列。
  

• 将数组分成两半，对每一半进行递归归并排序，然后将两个有序的子数组合并成一个有序数组。
  
• 时间复杂度：平均环境下为 O(nlogn)。
  
• 空间复杂度：O(n)。
  

  具体文章描述

1.   public static void MergeSort(int[] arr, int left, int right)
2.         {
3.             if (left < right)
4.             {
5.                 // 计算中间索引
6.                 int mid = (left + right) / 2;
8.                 // 对左半部分数组进行归并排序
9.                 MergeSort(arr, left, mid);
11.                 // 对右半部分数组进行归并排序
12.                 MergeSort(arr, mid + 1, right);
14.                 // 合并两个有序数组
15.                 Merge(arr, left, mid, right);
16.             }
17.         }
19.         public static void Merge(int[] arr, int left, int mid, int right)
20.         {
21.             int n1 = mid - left + 1; // 左半部分数组的长度
22.             int n2 = right - mid;    // 右半部分数组的长度
24.             // 创建临时数组
25.             int[] leftArr = new int[n1];
26.             int[] rightArr = new int[n2];
28.             // 将数据拷贝到临时数组
29.             for (int i = 0; i < n1; ++i)
30.             {
31.                 leftArr[i] = arr[left + i];
32.             }
34.             for (int j = 0; j < n2; ++j)
35.             {
36.                 rightArr[j] = arr[mid + 1 + j];
37.             }
39.             // 合并两个有序数组
40.             int k = left;   // 初始化合并后的数组索引
41.             int p = 0;      // 初始化左半部分数组的索引
42.             int q = 0;      // 初始化右半部分数组的索引
44.             while (p < n1 && q < n2)
45.             {
46.                 if (leftArr[p] <= rightArr[q])
47.                 {
48.                     arr[k] = leftArr[p];
49.                     p++;
50.                 }
51.                 else
52.                 {
53.                     arr[k] = rightArr[q];
54.                     q++;
55.                 }
56.                 k++;
57.             }
59.             // 复制左半部分数组的剩余元素
60.             while (p < n1)
61.             {
62.                 arr[k] = leftArr[p];
63.                 p++;
64.                 k++;
65.             }
67.             // 复制右半部分数组的剩余元素
68.             while (q < n2)
69.             {
70.                 arr[k] = rightArr[q];
71.                 q++;
72.                 k++;
73.             }
74.         }
76.         public static void MergeSortRun()
77.         {
78.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3 };
79.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
81.             MergeSort(array, 0, array.Length - 1);
83.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
84.         }   

复制代码

6.希尔排序

   简介：希尔排序简单的来说就是一种改进的插入排序算法，它通过将待排序的元素分成多少个子序列，然后对每个子序列进行插入排序，终极逐步缩小子序列的间隔，直到整个序列变得有序。希尔排序的主要思想是通过插入排序的上风，减小逆序对的间隔，从而进步排序服从。
  

• 将待排序数组分别成多少个间隔相等的子序列，对每个子序列进行插入排序，随着间隔的逐步缩小，直至间隔为1，终极对整个数组进行插入排序，使得整个数组基本有序。
  
• 时间复杂度：在 O(n^2)和O(n ^1.5) 之间。
  
• 空间复杂度：O(n)。
  

  具体文章描述

1. public static void ShellSort(int[] array)
2.         {
3.             int arrLength = array.Length;
5.             // 初始化增量（初始间隔）为数组长度的一半
6.             int gap = arrLength / 2;
8.             // 不断缩小增量，直到增量为1
9.             while (gap > 0)
10.             {
11.                 // 对每个子序列进行插入排序
12.                 for (int i = gap; i < arrLength; i++)
13.                 {
14.                     int temp = array[i];
15.                     int j = i;
17.                     // 在子序列内部进行插入排序
18.                     while (j >= gap && array[j - gap] > temp)
19.                     {
20.                         array[j] = array[j - gap];
21.                         j -= gap;
22.                     }
24.                     array[j] = temp;
25.                 }
27.                 // 缩小增量
28.                 gap /= 2;
29.             }
30.         }
32.         public static void ShellSortRun()
33.         {
34.             int[] array = { 19, 20, 22, 32, 34, 50, 99, 49, 1, 11, 11, 55, 35, 93, 96, 71, 70, 38, 78, 48 };
36.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
38.             ShellSort(array);
40.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
41.         }

复制代码

7.堆排序

   简介：堆排序是一种高效的排序算法，基于二叉堆数据结构实现。它具有稳固性、时间复杂度为O(nlogn)和空间复杂度为O(1)的特点。
  

• 将待排序数组构建成最大堆，然后将堆顶元素与最后一个元素交换并重新调整堆，直到全部元素都排好序。
  
• 时间复杂度：平均环境下为 O(nlogn)。
  
• 空间复杂度：O(1)。
  

  具体文章描述

1. public static void HeapSort(int[] array)
2.         {
3.             int arrayLength = array.Length;
5.             //构建最大堆
6.             for (int i = arrayLength / 2 - 1; i >= 0; i--)
7.                 Heapify(array, arrayLength, i);
9.             //依次取出堆顶元素，并重新调整堆
10.             for (int i = arrayLength - 1; i >= 0; i--)
11.             {
12.                 //将堆顶元素与当前最后一个元素交换
13.                 int temp = array[0];
14.                 array[0] = array[i];
15.                 array[i] = temp;
17.                 //重新调整堆
18.                 Heapify(array, i, 0);
19.             }
20.         }
22.         private static void Heapify(int[] arr, int n, int i)
23.         {
24.             int largest = i; //假设父节点最大
25.             int left = 2 * i + 1; //左子节点
26.             int right = 2 * i + 2; //右子节点
28.             //如果左子节点大于父节点，则更新最大值
29.             if (left < n && arr[left] > arr[largest])
30.                 largest = left;
32.             //如果右子节点大于父节点和左子节点，则更新最大值
33.             if (right < n && arr[right] > arr[largest])
34.                 largest = right;
36.             //如果最大值不是当前父节点，则交换父节点和最大值，并继续向下调整堆
37.             if (largest != i)
38.             {
39.                 int swap = arr[i];
40.                 arr[i] = arr[largest];
41.                 arr[largest] = swap;
43.                 Heapify(arr, n, largest);
44.             }
45.         }
47.         public static void HeapSortRun()
48.         {
49.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3, 99, 888, 0, -1 };
50.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
52.             HeapSort(array);
54.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
55.         }

复制代码

8.桶排序

   简介：桶排序是一种线性时间复杂度的排序算法，它将待排序的数据分到有限数目的桶中，每个桶再进行单独排序，最后将全部桶中的数据按顺序依次取出，即可得到排序结果。
  

• 将元素分配到有限数目的桶中，对每个桶中的元素进行排序，然后按照顺序将桶中的元素输出。
  
• 时间复杂度：平均环境下为 O(n + k)，其中 k 表示桶的数目。
  
• 空间复杂度：O(n + k)。
  

  具体文章描述

1. public static void BucketSort(int[] array)
2.         {
3.             int arrLength = array.Length;
4.             if (arrLength <= 1)
5.             {
6.                 return;
7.             }
9.             //确定桶的数量
10.             int maxValue = array[0], minValue = array[0];
11.             for (int i = 1; i < arrLength; i++)
12.             {
13.                 if (array[i] > maxValue)
14.                     maxValue = array[i];
15.                 if (array[i] < minValue)
16.                     minValue = array[i];
17.             }
18.             int bucketCount = (maxValue - minValue) / arrLength + 1;
20.             //创建桶并将数据放入桶中
21.             List<List<int>> buckets = new List<List<int>>(bucketCount);
22.             for (int i = 0; i < bucketCount; i++)
23.             {
24.                 buckets.Add(new List<int>());
25.             }
27.             for (int i = 0; i < arrLength; i++)
28.             {
29.                 int bucketIndex = (array[i] - minValue) / arrLength;
30.                 buckets[bucketIndex].Add(array[i]);
31.             }
33.             //对每个非空的桶进行排序
34.             int index = 0;
35.             for (int i = 0; i < bucketCount; i++)
36.             {
37.                 if (buckets[i].Count == 0)
38.                 {
39.                     continue;
40.                 }
42.                 int[] tempArr = buckets[i].ToArray();
43.                 Array.Sort(tempArr);
45.                 foreach (int num in tempArr)
46.                 {
47.                     array[index++] = num;
48.                 }
49.             }
50.         }
52.         public static void BucketSortRun()
53.         {
54.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3, 99, 888};
55.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
57.             BucketSort(array);
59.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
60.         }

复制代码

9.计数排序算法

   简介：计数排序是一种非比较性的排序算法，实用于排序一定范围内的整数。它的基本思想是通过统计每个元素的出现次数，然后根据元素的巨细依次输出排序结果。
  

• 时间复杂度：平均环境下为O(n+k)，最好最坏环境下也是O(n+k)，其中n为待排序数组的长度，k为最大值和最小值之差。
  
• 空间复杂度：O(n + k)。
  

  具体文章描述

1. public static void CountingSort(int[] array)
2.         {
3.             int arrayLength = array.Length;
4.             if (arrayLength <= 1) return;
6.             int min = array[0];
7.             int max = array[0];
9.             //找出最大值和最小值
10.             for (int i = 1; i < arrayLength; i++)
11.             {
12.                 if (array[i] < min) min = array[i];
13.                 if (array[i] > max) max = array[i];
14.             }
16.             //统计每个元素出现的次数
17.             int[] count = new int[max - min + 1];
19.             //统计每个元素出现的次数
20.             for (int i = 0; i < arrayLength; i++)
21.             {
22.                 count[array[i] - min]++;
23.             }
25.             //根据count数组和min值确定每个元素的起始位置
26.             for (int i = 1; i < count.Length; i++)
27.             {
28.                 count[i] += count[i - 1];
29.             }
31.             //存储排序结果
32.             int[] temp = new int[arrayLength];
34.             //根据count数组和min值确定每个元素在temp数组中的位置
35.             for (int i = arrayLength - 1; i >= 0; i--)
36.             {
37.                 int index = count[array[i] - min] - 1;
38.                 temp[index] = array[i];
39.                 count[array[i] - min]--;
40.             }
42.             //将排序结果复制回原数组
43.             for (int i = 0; i < arrayLength; i++)
44.             {
45.                 array[i] = temp[i];
46.             }
47.         }
49.         public static void CountingSortRun()
50.         {
51.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3, 99, 888};
52.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
54.             CountingSort(array);
56.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
57.         }

复制代码

10.基数排序算法

   简介：基数排序是一种非比较性排序算法，它通过将待排序的数据拆分成多个数字位进行排序。
  

• 时间复杂度：平均环境下为O(d(n+r))，最好最坏环境下也是O(d(n+r))，d为位数，r为基数
  
• 空间复杂度：*O®
  

  具体文章描述

1. public static void RadixSort(int[] array)
2.         {
3.             if (array == null || array.Length < 2)
4.             {
5.                 return;
6.             }
8.             //获取数组中的最大值，确定排序的位数
9.             int max = GetMaxValue(array);
11.             //进行基数排序
12.             for (int exp = 1; max / exp > 0; exp *= 10)
13.             {
14.                 CountingSort(array, exp);
15.             }
16.         }
18.         private static void CountingSort(int[] array, int exp)
19.         {
20.             int arrayLength = array.Length;
21.             int[] output = new int[arrayLength];
22.             int[] count = new int[10];
24.             //统计每个桶中的元素个数
25.             for (int i = 0; i < arrayLength; i++)
26.             {
27.                 count[(array[i] / exp) % 10]++;
28.             }
30.             //计算每个桶中最后一个元素的位置
31.             for (int i = 1; i < 10; i++)
32.             {
33.                 count[i] += count[i - 1];
34.             }
36.             //从原数组中取出元素，放入到输出数组中
37.             for (int i = arrayLength - 1; i >= 0; i--)
38.             {
39.                 output[count[(array[i] / exp) % 10] - 1] = array[i];
40.                 count[(array[i] / exp) % 10]--;
41.             }
43.             //将输出数组复制回原数组
44.             for (int i = 0; i < arrayLength; i++)
45.             {
46.                 array[i] = output[i];
47.             }
48.         }
50.         private static int GetMaxValue(int[] arr)
51.         {
52.             int max = arr[0];
53.             for (int i = 1; i < arr.Length; i++)
54.             {
55.                 if (arr[i] > max)
56.                 {
57.                     max = arr[i];
58.                 }
59.             }
60.             return max;
61.         }
63.         public static void RadixSortRun()
64.         {
65.             int[] array = { 19, 27, 46, 48, 99, 888, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3 };
67.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
69.             RadixSort(array);
71.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
72.         }

复制代码

2. 常见查找算法

1.线性查找

   逐个遍历数组或列表，查找目标元素，时间复杂度为O(n)。
  具体文章描述
2.二分查找

   对于有序数组或列表，通过比较中间元素与目标元素的巨细关系来确定目标元素所在的区间，不停缩小查找范围，直到找到目标元素或查找范围为空，时间复杂度为 O(log n)。
  具体文章描述
3.哈希查找

   通过哈希函数将关键字映射到哈希表的位置，快速定位目标元素，时间复杂度为 O(1)，但必要额外的空间来存储哈希表。
  具体文章描述
4.二叉查找树

   通过构建二叉搜刮树，按照左子树小于根节点、右子树大于根节点的规则，进行查找操纵，时间复杂度取决于树的高度，平均环境为 O(log n)，最坏环境为 O(n)。
逐个遍历数组或列表，查找目标元素，时间复杂度为O(n)。
  具体文章描述
5.平衡二叉查找树

   比方 AVL 树、红黑树等，保持树的平衡性，使得查找服从更高，时间复杂度稳固在 O(log n)。
逐个遍历数组或列表，查找目标元素，时间复杂度为O(n)。
  具体文章描述
6.跳表

   一种类似于平衡二叉查找树的数据结构，通过构建多层索引，进步查找服从，平均环境下时间复杂度为 O(log n)。
  具体文章描述1
具体文章描述2
7.Trie 树

   一种树形数据结构，用于处理字符串检索，时间复杂度与字符串的长度相关。
逐个遍历数组或列表，查找目标元素，时间复杂度为O(n)。
  具体文章描述
8.Bloom Filter

   一种高效的查找算法，用于判定一个元素是否属于一个聚集，可能会存在一定的误判率，但具有空间服从和查询服从高的特点。
逐个遍历数组或列表，查找目标元素，时间复杂度为O(n)。
  具体文章描述
3.空间切割算法

   

• 四叉树：将二维空间递归地分别为四个象限，每个象限又可以进一步分别为四个子象限，以此类推。四叉树常用于图像处理、碰撞检测等范畴。
  
• 八叉树：类似于四叉树，但是将三维空间递归地分别为八个子立方体。八叉树常用于三维物体的空间索引和碰撞检测。
  
• kd 树：一种多维空间分别结构，将空间按照特定维度分别为两个子空间，可以是二维、三维或更高维。kd 树常用于高维空间的搜刮和最近邻查找。
  
• R 树：一种多维空间索引结构，用于高效地存储和查询多维数据。R 树可以或许快速查找空间范围内的对象，并支持动态插入和删除操纵。
  
• BVH：一种基于困绕体的层次空间分别结构，用于加速碰撞检测和光线追踪等应用。BVH 将空间分别为层次结构，每个节点表示一个困绕体，可以是球体、盒子等，以淘汰碰撞检测的计算量。
  

  4.洗牌算法

   逆序遍历这个数组，随机从这个数组内里取一个0~i+1之间的数，由于是左闭右开，以是不用担心会越界，取完后，
将其与当前遍历的元素进行位序交换，然后进行下一次遍历

1.         public static void Shuffle<T>(T[] array)
2.     {
3.         Random random = new Random();
4.         for (int i = array.Length - 1; i > 0; i--)
5.         {
6.             // 随机选取一个不大于 i 的数
7.             int j = random.Next(i + 1);
9.             // 交换当前元素与随机选中的元素
10.             T temp = array[i];
11.             array[i] = array[j];
12.             array[j] = temp;
13.         }
14.     }

复制代码

5.一个数组长度为n-1,有1~n，n个数在内里但是缺了一个，怎样用最快的方法找到这个数

   假如有序的话就用二分查找，假如无序的就可以用
.
求和法
  

• 时间复杂度：O(n) 空间复杂度：O(1)。但n过大时，求和存在溢出问题。
  

1. //n：最大元素的值而不是元素的个数
2. int getNum(int a[], int n)
3. {
4.     int sum = n*(n+1)/2;
5.     int t;
6.     for(int i=0; i<n-1; i++)
7.     {
8.         sum = sum - a[i];
9.     }
10.     return sum;
11. }

复制代码

  异或法
利用异或运算，
任何数异或自己都等于0，x^X=0
任何数异或0都等于他自己x^0=x；
假如缺的为3。result = 1245N
第二次异或后 result = 1245N 12345N = 0^3 = 3
时间复杂度：O(n) 空间复杂度：O(1)

1. //异或方法，n：最大元素的值
2. int getLose(int a[], int n)
3. {
4.     int t = 0;
5.     for(int i =1; i<=n; i++)
6.         t = t ^ i;
7.     //最大值为n，缺失一个元素，则元素个数为n-2
8.     for(int i=0; i<n-1; i++)
9.         t = t ^ a[i];
10.     return t;
11. }

复制代码

6.怎样计算某个时候（ex–3:15）的分针和时针的夹角

   分针：每分钟移动360度 / 60 = 6度
时针：每小时移动360度 / 12 = 30度，每分钟时针移动30度 / 60 = 0.5度
如3：15，此时分钟移动了156=90，时针303+0.5*15=97.5，那么两者之间的最小夹角就是7.5度，最大夹角是352.5度

1.                         float h = 3;
2.             float m = 15;
3.             float angleM = m / 60 * 360;
4.             if (h >= 12)
5.             {
6.                 h = h - 12;
7.             }
8.             float angleH = h * 30 + m / 60 * 30;    //时针角度计算
9.             float angle = Math.Abs(angleH - angleM);
10.             Console.WriteLine(angle);

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。