algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-11-02 12:58:42 +08:00
Code Issues Packages Projects Releases Wiki Activity

完善所以c#相关的文档和代码

Browse Source
This commit is contained in:
zhuzhiqing
2022-12-23 15:42:02 +08:00
parent 1646c284f6
commit a427cb1b4d
48 changed files with 4325 additions and 65 deletions
Download Patch File Download Diff File Expand all files Collapse all files

67
codes/csharp/chapter_sorting/bubble_sort.cs Normal file
View File

@ -0,0 +1,67 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace hello_algo.chapter_sorting
{
public class bubble_sort
{
/* 冒泡排序 */
static void bubbleSort(int[] nums)
{
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = nums.Length - 1; i > 0; i--)
{
// 内循环：冒泡操作
for (int j = 0; j < i; j++)
{
if (nums[j] > nums[j + 1])
{
// 交换 nums[j] 与 nums[j + 1]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
}
}
}
}
/* 冒泡排序（标志优化）*/
static void bubbleSortWithFlag(int[] nums)
{
// 外循环：待排序元素数量为 n-1, n-2, ..., 1
for (int i = nums.Length - 1; i > 0; i--)
{
bool flag = false; // 初始化标志位
// 内循环：冒泡操作
for (int j = 0; j < i; j++)
{
if (nums[j] > nums[j + 1])
{
// 交换 nums[j] 与 nums[j + 1]
int tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
flag = true; // 记录交换元素
}
}
if (!flag) break; // 此轮冒泡未交换任何元素，直接跳出
}
}
[Test]
public void Test()
{
int[] nums = { 4, 1, 3, 1, 5, 2 };
bubbleSort(nums);
Console.WriteLine("冒泡排序完成后 nums = " + string.Join(",",nums));
int[] nums1 = { 4, 1, 3, 1, 5, 2 };
bubbleSortWithFlag(nums1);
Console.WriteLine("冒泡排序完成后 nums1 = " + string.Join(",", nums));
}
}
}

32
codes/csharp/chapter_sorting/insertion_sort.cs Normal file
View File

@ -0,0 +1,32 @@
using NUnit.Framework;
namespace hello_algo.chapter_sorting
{
public class insertion_sort
{
/* 插入排序 */
static void insertionSort(int[] nums)
{
// 外循环：base = nums[1], nums[2], ..., nums[n-1]
for (int i = 1; i < nums.Length; i++)
{
int bas = nums[i], j = i - 1;
// 内循环：将 base 插入到左边的正确位置
while (j >= 0 && nums[j] > bas)
{
nums[j + 1] = nums[j]; // 1. 将 nums[j] 向右移动一位
j--;
}
nums[j + 1] = bas; // 2. 将 base 赋值到正确位置
}
}
[Test]
public void Test()
{
int[] nums = { 4, 1, 3, 1, 5, 2 };
insertionSort(nums);
Console.WriteLine("插入排序完成后 nums = " + string.Join(",", nums));
}
}
}

64
codes/csharp/chapter_sorting/merge_sort.cs Normal file
View File

@ -0,0 +1,64 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace hello_algo.chapter_sorting
{
public class merge_sort
{
/**
* 合并左子数组和右子数组
* 左子数组区间 [left, mid]
* 右子数组区间 [mid + 1, right]
*/
static void merge(int[] nums, int left, int mid, int right)
{
// 初始化辅助数组
int[] tmp = nums[left..(right + 1)];//Array.CopyOfRange(nums, left, right + 1);
// 左子数组的起始索引和结束索引
int leftStart = left - left, leftEnd = mid - left;
// 右子数组的起始索引和结束索引
int rightStart = mid + 1 - left, rightEnd = right - left;
// i, j 分别指向左子数组、右子数组的首元素
int i = leftStart, j = rightStart;
// 通过覆盖原数组 nums 来合并左子数组和右子数组
for (int k = left; k <= right; k++)
{
// 若“左子数组已全部合并完”，则选取右子数组元素，并且 j++
if (i > leftEnd)
nums[k] = tmp[j++];
// 否则，若“右子数组已全部合并完”或“左子数组元素 < 右子数组元素”，则选取左子数组元素，并且 i++
else if (j > rightEnd || tmp[i] <= tmp[j])
nums[k] = tmp[i++];
// 否则，若“左子数组元素 > 右子数组元素”，则选取右子数组元素，并且 j++
else
nums[k] = tmp[j++];
}
}
/* 归并排序 */
static void mergeSort(int[] nums, int left, int right)
{
// 终止条件
if (left >= right) return; // 当子数组长度为 1 时终止递归
// 划分阶段
int mid = (left + right) / 2; // 计算中点
mergeSort(nums, left, mid); // 递归左子数组
mergeSort(nums, mid + 1, right); // 递归右子数组
// 合并阶段
merge(nums, left, mid, right);
}
[Test]
public void Test()
{
/* 归并排序 */
int[] nums = { 7, 3, 2, 6, 0, 1, 5, 4 };
mergeSort(nums, 0, nums.Length - 1);
Console.WriteLine("归并排序完成后 nums = " + string.Join(",", nums));
}
}
}

