2021-10-20-《C#数据结构与算法》-学习笔记-P59-P69 排序算法

已于 2022-06-25 10:26:37 修改
阅读量136 收藏 1
点赞数
分类专栏： 《C#数据结构与算法》 文章标签： 算法 数据结构 c#
于 2021-10-20 21:08:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49079904/article/details/120874066
版权

总结

1.视频资源P59-P66：
https://www.bilibili.com/video/BV1gE41157pC?p=8&spm_id_from=pageDriver

2.学习内容：
1）冒泡排序 P59；
2）泛型冒泡排序 P60；
3）选择排序 P61；
4）排序算法测试辅助工具 P62；
5）插入排序 P63；
6）归并排序的归并过程 P64；
7）归并排序及递归调用 P65；
8）归并排序优化 P66；
9）快速排序 P67；
10）随机化快速排序 P68；
11）三向切分的随机化快速排序 P69。

2021/11/07、08、09、10、11回溯
紫色笔为回溯后增加
1）根据伪代码编写冒泡排序算法类；
2）根据伪代码编写选择、插入（自己也写了一个方法）排序算法类；
3）根据伪代码编写归并排序版本1类;
4）根据伪代码编写归并排序版本优化类（递归调用部分）；
5）根据伪代码编写快速排序类。

具体内容

P59 冒泡排序
1、冒泡排序思想；
2、新建项目；
3、新建冒泡排序类。

在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class BubbleSort
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n - 1 - i; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        Swap(arr, j, j + 1);
                    }
                }
            }
        }

        public static void Swap(int[] arr ,int i,int j)
        {
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

P60 泛型冒泡排序
1、新建泛型冒泡排序类；
2、自定义数据类型排序。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class BubbleSortGeneric
    {
        public static void Sort<E>(E[] arr) where E:IComparable<E>
        {
            int n = arr.Length;

            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n - 1 - i; j++)
                {
                    if (arr[j].CompareTo( arr[j + 1])>0)
                    {
                        Swap(arr, j, j + 1);
                    }
                }
            }
        }

        public static void Swap<E>(E[] arr, int i, int j)
        {
            E c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Text;

namespace Sorting
{
    class Data:IComparable<Data>
    {
        private int year;
        private int month;
        private int day;
        private string happen;

        public Data(int year, int month,int day, string happen)
        {
            this.year = year;
            this.month = month;
            this.day = day;
            this.happen = happen;
        }
        public int CompareTo([AllowNull] Data other)
        {
            //返回值 < 0 放在前面
            //返回值 > 0 放在后面
            //返回值 = 0 按顺序
            if (this.year >other.year)
            {
                return 1;
            }
            if (this.year < other.year)
            {
                return -1;
            }
            if (this.month > other.month)
            {
                return 1;
            }
            if (this.month < other.month)
            {
                return -1;
            }
            if (this.day > other.day)
            {
                return 1;
            }
            if (this.day < other.day)
            {
                return -1;
            }
            return 0;
        }

        public override string ToString()
        {
            return year + "/" + month + "/" + day + ":" + happen;
        }
    }
}

P61 选择排序
1、选择排序思想；
2、新建选择排序类。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class SelectSort
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            for (int i = 0; i < n; i++)
            {
                int min = i;
                for (int j = i+1; j < n; j++)
                {
                    if (arr[j] < arr[min])
                    {
                        min = j;
                    }
                }
                Swap(arr, i, min);
            }
        }
        public static void Swap(int[] arr, int i, int j)
        {
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

P62 排序算法测试辅助工具

在这里插入图片描述

P63 插入排序
1、插入排序思想；
2、新建插入排序类；
3、比较选择排序与插入排序性能

在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class InsertSort
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            //方法一：
            for (int i = 1; i < n; i++)
            {
                for (int j = i; j > 0; j--)
                {
                    if (arr[j] < arr[j - 1])
                    {
                        Swap(arr, j, j - 1);
                    }
                }
            }

            //方法二：

            //for (int i = 1; i < n; i++)
            //{
            //    int e = arr[i];
            //    for (int j = i; j > 0; j--)
            //    {
            //        if (e < arr[j - 1])
            //        {
            //            arr[i] = arr[j - 1];
            //            //Swap(arr, j, j - 1);
            //        }
            //        else
            //        {
            //            break;
            //        }
            //    }
            //}
        }
        public static void Swap(int[] arr, int i, int j)
        {
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

P64 归并排序的归并过程
1、归并排序思想；
2、新建归并排序类。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class MergeSort1
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            int[] temp =new int[n];

            Sort(arr, temp, 0, n-1) ;
        }

        private static void Sort(int[] arr, int[] temp, int l, int r)
        {
            int mid = ((r - l) + l) / 2;
            mergeSort(arr, temp, l, mid, r);
        }
        private static void mergeSort(int[] arr, int[] temp, int l, int mid, int r)
        {
            int i = l;
            int j = mid + 1;
            int k = l;

            //左右半边均有元素
            while (i <= mid && j <= r)
            {
                if (arr[i] < arr[j])
                {
                    temp[k] = arr[i];
                    k++;
                    i++;
                }
                else
                {
                    temp[k] = arr[j];
                    k++;
                    j++;
                }
            }
            //左半边有元素，右半边无元素
            while (i <= mid && j > r)
            {
                temp[k] = arr[i];
                k++;
                i++;
            }
            //左半边无元素，右半边有元素
            while (i > mid && j <= r)
            {
                temp[k] = arr[j];
                k++;
                j++;
            }

            //将temp数组放进arr数组中
            for (int z = l; z <= r; z++)
            {
                arr[z] = temp[z];
            }
        }
    }
}

