C#语言 十大经典排序算法动画与解析！（动态演示+代码）(java改写成C# )
以下内容是根据 https://www.cnblogs.com/fivestudy/p/10212306.html 进行改写
排序算法是《数据结构与算法》中最基本的算法之一。
排序算法简介
排序算法可以分为内部排序和外部排序。
内部排序是数据记录在内存中进行排序。
而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。
常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。
用一张图概括：
image
关于时间复杂度：
平方阶 (O(n2)) 排序 各类简单排序：直接插入、直接选择和冒泡排序。
线性对数阶 (O(nlog2n)) 排序 快速排序、堆排序和归并排序；
O(n1+§)) 排序，§ 是介于 0 和 1 之间的常数。 希尔排序
线性阶 (O(n)) 排序 基数排序，此外还有桶、箱排序。
关于稳定性：
稳定的排序算法：冒泡排序、插入排序、归并排序和基数排序。
不是稳定的排序算法：选择排序、快速排序、希尔排序、堆排序。
1. 冒泡排序
1.1 算法步骤
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
1.2 动画演示
image
1.3 参考代码
/// <summary>
/// 冒泡排序，从小到大
/// </summary>
/// <param name="a"></param>
/// <param name="n"></param>
static void BubbleSort(int[] arr,int n)
{
for (int i = 0; i < n-1; i++)
{
for (int j = 0; j < n-1-i; j++)
{
if (arr[j] > arr[j + 1])
{
var temp = arr[j];//相邻的两个数，前面的值比后面的大，则两两交换值
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
{
int[] arr = new int[] {5,4,2,3,8 };
int n = arr.Length;
ShowNum("排序前", arr);
BubbleSort(arr, n);
ShowNum("冒泡排序后", arr);
Console.WriteLine("");
}
static void ShowNum(string des,int[] a)
{
StringBuilder sb = new StringBuilder();
for (int i = 0; i < a.Length; i++)
{
sb.Append(a[i].ToString() + " "); }
Console.WriteLine(des+"数据为："+sb.ToString());
}
2. 选择排序
2.1 算法步骤
首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
重复第二步，直到所有元素均排序完毕。
2.2 动画演示
image
2.3 参考代码
/// <summary>
/// 选择排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
static void SelectSort(int[] arr,int n)
{ for (int i = 0; i < n-1; i++)
{
var minIndex = i;
for (int j = i+1; j < n; j++)
{
if (arr[j] < arr[minIndex])//在未排序区寻找最小的数
{
minIndex = j;//将最小的数索引保存
}
}
var temp = arr[i];//要选择的排序位置的值，与未排序区索引的值，两两交换
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
{
int[] arr = new int[] { 2,4,3,6,5 };
int n = arr.Length;
ShowNum("排序前", arr);
SelectSort(arr, n);
ShowNum("选择排序后", arr);
Console.WriteLine("");
}
3. 插入排序
3.1 算法步骤
将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
3.2 动画演示
image
3.3 参考代码
/// <summary>
/// 插入排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
static void InsertSort(int[] arr,int n)
{
if (n <= 1)
{
return;
}
for (int i = 1; i < n; i++)
{
if (arr[i-1] > arr[i])
{
var j = i - 1;
var temp = arr[i];//记录要插入的数据
arr[i] = arr[i - 1];//先后移一个元素
for (; j >= 0; --j)
{
if (arr[j] > temp)
{
arr[j + 1] = arr[j];
}
else
{
break;
}
}
arr[j + 1] = temp;//插入到正确位置
; }
}
}
/// <summary>
/// 插入排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
static void InsertSort1(int[] arr, int n)
{
for (int i = 1; i < n; i++)
{
var temp = arr[i];//记录要插入的数据
// 从已经排序的序列最右边的开始比较，找到比其小的数
int j = i;
while (j>0 && arr[j-1]>temp)
{
arr[j] = arr[j - 1];
j--;
}
//存在比其小的数，插入
if (j != i)
{
arr[j] = temp;
}
}
}
{
int[] arr = new int[] { 5,3,4,7,2};
int n = arr.Length;
ShowNum("排序前", arr);
InsertSort1(arr, n);
ShowNum("插入排序后", arr);
Console.WriteLine("");
}
4. 希尔排序
4.1 算法步骤
选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
按增量序列个数 k，对序列进行 k 趟排序；
每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
4.2 动画演示
image
4.3 参考代码
/// <summary>
/// 希尔排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
static void SellSort(int[]arr,int n)
{
int gap = 10;
while (gap < n)
{
gap = gap * 2 + 1;
}
while (gap > 0)
{
for (int i = gap; i < n; i++)
{
var temp = arr[i];
int j = i - gap;
while(j>=0&& arr[j] > temp)
{
arr[j + gap] = arr[j];
j -= gap;
}
arr[j + gap] = temp;
}
gap = (int)Math.Floor(gap / 2.00);
} }
{
int[] arr = new int[] { 8,9,1,7,2,3,5,4,6,0 };
int n = arr.Length;
ShowNum("排序前", arr);
SellSort(arr,n);
ShowNum("希尔排序后", arr);
Console.WriteLine("");
}
5. 归并排序
5.1 算法步骤
申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
设定两个指针，最初位置分别为两个已经排序序列的起始位置；
比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
重复步骤 3 直到某一指针达到序列尾；
将另一序列剩下的所有元素直接复制到合并序列尾。
5.2 动画演示
image
5.3 参考代码
写法一:
/// <summary>
/// 归并排序，从小到大
/// </summary>
/// <param name="arr">原arr</param>
/// <param name="newArr">排序后的newArr</param>
/// <param name="fristIndex">首位Index</param>
/// <param name="lastIndex">末位Index</param>
/// <returns></returns>
static int[] MergeSort(int[] arr, int[] newArr, int fristIndex, int lastIndex)
{
if (fristIndex == lastIndex)
{
newArr[fristIndex] = arr[fristIndex];
}
else
{
int midIndex = (fristIndex + lastIndex) / 2;//将SR[s...t]评分为SR[s...m]和SR[m+1...t]
int[] newArr2 = new int[arr.Length];
MergeSort(arr, newArr2, fristIndex, midIndex);//递归地将SR[s...m]归并为有序的TR2[s...m]
//ShowSortArray(test, s, m);
MergeSort(arr, newArr2, midIndex + 1, lastIndex);//递归地将SR[m+1...t]归并为有序的TR2[m+1...t]
Merge(newArr2, newArr, fristIndex, midIndex, lastIndex);
}
return newArr;
}
/// <summary>
/// 将arr中记录由小到大地并入newArr
/// </summary>
/// <param name="arr">原arr</param>
/// <param name="newArr">要并入目标的newArr</param>
/// <param name="fristIndex">首位Index</param>
/// <param name="midIndex">分割Index</param>
/// <param name="lastIndex">末位Index</param>
private static void Merge(int[] arr, int[] newArr, int fristIndex, int midIndex, int lastIndex)
{
int j = 0, k = 0;
for (k = fristIndex, j = midIndex + 1; fristIndex <= midIndex && j <= lastIndex; k++)
{
//将arr中首位值、分割位值的最小的那个依次并入newArr
if (arr[fristIndex] <= arr[j])
{
newArr[k] = arr[fristIndex];
fristIndex++;//首位Index 后移
}
else
{
newArr[k] = arr[j];
j++; //分割Index 后移
}
}
//将剩下的尚未并入的arr[fristIndex]的值依次并入到newArr
if (fristIndex <= midIndex)
{
while (k <= lastIndex && fristIndex <= midIndex)
{
newArr[k] = arr[fristIndex];
k++;
fristIndex++;
}
}
//将剩下的尚未并入的arr[midIndex]的值依次并入到newArr
if (j <= lastIndex)
{
while (k <= lastIndex && j <= lastIndex)
{
newArr[k] = arr[j];
k++;
j++;
}
} }
写法二：
/// <summary>
/// 归并排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
/// <returns></returns>
static int[] MergeSort1(int[] arr)
{
var result = new int[arr.Length];
if (arr.Length == 1)
{
return arr;
} int middle = arr.Length / 2; int[] left = arr.ToList().Take(middle).ToArray(); int[] right = arr.ToList().Skip(middle).ToArray(); var newLeft = MergeSort1(left);
var newRight = MergeSort1(right); return Merge1(newLeft,newRight);
}
private static int[] Merge1(int[] left, int[] right)
{
int[] result = new int[left.Length + right.Length];
int i = 0;
while (left.Length > 0 && right.Length > 0)
{
if (left[0] <= right[0])
{
result[i++] = left[0];
left = left.ToList().Skip(1).ToArray(); }
else
{
result[i++] = right[0];
right = right.ToList().Skip(1).ToArray();
} }
while (left.Length > 0)
{
result[i] = left[0];
left = left.ToList().Skip(1).ToArray();
i++;
}
while (right.Length > 0)
{
result[i] = right[0];
right = right.ToList().Skip(1).ToArray();
i++; ;
}
return result;
}
{
int[] arr = new int[] { 6,4,3,7,5,1,2 };
int n = arr.Length;
ShowNum("排序前", arr);
int[] newArr = new int[arr.Length];
newArr = MergeSort( arr,newArr,0,arr.Length-1);
ShowNum("归并排序后", newArr);
newArr = MergeSort1(arr);
ShowNum("归并2排序后", newArr);
Console.WriteLine("");
}
6. 快速排序
6.1 算法步骤
从数列中挑出一个元素，称为 “基准”（pivot）;
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
6.2 动画演示
image
6.3 参考代码
/// <summary>
/// 快速排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="left"></param>
/// <param name="right"></param>
static void QuickSort(int[] arr,int left,int right)
{
if (left < right)
{
var L_R = arr[left];//基准数，把比他小或者等于它的 放在它的左边，然后把比它大的 放在它的右边
var i = left;
var j = right;
while (i < j)
{
//从后往前比较
while (i < j)
{
if (arr[j] <= L_R)//找到一个比基准数小于或者等于的值，应该把他放在L_R的左边
{
arr[i] = arr[j];
break;
}
else
{
j--;//向左移动 到下一个数字，然后做比较
}
} //从前往后
while (i < j)
{
if (arr[i] > L_R)//找到一个比基准数大于或者等于的值，应该把他放在L_R的右边
{
arr[j] = arr[i];
break;
}
else
{
i++;
}
}
}
//跳出循环，现在i==j i是中间位置
arr[i] = L_R;
QuickSort(arr, left, i - 1);
QuickSort(arr, i + 1, right);
} }
{
int[] arr = new int[] {3,5,8,1,2,9,4,7,6 };
int n = arr.Length;
ShowNum("排序前", arr);
QuickSort(arr, 0,n-1);
ShowNum("快速排序后", arr);
Console.WriteLine("");
}
7. 堆排序
7.1 算法步骤
创建一个堆 H[0……n-1]；
把堆首（最大值）和堆尾互换；
把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
重复步骤 2，直到堆的尺寸为 1。
7.2 动画演示
image
7.3 参考代码
/// <summary>
/// 堆排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
static void HeapSort(int[]arr)
{
BuildMaxHeap(arr); //创建大顶推（初始状态看做：整体无序）
for (int i = arr.Length-1; i > 0; i--)
{
Swap(ref arr[0], ref arr[i]);//将堆顶元素依次与无序区的最后一位交换（使堆顶元素进入有序区）
MaxHeapify(arr, 0, i);//重新将无序区调整为大顶堆
}
}
/// <summary>
/// 创建大顶推（根节点大于左右子节点）
/// </summary>
/// <param name="arr">待排数组</param>
private static void BuildMaxHeap(int[] arr)
{ for (int i = arr.Length/2-1; i >=0; i--)//从最底层的最后一个根节点开始进行大顶推的调整
{
MaxHeapify(arr, i, arr.Length); //调整大顶堆 }
}
/// <summary>
/// 大顶推的调整过程
/// </summary>
/// <param name="arr">待调整的数组</param>
/// <param name="currentIndex">待调整元素在数组中的位置</param>
/// <param name="heapSize">堆中所有元素的个数</param>
private static void MaxHeapify(int[]arr,int currentIndex,int heapSize)
{
int left = 2 * currentIndex + 1; //左子节点在数组中的位置
int right = 2 * currentIndex + 2; //右子节点在数组中的位置
int large = currentIndex; //记录此根节点、左子节点、右子节点 三者中最大值的位置
if (left<heapSize && arr[left] > arr[large])//与左子节点进行比较
{
large = left;
}
if(right<heapSize&& arr[right] > arr[large]) //与右子节点进行比较
{
large = right;
}
if (currentIndex!=large)//如果 currentIndex != large 则表明 large 发生变化（即：左右子节点中有大于根节点的情况）
{
Swap(ref arr[currentIndex], ref arr[large]); //将左右节点中的大者与根节点进行交换（即：实现局部大顶堆）
MaxHeapify(arr, large, heapSize);//以上次调整动作的large位置（为此次调整的根节点位置），进行递归调整
}
}
/// <summary>
/// 交换函数
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
private static void Swap(ref int a,ref int b)
{ int temp = 0;
temp = a;
a = b;
b = temp;
}
{
int[] arr = new int[] { 5,2,7,3,6,1,4 };
int n = arr.Length;
ShowNum("排序前", arr);
HeapSort(arr);
ShowNum("堆排序后", arr);
Console.WriteLine("");
}
8. 计数排序
8.1 算法步骤
花O(n)的时间扫描一下整个序列 A，获取最小值 min 和最大值 max
开辟一块新的空间创建新的数组 B，长度为 ( max - min + 1)
数组 B 中 index 的元素记录的值是 A 中某元素出现的次数
最后输出目标整数序列，具体的逻辑是遍历数组 B，输出相应元素以及对应的个数
8.2 动画演示
image
8.3 参考代码
/// <summary>
/// 计数排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="n"></param>
static void CountingSort(int[]arr, int n)
{
int min = arr[0];
int max = min;
foreach (int number in arr)
{
if (number > max) { max = number; }
else if (number < min) { min = number; }
}
int[] counting = new int[max - min + 1];
for (int i = 0; i < n; i++)
{
counting[arr[i] - min] += 1;
}
int index = -1;
for (int i = 0; i < counting.Length; i++)
{
for (int j = 0; j < counting[i]; j++)
{
index++;
arr[index] = i + min;
}
}
}
{
int[] arr = new int[] { 5,3,4,7,2,4,3,4,7 };
int n = arr.Length;
ShowNum("排序前", arr);
CountingSort(arr, n);
ShowNum("计数排序后", arr);
Console.WriteLine("");
}
9. 桶排序
9.1 算法步骤
设置固定数量的空桶。
把数据放到对应的桶中。
对每个不为空的桶中数据进行排序。
拼接不为空的桶中数据，得到结果
9.2 动画演示
9.3 参考代码
/// <summary>
/// 桶排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="bucketCount">桶数</param>
/// <returns></returns>
static void BucketSort(int[] arr,int bucketCount)
{
int bucketSize = (arr.Max() - arr.Min()) / bucketCount + 1; // 桶
LinkedList<int>[] bucket = new LinkedList<int>[bucketCount];
// 初始化桶
for (int i = 0; i < bucketCount; i++)
{
bucket[i] = new LinkedList<int>();
} // 元素分装到各桶
for (int i = 0; i < arr.Length; i++)
{ int bucketIndex = (arr[i]-arr.Min())/ bucketSize;//arr[i] 的值放入第Index的桶中（Index值 从0 到 buckectCount-1） // 添加并进行插入排序
InsertToLinkList(bucket[bucketIndex], arr[i]);
} // 各桶排序
int index = 0;
for (int i = 0; i < bucketCount; i++)
{
foreach (var item in bucket[i])
{
arr[index++] = item;
}
} } /// <summary>
/// 按升序插入
/// </summary>
/// <param name="linkedList">要排序的链表</param>
/// <param name="num">要插入排序的数字</param>
private static void InsertToLinkList(LinkedList<int> linkedList, int num)
{
if (linkedList.Count == 0)
{
linkedList.AddFirst(num);
return;
} var minValue = linkedList.Min(); var minNode = linkedList.Find(minValue);
var maxValue = linkedList.Max(); var maxNode = linkedList.Find(maxValue);
if (num < minValue)
{
linkedList.AddBefore(minNode, num);
return;
}
if (num >maxValue)
{
linkedList.AddAfter(maxNode, num);
return;
}
else
{
for (int i = 0; i < linkedList.Count-1; i++)
{
if (linkedList.ElementAt(i) <= num && linkedList.ElementAt(i+1)>=num)
{
LinkedListNode<int> node = linkedList.FindLast(linkedList.ElementAt(i));
linkedList.AddAfter(node, num);
return;
}
}
} }
{
int[] arr = new int[] {7,12,56,23,19,33,35,42,42,2,8,22,39,26,17 };
int n = arr.Length;
ShowNum("排序前", arr);
BucketSort(arr, 5);
ShowNum("桶排序后", arr);
Console.WriteLine("");
}
10. 基数排序
10.1 算法步骤
将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零
从最低位开始，依次进行一次排序
从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列
10.2 动画演示
image
10.3 参考代码
/// <summary>
/// 基数排序，从小到大
/// </summary>
/// <param name="arr"></param>
/// <param name="bucketNum">桶数</param>
static void RadixSort(int[]arr,int bucketNum)
{
int maxLength = MaxLength(arr);
//创建bucket时，在二维中增加一组标识位，其中bucket[x, 0]表示这一维所包含的数字的个数
//通过这样的技巧可以少写很多代码 int[,] bucket = new int[bucketNum, arr.Length + 1];
for (int i = 0; i < maxLength; i++)
{
foreach (var item in arr)
{
int bit = (int)(item / Math.Pow(10, i) % 10);
bucket[bit, ++bucket[bit, 0]] = item;
}
for (int count = 0,j=0; j < bucketNum; j++)
{
for (int k = 1; k <= bucket[j,0]; k++)
{
arr[count++] = bucket[j, k];
}
}
// //最后要重置这个标识
for (int j = 0; j < bucketNum; j++)
{
bucket[j, 0] = 0;
}
}
} private static int MaxLength(int[] arr)
{
if (arr.Length == 0) return 0;
int max = arr[0];
for (int i = 1; i < arr.Length; i++)
{
if (arr[i] > max) max = arr[i];
}
int count = 0;
while (max != 0)
{
max /= 10;
count++;
}
return count;
// return (int)Math.Log10(max)+1;
}
{
int[] arr = new int[] { 1, 10, 321, 127, 743, 60, 577 };
int n = arr.Length;
ShowNum("排序前", arr);
RadixSort(arr, 10);
ShowNum("基数排序后", arr);
Console.WriteLine("");
}
GitHub Repo：Sort Article
Follow: MisterBooo · GitHub
内容改写自： https://www.cnblogs.com/fivestudy/p/10212306.html
C#语言 十大经典排序算法动画与解析！（动态演示+代码）(java改写成C# )的更多相关文章
- JavaScript 数据结构与算法之美 - 十大经典排序算法汇总（图文并茂）
1. 前言 算法为王. 想学好前端,先练好内功,内功不行,就算招式练的再花哨,终究成不了高手:只有内功深厚者,前端之路才会走得更远. 笔者写的 JavaScript 数据结构与算法之美 系列用的语言是 ...
- 十大经典排序算法的 JavaScript 实现
计算机领域的都多少掌握一点算法知识,其中排序算法是<数据结构与算法>中最基本的算法之一.排序算法可以分为内部排序和外部排序,内部排序是数据记录在内存中进行排序,而外部排序是因排序的数据很大 ...
- 一文搞定十大经典排序算法（Java实现）
本文总结十大经典排序算法及变形,并提供Java实现. 参考文章: 十大经典排序算法总结(Java语言实现) 快速排序算法—左右指针法,挖坑法,前后指针法,递归和非递归 快速排序及优化(三路划分等) 一 ...
- 十大经典排序算法(Javascript实现)
前言 总括: 本文结合动图详细讲述了十大经典排序算法用Javascript实现的过程. 原文博客地址:十大经典排序算法 公众号:「菜鸟学前端」,回复「666」,获取一揽子前端技术书籍 人生有情泪沾衣, ...
- 十大经典排序算法（java实现、配图解，附源码)
前言: 本文章主要是讲解我个人在学习Java开发环境的排序算法时做的一些准备,以及个人的心得体会,汇集成本篇文章,作为自己对排序算法理解的总结与笔记. 内容主要是关于十大经典排序算法的简介.原理.动静 ...
- 十大经典排序算法（python实现）（原创）
个人最喜欢的排序方法是非比较类的计数排序,简单粗暴.专治花里胡哨!!! 使用场景: 1,空间复杂度 越低越好.n值较大: 堆排序 O(nlog2n) O(1) 2,无空间复杂度要求.n值较大: 桶排序 ...
- 十大经典排序算法+sort排序
本文转自:十大经典排序算法,其中有动图+代码详解,本文简单介绍+个人理解. 排序算法 经典的算法问题,也是面试过程中经常被问到的问题.排序算法简单分类如下: 这些排序算法的时间复杂度等参数如下: 其中 ...
- 十大经典排序算法最强总结（含JAVA代码实现）(转)
十大经典排序算法最强总结(含JAVA代码实现) 最近几天在研究排序算法,看了很多博客,发现网上有的文章中对排序算法解释的并不是很透彻,而且有很多代码都是错误的,例如有的文章中在“桶排序”算法中对每 ...
- python实现十大经典排序算法
Python实现十大经典排序算法 代码最后面会给出完整版,或者可以从我的Githubfork,想看动图的同学可以去这里看看: 小结: 运行方式,将最后面的代码copy出去,直接python sort. ...
- 用Python实现十大经典排序算法-插入、选择、快速、冒泡、归并等
本文来用图文的方式详细讲解了Python十大经典排序算法 —— 插入排序.选择排序.快速排序.冒泡排序.归并排序.希尔排序.插入排序.桶排序.基数排序.计数排序算法,想要学习的你们,继续阅读下去吧,如 ...
随机推荐
- [ABC261F] Sorting Color Balls
Problem Statement There are $N$ balls arranged from left to right. The color of the $i$-th ball from ...
- VUE2.0 学习 第一组
本笔记主要参考菜鸟教程和官方文档编写. 1. 对于Vue2.0来说每个vue应用都需要实例化vue来实现. var vm = new Vue({ // 选项 }) 2.首先,DOM是一种api,它可以 ...
- Java并发(十九)----Monitor原理及Synchronized原理
1.Java 对象头 以 32 位虚拟机为例 普通对象 |--------------------------------------------------------------| | ...
- 【C#】【IO】【Threading】【实例】工作报表前的本地数据聚合操作
<工作记录--Report> 报表前的数据获取操作是高重复性的,今天差不多完成了脚本,下述是代码: 1 // See https://aka.ms/new-console-template ...
- 持续集成Jenkins
一.简单慨念 持续集成(Continuous integration,简称 CI),随着近几年的发展,持续集成在项目中 得到了广泛的推广和应用. 软件集成就是用一种较好的方式,使多种软件的功能集成到一 ...
- 带你了解TensorFlow pb模型常用处理方法
摘要:TensorFlow 模型训练完成后,通常会通过frozen过程保存一个最终的pb模型. 本文分享自华为云社区<TensorFlow pb模型修改和优化>,作者:luchangli. ...
- 教你3种Kafka的指定副本作为Leader的实现方式
摘要:因为在我们实际的运维过程中,需要指定某个副本为ISR,但是Kafka中的Leader选举策略并不支持这个功能,所以需要我们自己来实现它. 本文分享自华为云社区<Kafka的指定副本作为Le ...
- iOS应用程序发布流程：从测试到上架的完整指南
目录 转载:iOS应用程序的签名.重签名和安装测试 前言 打开要处理的IPA文件 设置签名使用的证书和描述文件 开始ios ipa重签名 转载:iOS应用程序的签名.重签名和安装测试 前言 ipa ...
- A/B测试有哪些常见应用场景？——火山引擎DataTester科普
更多技术交流.求职机会,欢迎关注字节跳动数据平台微信公众号,回复[1]进入官方交流群 火山引擎 DataTester不仅对外提供服务,也是字节跳动内部所应用的A/B实验平台,它基于先进的底层算法, ...
- TeamX 引擎的高并发能力测试
TeamX,是基于 SolonJT 引擎构建的一个团队协工具.主要功能有: Wiki(团队词条,用于写接口文档也行...) Planned(项目计划 和 个人日志) 比较兄弟产品,区别会很大:基于表格 ...