182
codes/csharp/chapter_sorting/quick_sort.cs Normal file
View File

@ -0,0 +1,182 @@
using NUnit.Framework;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace hello_algo.chapter_sorting
{
class QuickSort
{
/* 元素交换 */
static void swap(int[] nums, int i, int j)
{
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵划分 */
static int partition(int[] nums, int left, int right)
{
// 以 nums[left] 作为基准数
int i = left, j = right;
while (i < j)
{
while (i < j && nums[j] >= nums[left])
j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left])
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
/* 快速排序 */
public static void quickSort(int[] nums, int left, int right)
{
// 子数组长度为 1 时终止递归
if (left >= right)
return;
// 哨兵划分
int pivot = partition(nums, left, right);
// 递归左子数组、右子数组
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
}
/* 快速排序类（中位基准数优化） */
class QuickSortMedian
{
/* 元素交换 */
static void swap(int[] nums, int i, int j)
{
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 选取三个元素的中位数 */
static int medianThree(int[] nums, int left, int mid, int right)
{
// 使用了异或操作来简化代码
// 异或规则为 0 ^ 0 = 1 ^ 1 = 0, 0 ^ 1 = 1 ^ 0 = 1
if ((nums[left] > nums[mid]) ^ (nums[left] > nums[right]))
return left;
else if ((nums[mid] < nums[left]) ^ (nums[mid] < nums[right]))
return mid;
else
return right;
}
/* 哨兵划分（三数取中值） */
static int partition(int[] nums, int left, int right)
{
// 选取三个候选元素的中位数
int med = medianThree(nums, left, (left + right) / 2, right);
// 将中位数交换至数组最左端
swap(nums, left, med);
// 以 nums[left] 作为基准数
int i = left, j = right;
while (i < j)
{
while (i < j && nums[j] >= nums[left])
j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left])
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
/* 快速排序 */
public static void quickSort(int[] nums, int left, int right)
{
// 子数组长度为 1 时终止递归
if (left >= right)
return;
// 哨兵划分
int pivot = partition(nums, left, right);
// 递归左子数组、右子数组
quickSort(nums, left, pivot - 1);
quickSort(nums, pivot + 1, right);
}
}
/* 快速排序类（尾递归优化） */
class QuickSortTailCall
{
/* 元素交换 */
static void swap(int[] nums, int i, int j)
{
int tmp = nums[i];
nums[i] = nums[j];
nums[j] = tmp;
}
/* 哨兵划分 */
static int partition(int[] nums, int left, int right)
{
// 以 nums[left] 作为基准数
int i = left, j = right;
while (i < j)
{
while (i < j && nums[j] >= nums[left])
j--; // 从右向左找首个小于基准数的元素
while (i < j && nums[i] <= nums[left])
i++; // 从左向右找首个大于基准数的元素
swap(nums, i, j); // 交换这两个元素
}
swap(nums, i, left); // 将基准数交换至两子数组的分界线
return i; // 返回基准数的索引
}
/* 快速排序（尾递归优化） */
public static void quickSort(int[] nums, int left, int right)
{
// 子数组长度为 1 时终止
while (left < right)
{
// 哨兵划分操作
int pivot = partition(nums, left, right);
// 对两个子数组中较短的那个执行快排
if (pivot - left < right - pivot)
{
quickSort(nums, left, pivot - 1); // 递归排序左子数组
left = pivot + 1; // 剩余待排序区间为 [pivot + 1, right]
}
else
{
quickSort(nums, pivot + 1, right); // 递归排序右子数组
right = pivot - 1; // 剩余待排序区间为 [left, pivot - 1]
}
}
}
}
public class quick_sort
{
[Test]
public void Test()
{
/* 快速排序 */
int[] nums = { 2, 4, 1, 0, 3, 5 };
QuickSort.quickSort(nums, 0, nums.Length - 1);
Console.WriteLine("快速排序完成后 nums = " + string.Join(",", nums));
/* 快速排序（中位基准数优化） */
int[] nums1 = { 2, 4, 1, 0, 3, 5 };
QuickSortMedian.quickSort(nums1, 0, nums1.Length - 1);
Console.WriteLine("快速排序（中位基准数优化）完成后 nums1 = " + string.Join(",", nums1));
/* 快速排序（尾递归优化） */
int[] nums2 = { 2, 4, 1, 0, 3, 5 };
QuickSortTailCall.quickSort(nums2, 0, nums2.Length - 1);
Console.WriteLine("快速排序（尾递归优化）完成后 nums2 = " + string.Join(",", nums2));
}
}
}