P65 归并排序及递归调用
1、保证左右有序；
2、递归分割数组；
3、优化P64归并排序类；
4、对递归过程进行讲解；
5、归并排序性能分析；
6、比较归并排序与插入排序性能。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class MergeSort1Pluse
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            int[] temp =new int[n];

            Sort(arr, temp, 0, n-1) ;
        }

        private static void Sort(int[] arr, int[] temp, int l, int r)
        {
        	if (r<=l)
            {
                return;
            }
            int mid = l + (r - l) / 2;
            Sort(arr, temp, l, mid);
            Sort(arr, temp, mid+1, r);
            mergeSort(arr, temp, l, mid, r);
        }
        private static void mergeSort(int[] arr, int[] temp, int l, int mid, int r)
        {
            int i = l;
            int j = mid + 1;
            int k = l;

            //左右半边均有元素
            while (i <= mid && j <= r)
            {
                if (arr[i] < arr[j])
                {
                    temp[k] = arr[i];
                    k++;
                    i++;
                }
                else
                {
                    temp[k] = arr[j];
                    k++;
                    j++;
                }
            }
            //左半边有元素，右半边无元素
            while (i <= mid && j > r)
            {
                temp[k] = arr[i];
                k++;
                i++;
            }
            //左半边无元素，右半边有元素
            while (i > mid && j <= r)
            {
                temp[k] = arr[j];
                k++;
                j++;
            }

            //将temp数组放进arr数组中
            for (int z = l; z <= r; z++)
            {
                arr[z] = temp[z];
            }
        }
    }
}

在这里插入图片描述

P66 归并排序优化
1、新建第二版归并排序类；
2、比较优化前后归并排序性能；
3、测试几乎为有序数组时归并排序性能。

在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class MergeSort2
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;
            int[] temp =new int[n];

            Sort(arr, temp, 0, n-1) ;
        }

        private static void Sort(int[] arr, int[] temp, int l, int r)
        {
            //优化1：小规模数组使用插入排序，减小递归带来的损耗
            if (r - l + 1 < 15)
            {
                InsertSort.Sort1(arr,l,r);
                return;
            }
            else
            {
                int mid = l + (r - l) / 2;
                Sort(arr, temp, l, mid);
                Sort(arr, temp, mid + 1, r);

                //优化2：数组有序时使用插入排序
                if (arr[mid]>arr[mid+1])
                {
                    mergeSort(arr, temp, l, mid, r);
                }
            }
        }
        private static void mergeSort(int[] arr, int[] temp, int l, int mid, int r)
        {
            int i = l;
            int j = mid + 1;
            int k = l;

            //左右半边均有元素
            while (i <= mid && j <= r)
            {
                if (arr[i] < arr[j])
                {
                    temp[k] = arr[i];
                    k++;
                    i++;
                }
                else
                {
                    temp[k] = arr[j];
                    k++;
                    j++;
                }
            }
            //左半边有元素，右半边无元素
            while (i <= mid && j > r)
            {
                temp[k] = arr[i];
                k++;
                i++;
            }
            //左半边无元素，右半边有元素
            while (i > mid && j <= r)
            {
                temp[k] = arr[j];
                k++;
                j++;
            }

            //将temp数组放进arr数组中
            for (int z = l; z <= r; z++)
            {
                arr[z] = temp[z];
            }
        }
    }
}

P67 快速排序
1、快速排序思想；
2、新建快速排序1类；
3、性能比较：优化归并排序、快速排序1；
4、可读性问题。

在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class QuickSort1
    {
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            quickSort(arr,0, n - 1);
        }

        private static void quickSort(int[] arr, int l, int r)
        {
            if (r - l + 1 < 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int v = arr[l];

            int j = l;//arr[l+1...l]<v  arr[j+1...i-1]>v
            int i = l + 1;
            while (i <= r)
            {
                if (arr[i] >= v)
                {
                    i++;
                }
                else
                {
                    j++;
                    Swap(arr, i, j);
                }
            }
            Swap(arr, l, j);
            quickSort(arr, l, j);
            quickSort(arr, j + 1, r);
        }
        public static void Swap(int[] arr, int i, int j)
        {
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

P68 随机化快速排序
1、快速排序理想情况；
2、快速排序最不理想情况；
3、新建快速排序2类。

在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class QuickSort2
    {
        private static Random rd = new Random();
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            quickSort(arr,0, n - 1);
        }

        private static void quickSort(int[] arr, int l, int r)
        {
            if (r - l + 1 < 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int p = l + rd.Next(r - l + 1);//取不到括号中的值，所以r - l 还要+ 1才对

            Swap(arr, l, p);

            int v = arr[l];

            int j = l;//arr[l+1...l]<v  arr[j+1...i-1]>v
            int i = l + 1;
            while (i <= r)
            {
                if (arr[i] >= v)
                {
                    i++;
                }
                else
                {
                    j++;
                    Swap(arr, i, j);
                }
            }
            Swap(arr, l, j);
            quickSort(arr, l, j);
            quickSort(arr, j + 1, r);
        }
        public static void Swap(int[] arr, int i, int j)
        {
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

P69 三向切分的随机化快速排序
1、问题引出；
2、解决方案：三向切分；
3、新建快速排序3类；
4、性能比较：快速排序1、2、3类。

在这里插入图片描述
在这里插入图片描述

using System;
using System.Collections.Generic;
using System.Text;

namespace Sorting
{
    class QuickSort3
    {
        private static Random rd = new Random();
        public static void Sort(int[] arr)
        {
            int n = arr.Length;

            quickSort(arr,0, n - 1);
        }

        private static void quickSort(int[] arr, int l, int r)
        {
            if (r - l + 1 < 15)
            {
                InsertSort.Sort1(arr, l, r);
                return;
            }

            int p = l + rd.Next(r - l + 1);

            Swap(arr, l, p);

            int v = arr[l];

            int lt = l;//arr[l+1...lt] < v
            int i = l + 1;//arr[lt+1...i-1] = v
            int gt = r + 1; //arr[gt...r] > v

            while (i <gt)
            {
                if (arr[i] > v)
                {
                    gt--;
                    Swap(arr, i, gt);
                }

                if (arr[i] < v)
                {
                    lt++;
                    Swap(arr, i, lt);
                    i++;
                }

                if (arr[i] == v)
                {
                    i++;
                }
            }

            Swap(arr, l, lt);
            quickSort(arr, l, lt-1);
            quickSort(arr, gt, r);
        }
        public static void Swap(int[] arr, int i, int j)
        {
            int c = arr[i];
            arr[i] = arr[j];
            arr[j] = c;
        }
    }
}

在这里插入图片描述

Joy_ou悠
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021-06-18-刘铁猛C#语言入门详解-学习笔记P19委托
weixin_49079904的博客
06-18 711
P19委托 一、P18内容总结 介绍委托 委托的声明 委托的使用 二、什么是委托delegate 委托是函数指针的升级版 1）举例说明：C/C++中的函数指针 程序员常提及的概念：一切皆地址 1）变量（数据）是以某个地址为起点的一段内存中所存储的值 解释：数据存储在变量中，变量的本质：以变量名所对应的内存地址为起点的一段内存[存储着变量的数据]，内存的大小由数据类型决定 2）函数（算法）是以某个地址为起点的一段内存中所存储的一组机器语言指令 函数的本质：以函数名所对应的内存地址为起点的一段内存，在这段
数据结构之排序算法！！看这一篇(配动图理解)
Y_1215的博客
01-21 1369
包含递归和非递归哦
简历信息提取算法-学习笔记（二）
weixin_42189651的博客
02-27 925
本文是的AIStduio 简历解析系列文章的学习笔记。 NLP入门学习笔记
路径规划算法--Dijkstra算法，A*算法，CBS算法
风的季节
04-04 7325
路径规划算法 一、A*算法总结 基本思想 A算法把Dijkstra算法（靠近初始点的结点）和最佳优先搜索算法（BFS）（靠近目标点的结点）的信息块结合起来。 在讨论A算法的标准术语中，g(n)表示从初始结点到任意结点n的代价，h(n)表示从节点n到目标点的启发式评估代价，当从初始点向目标点移动时，A*权衡这两者。每次进行主循环时，它检查f(n)最小的结点n，其中f(n)=g(n) + h(n)....
非线性回归算法--学习笔记
oneself的博客
10-30 559
非线性回归算法--学习笔记
机器学习-最小二乘拟合
qq_32649321的博客
03-07 3382
0.前言 解决非线性问题的方法： 这里主要记录Levenberg-Marquardt算法学习笔记！ 1.Levenberg-Marquardt算法介绍 基本原理： 计算当C最小时对应的函数参数。 Levenberg-Marquardt（LM）是一种用于解决非线性最小二乘问题的算法，当通过最小化数据点与函数之间误差的平方和来拟合参数化函数到一组测量数据点时，就会出现最小二乘问题。 Levenberg-Marquardt曲线拟合方法实际上是两种最小化方法的结合:梯度下降法（ gradient desce
（超简单、超易懂、超详细）算法精讲(二十四)：福特-富尔克森算法
Malex2024的博客
06-23 980
福特-富尔克森算法（Ford-Fulkerson Algorithm）是一种用于解决网络流问题的算法，由L.R. Ford和D.R. Fulkerson于1956年提出。该算法基于残余网络的概念，通过不断地寻找增广路径来寻找最大流。网络流问题是指在一个有向图中，每条边都有一个容量限制，同时有一个源节点和一个汇节点，要求从源节点向汇节点发送最大流量的问题。福特-富尔克森算法的基本思想是不断地寻找增广路径，并沿着增广路径更新网络中的流量。
C# 学习笔记--个人学习使用 ＜1＞
Kuang Da's Blog
08-21 1478
个人用的学习笔记
KNN算法-学习笔记整理
码python的Vinsmoke
05-30 2249
机器学习算法 机器学习算法是一类从数据中自动分析获得规律（模型），并利用规律对未知数据进行预测的算法 开发机器学习应用程序的步骤 收集数据 可以使用很多方法收集样本数据，如：制作网络爬虫从网站上抽取数据、从RSS反馈或者API中得到信息、设备发送过来的实测数据。 准备输入数据 得到数据之后，还必须确保数据格式符合要求。 分析输入数据 这一步的主要作用是确保数据集中没有垃圾数据。如果是使用信任的数据来源，那么可以直接跳过这个步骤 训练算法 机器学习算法从这一步才真正开始学习。如果使用无监督学习算法，由于不存
【算法】C#实现经典排序算法总结（附动图）
好学若饥，谦卑若愚。
01-31 3113
自行整理的C#常见算法笔记。
ML.NET-Jupyter-Notebooks：一些涵盖ML.NET方案的C＃Jupyter笔记本
02-04
通过研究这些笔记本，你可以学习到如何在C#环境中加载数据、选择合适的算法、调整模型参数、评估模型性能以及最终部署模型。此外，还可以了解到如何利用Jupyter Notebook的强大功能来增强你的机器学习实践。 总结...
《Hello 算法》数据结构与算法教程，支持 Java, C++, Python, Go, JS, TS, C#
12-30
数据结构学习资料分享 内容概览： 本次分享包涵了大学计算机相关专业必学的“数据结构”课程的一系列学习资料。主要包括： 算法代码：我们提供了多种数据结构的实现代码，包括数组、链表、栈、队列、树、图等。...
leetcode单词接龙2-Algorithms:算法学习笔记
06-30
leetcode单词接龙2 Algorithms 算法学习笔记 目录 leetcode刷题笔记 数组 排序算法 链表 反转 关系题型整理 股票买卖 矩形面积或装水问题 子序列问题 排列组合 栈 队列 树 基础遍历 BFS DFS 回溯 动态规划
C#图像处理程序实现--PCA（低维）算法笔记整理 Eigenvalue.rar
03-10
本笔记将详细讲解如何在C#中实现PCA算法，并通过实例来阐述PCA如何用于图像处理。 PCA的主要目标是将原始高维数据转换为一组线性无关的新坐标系，即主成分，新坐标系中的各轴按照数据方差大小排序，前几个主成分...
数据结构与算法（C#语言描述）.zip
06-17
大学生数据结构学习笔记和资料大全！
day54--面试专题（基础篇）
ZHUSHANGLIN的博客
06-28 1068
有一个有序表为 1,5,8,11,19,22,31,35,40,45,48,49,50 当二分查找值为 48 的结点时，查找成功需要比较的次数。使用二分法在序列 1,4,6,7,15,33,39,50,64,78,75,81,89,96 中查找元素 81 时，需要经过（ ）次比较。② A[M] > T，中间值右侧的其它元素都大于 T，无需比较，中间索引左边去找，M - 1 设置为右边界，重新查找。将数组分为两个子集，排序的和未排序的，每一轮从未排序的子集中选出最小的元素，放入排序子集。
2-18 基于matlab的关于联合对角化盲源分离算法的二阶盲识别（SOBI）算法
m0_59476991的博客
06-28 238
基于matlab的关于联合对角化盲源分离算法的二阶盲识别（SOBI）算法。通过联合对角化逼近解混矩阵。构建的四组信号，并通过认为设置添加噪声比例，掩盖信号信息。通过SOBI算法实现了解混。程序已调通，可直接运行。
算法总结-栈和队列
qq_66230764的博客
06-28 289
1.栈实现队列思路：两个栈实现，一个出一个进。pop() 把sin的元素出栈赋值给sout，赋值完后sout pop的第一个就是队头元素peek() 直接调用上述实现的pop函数思路：单个队列实现。pop：把队列的头元素依次插入到队尾，除了最后一个（这个元素是要pop出去的）。top：直接调用队列的back方法思路：用栈来实现，遍历s对于每一个左括号，栈里push进一个相应的右括号。两种失败情况，如果栈的top和s[i]相等就返回true。
【408考点之数据结构】顺序查找和折半查找
最新发布
gygkhd的博客
07-01 367
顺序查找（Sequential Search），也称线性查找，是一种最简单、最直接的查找方法。它从数据集的第一个元素开始，逐个检查每个元素，直到找到目标元素或检查完整个数据集。
电脑销售管理系统-数据库课程设计.doc
12-20
5. 数据库连接：系统需使用C#与SQL Server 2008进行数据连接，这涉及到ADO.NET或其他数据访问技术，如Entity Framework，用于在应用程序和数据库之间传递数据。 6. 功能实现：系统需实现商品信息的查询、修改、插入...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值