2021-10-07-《C#数据结构与算法》-学习笔记-P24-P30二分查找法与有序数组

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

总结

1.视频资源P24-P30：
https://www.bilibili.com/video/BV1gE41157pC?p=8&spm_id_from=pageDriver
2.学习内容：
Part1 查找算法
1）顺序查找（暴力查找）与二分查找P24；
2）顺序查找（暴力查找）与二分查找性能比较P25；

Part2 有序数组
3）新数据结构：有序数组P26-P28；
4）基于有序数组实现集合P29；
5）基于有序数组实现映射/字典P30。

Part3 2021/10/25、26回溯
1）根据伪代码编写程序；
2）二分查找法：mid=l+(r-l)/2

具体内容

Part1查找算法

P24 顺序查找（暴力查找）与二分查找
1、二分查找概念；
2、创建查找类；
3、编写静态二分查找方法；
4、查询算法复杂度分析。

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

//TestSearch类
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class TestSearch
    {
        public int BinarySearch(int[] arr,int target)
        {
            int l = 0;
            int r = arr.Length - 1;

            while (l<=r)
            {
                int mid = ((r - l) + l) / 2;
                if (arr[mid] < target)
                {
                    l = mid + 1;
                }
                else if (arr[mid] > target)
                {
                    r = mid - 1;
                }
                else
                {
                    return mid;
                }
            }
            return -1;
        }
    }
}

P25 查找算法性能比较

在这里插入图片描述

Part2有序数组

P26-28 有序数组及有序数组的创建
1、有序数组基本操作；
2、创建有序数组类；
3、实现有序数组Rank方法；
4、实现有序数组增、删元素方法；
5、实现有序数组相关方法。

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

//有序数组类
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class SortedArray1<Key> where Key : IComparable<Key>
    {
        private Key[] keys;
        private int N;

        public SortedArray1(int capacity)
        {
            keys = new Key[capacity];
        }

        public SortedArray1()
        {
            keys = new Key[10];
        }

        #region 返回数组容量、元素个数、判断数组是否为空
        //返回数组容量
        public int Capacity
        {
            get { return keys.Length; }
        }

        //返回数组中元素个数
        public int Count
        {
            get { return N; }
        }

        //判断数组是否为空
        public bool IsEmpty
        {
            get { return N == 0; }
        }
        #endregion


        public int Rank(Key key)
        {
            int l = 0;
            int r = N - 1;

            while (l <= r)
            {
                //这里的问题 有毒  写成了(l + (r - l) )/ 2
                int mid = l + (r - l) / 2;
                if (keys[mid].CompareTo(key) < 0)
                {
                    l = mid + 1;
                }
                else if (keys[mid].CompareTo(key) > 0)
                {
                    r = mid - 1;
                }
                else
                {
                    return mid;
                }
            }
            return l;
        }

        public void Add(Key key)
        {
            int index = Rank(key);
            
            if (N == keys.Length)
            {
                RestCapacity(keys.Length * 2);
            }

            if (index<N && keys[index].CompareTo(key)==0)
            {
                return;
            }

            else
            {
                for (int i = N-1 ; i >= index; i--)
                {
                    keys[i+1] = keys[i];
                }
                
                keys[index] = key;
                N++;
            }
        }

        public void Remove(Key key)
        {
            if (IsEmpty)
            {
                return;
            }

            int index = Rank(key);

            if (index < N && keys[index].CompareTo(key) != 0)
            {
                 return;
            }

            for (int i = index + 1; i < N; i++)
            {
                keys[i - 1] = keys[i];
            }
            N--;
            keys[N] = default(Key);

            if (N == keys.Length / 4)
            {
                RestCapacity(keys.Length / 2);
            }
        }

        #region 扩容操作
        private void RestCapacity(int newCapacity)
        {
            Key[] newKeys = new Key[newCapacity];

            for (int i = 0; i < N; i++)
            {
                newKeys[i] = keys[i];
            }
            keys = newKeys;
        }
        #endregion

        //重写 ToString()
        public override string ToString()
        {
            StringBuilder res = new StringBuilder();
            res.Append("[");
            for (int i = 0; i < N; i++)
            {
                res.Append(keys[i]);
                if (i != N - 1)
                {
                    res.Append(",");
                }
            }
            res.Append("]");
            return res.ToString();
        }

        //找到最小值
        public Key Min()
        {
            if (IsEmpty)
            {
                throw new ArgumentException("数组为空");
            }
            else
            {
                return keys[0];
            }
        }

        //找到最大值
        public Key Max()
        {
            if (IsEmpty)
            {
                throw new ArgumentException("数组为空");
            }
            else
            {
                return keys[N-1];
            }
        }

        //返回索引为k的键
        public Key Select(int k)
        {
            if (k<0 || k>=N)
            {
                throw new ArgumentException("数组索引异常");
            }
            else
            {
                return keys[k];
            }
        }

        //判断数组中是否包含值为key的键
        public bool Contains(Key key)
        {
            int index = Rank(key);

            if (index<N && keys[index].CompareTo(key) == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //找出小于或等于key的最大键
        public Key Floor(Key key)
        {
            int index = Rank(key);

            if (index < N && keys[index].CompareTo(key) == 0)
            {
                return keys[index];
            }
            if (index ==0)
            {
                throw new ArgumentException("不存在小于或等于key的最大键");
            }
            else
            {
                return keys[index-1];
            }
        }

        //找出大于或等于key的最小键
        public Key Ceiling(Key key)
        {
            int index = Rank(key);

            if (index == N)
            {
                throw new ArgumentException("不存在大于或等于key的最小键");
            }
            else
            {
                return keys[index +1];
            }
        }
    }
}

P29 基于有序数组实现集合
1、创建有序数组集合类；
2、比较链表实现集合与有序数组实现集合性能；

在这里插入图片描述

//有序数组集合类
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class SortedArray1Set<Key>  : ISet<Key> where Key : IComparable<Key>
    {
        private SortedArray1<Key> sortedArray1Set;
        public SortedArray1Set(int capacity)
        {
            sortedArray1Set = new SortedArray1<Key>();
        }

        public SortedArray1Set()
        {
            sortedArray1Set = new SortedArray1<Key>();
        }
        public int Count { get { return sortedArray1Set.Count;} }

        public bool IsEmpty { get { return sortedArray1Set.IsEmpty; } }

        public void Add(Key key)
        {
            sortedArray1Set.Add(key);
        }

        public bool Contains(Key key)
        {
            return sortedArray1Set.Contains(key);
        }

        public void Remove(Key key)
        {
            sortedArray1Set.Remove(key);
        }
    }
}

P30 基于有序数组实现映射/字典
1、更改有序数组类；
2、创建有序数组字典类；
2、比较链表实现字典与有序数组实现集字典性能；

在这里插入图片描述

//有序数组2类
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class SortedArray2<Key,Value> where Key : IComparable<Key>
    {
        private Key[] keys;
        private Value[] values;
        private int N;

        public SortedArray2(int capacity)
        {
            keys = new Key[capacity];
            values = new Value[capacity];
        }

        public SortedArray2()
        {
            keys = new Key[10];
            values = new Value[10];
        }

        #region 返回数组容量、元素个数、判断数组是否为空
        //返回数组容量
        public int Capacity
        {
            get { return keys.Length; }
        }

        //返回数组中元素个数
        public int Count
        {
            get { return N; }
        }

        //判断数组是否为空
        public bool IsEmpty
        {
            get { return N == 0; }
        }
        #endregion


        public int Rank(Key key)
        {
            int l = 0;
            int r = N - 1;

            while (l <= r)
            {
                //这里的问题 有毒  写成了(l + (r - l) )/ 2
                int mid = l + (r - l) / 2;
                if (keys[mid].CompareTo(key) < 0)
                {
                    l = mid + 1;
                }
                else if (keys[mid].CompareTo(key) > 0)
                {
                    r = mid - 1;
                }
                else
                {
                    return mid;
                }
            }
            return l;
        }

        public Value Get(Key key)
        {
            if (IsEmpty)
            {
                throw new ArgumentException("数组为空");
            }

            int index = Rank(key);
            if (index < N && keys[index].CompareTo(key) == 0)
            {
                return values[index];
            }

            else
            {
                throw new ArgumentException("该键不存在");
            }
        }

        public void Add(Key key,Value value)
        {
            int index = Rank(key);
            
            if (N == keys.Length)
            {
                RestCapacity(keys.Length * 2);
            }

            if (index<N && keys[index].CompareTo(key)==0)
            {
                values[index] = value;
                return;
            }

            else
            {
                for (int i = N-1 ; i >= index; i--)
                {
                    keys[i+1] = keys[i];
                    values[i + 1] = values[i];
                }
                
                keys[index] = key;
                values[index] = value;
                N++;
            }
        }

        public void Remove(Key key)
        {
            if (IsEmpty)
            {
                return;
            }

            int index = Rank(key);

            if (index < N && keys[index].CompareTo(key) != 0)
            {
                 return;
            }

            for (int i = index + 1; i < N; i++)
            {
                keys[i - 1] = keys[i];
                values[i - 1] = values[i];
            }

            N--;
            keys[N] = default(Key);
            values[N] = default(Value);

            if (N == keys.Length / 4)
            {
                RestCapacity(keys.Length / 2);
            }
        }

        #region 扩容操作
        private void RestCapacity(int newCapacity)
        {
            Key[] newKeys = new Key[newCapacity];
            Value[] newValues = new Value[newCapacity];

            for (int i = 0; i < N; i++)
            {
                newKeys[i] = keys[i];
                newValues[i] = values[i];
            }
            keys = newKeys;
            values = newValues;
        }
        #endregion

        //重写 ToString()
        public override string ToString()
        {
            StringBuilder res = new StringBuilder();
            res.Append("[");
            for (int i = 0; i < N; i++)
            {
                res.Append("{" + keys[i] + ","+values[i] +"}" );
                if (i != N - 1)
                {
                    res.Append(",");
                }
            }
            res.Append("]");
            return res.ToString();
        }

        //找到最小值
        public Key Min()
        {
            if (IsEmpty)
            {
                throw new ArgumentException("数组为空");
            }
            else
            {
                return keys[0];
            }
        }

        //找到最大值
        public Key Max()
        {
            if (IsEmpty)
            {
                throw new ArgumentException("数组为空");
            }
            else
            {
                return keys[N-1];
            }
        }

        //返回索引为k的键
        public Key Select(int k)
        {
            if (k<0 || k>=N)
            {
                throw new ArgumentException("数组索引异常");
            }
            else
            {
                return keys[k];
            }
        }

        //判断数组中是否包含值为key的键
        public bool Contains(Key key)
        {
            int index = Rank(key);

            if (index<N && keys[index].CompareTo(key) == 0)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        //找出小于或等于key的最大键
        public Key Floor(Key key)
        {
            int index = Rank(key);

            if (index < N && keys[index].CompareTo(key) == 0)
            {
                return keys[index];
            }
            if (index ==0)
            {
                throw new ArgumentException("不存在小于或等于key的最大键");
            }
            else
            {
                return keys[index-1];
            }
        }

        //找出大于或等于key的最小键
        public Key Ceiling(Key key)
        {
            int index = Rank(key);

            if (index == N)
            {
                throw new ArgumentException("不存在大于或等于key的最小键");
            }
            else
            {
                return keys[index +1];
            }
        }
    }
}

//有序数组字典类
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp1
{
    class SortedArray2Dictionary<Key,Value> : IDictionary<Key,Value> where Key : IComparable<Key>
    {
        private SortedArray2<Key, Value> sortedArray2Dictionary;

        public int Count { get { return sortedArray2Dictionary.Count; } }

        public bool IsEmpty { get { return sortedArray2Dictionary.IsEmpty; } }

        public SortedArray2Dictionary(int capacity)
        {
            sortedArray2Dictionary = new SortedArray2<Key, Value>(capacity);
        }

        public SortedArray2Dictionary()
        {
            sortedArray2Dictionary = new SortedArray2<Key, Value>();
        }

        public void Remove(Key key)
        {
            sortedArray2Dictionary.Remove(key);
        }

        public void Add(Key key, Value value)
        {
            sortedArray2Dictionary.Add(key,value);
        }

        public bool ContainsKey(Key key)
        {
            return sortedArray2Dictionary.Contains(key);
        }

        public Value Get(Key key)
        {
            return sortedArray2Dictionary.Get(key);
        }

        public void Set(Key key, Value newValue)
        {
            sortedArray2Dictionary.Add(key, newValue);
        }
    }
}
Joy_ou悠
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用C语言实现有序数组的二分查找
weixin_49449676的博客
04-16 2932
C语言实现二分查找
C#数据结构与算法学习笔记 有序数组和二分查找
Mr_Tfos的博客
05-20 260
1.二分查找和顺序查找 二分查找： class TestSearch { public static int BinarySearch(int[] arr, int target) { int l = 0; int r = arr.Length - 1; while (l <= r) { //int mid = (l +
二分查找（基于有序数组）
能能
09-01 4057
1、基本思想 2、算法实现 3、基于二分查找的有序符号表 4、性能分析 5、顺序查找和二分查找比较 1、基本思想 采用一对平行的数组，一个存储键一个存储值 实现的核心是 rank() 方法，它返回表中小于给定键的键的数量。 2、算法实现 二分查找法：将被查找的键和子数组的中间键比较。如果被查找的键小于中间键，就在左子数组中继续查找，如果大于就在右子数组中继...
实现有序列表（基于数组，二分查找）
thinking的专栏
03-05 1095
实现一个简单的有序列表，保证插入新数据时，列表依然有序，并且带有查找，删除功能。 查找功能使用了如下不同的方法： 顺序查找二分查找（使用了两种不同的二分查找写法） #ifndef _ORDERLIST_ #define _ORDERLIST_ #include #include using namespace std; template class OrderList
查找算法——二分查找-递归&非递归实现&找一个&找所有-推导&代码&测试
weixin_48017483的博客
12-26 115
查找算法——二分查找-递归&非递归实现&找一个&找所有-推导&代码&测试 二分查找仅对有序序列进行，时间复杂度O(log2 n) 递归实现思路：【递增排序为例】 1.确定该数组的中间的下标 mid=(left+right)/2 2.将所查找数findVal与arr[mid]进行比较： 2.1 findVal > arr[mid] => findVal应在mid右侧，向右递归查找 2.2 findVal < arr[mid] => findVal
二分查找之C#实现详解
enternalstar的博客
12-20 2652
【前置知识】 二分查找是对有序数组（向量）而言的，所以在使用二分查找前要确保数组已经是顺序的（用到排序算法）。 【二分查找原理】 聚会时通常会玩猜数字的游戏： 先由坐庄的人来写一个数字(比如在1~1000之内) 让大家轮流猜，并告诉大家正确数字比当前猜的数字大或者小 每猜一次范围就会缩小，最后猜中的人倒霉挨罚 二分查找要求只能猜中位数，每次让猜的范围缩小一半，这样很快就能猜中，也即很快...
SJG09-008变频扶梯调试手册03（电气部分）.pdf
02-20
二、变频器PG卡的安装及接线 * PG卡的型号：FU-04 TM2 * 安装PG卡时，必须先使变频器输入电源处于OFF状态，然后将PG卡的接插件及连线按接线图与变频器的主板相连 * PG卡的接线图：NO.1-15，各端子对应功能 三、...
2021-06-23-刘铁猛C#语言入门详解-学习笔记P23、24、25类
weixin_49079904的博客
06-23 540
P23、24、25类 一、P23、24、25内容总结 什么是类P23 构造器与析构器P23 类声明的全貌P24 最简单的类声明P24 类的继承P25 成员的继承与访问P25 面向对象的实现风格P25 二、什么是类–老师用例子将解释了一下 数据结构 数据类型（引用数据类型） 代表现实世界中的“种类” 三、构造器与析构器 实例 1）构造器 2）析构器 3）如何不用new操作符创建实例：使用反射、dynamic编程，老师举例说明，我没有记录了 //Student stu = new Student(
MCS－51单片机实现的功率因数表
08-13
只有查看数据时才需显示，所以显示时间很短，此表采用动态扫描的方法显示LED，第一、二位显示支路序号，三至六位显示各路的功率因数。 5. 主机 主机可采用CMOS器件以减小功耗，但抗干扰性能稍差一些，可根据实际抗...
H3C S5130S-EI-G-CMW710-R8108P24
08-30
注意：在升级版本之前，请注意与本版本配套的软、硬件条件必须符合下表的要求。 1. 型号（通过 display version 命令查询）：S5130S-36S-PWR-EI-G、S5130S-54S-EI-G、S5130S-36S-EI-G、S5130S-36F-EI-G、S5130S-54S-...
苏S01-2012 给水排水图集
06-24
江苏省省标苏S01-2012 给水排水图集，给水排水工程最新的江苏省规范图集。
实现有序数组的二分查找 C语言
HiMark
02-20 4240
写一个函数实现有序数组的二分查找#include<stdio.h> int Binarysearch(int arr[],int key,int n ) // 数组 ，关键字，数组长度。 { int left = 0; int right = n-1; int mid = 0;
简单的使用二分查找法（有序数组）
qq_43600938的博客
04-25 962
在主函数中实现二分查找法 #include<stdio.h> #include<stdlib.h> int main() { int arr[] = {1,2,3,4,5,6,7,8,9,10}; int k = 7; int left = 0; int right = sizeof(arr)/sizeof(arr[0])-1; while(left<...
实现一个简易的二分查找,查找一个有序数组
Smile__1的博客
06-27 1606
二分查找,前提是一个有序数组,原理很简单 如图:先找出数组中间 的数,与你需要查找的数进行比较，如果比中间数小（如图）就区左半部分的中间数在与需要查找的数进行比较（需要递归），直到找到为止。相反如果比中间数大就取右半部分的中间数进行比较… 代码 public static void main(String[] args) { int arr[] = {1,2,3,4,5,6,...
【查找】四种查找算法
风继续吹
07-28 777
顺序查找 顺序查找（Sequential Search）又叫线性查找，是最简单直接暴力的查找方法。就是从头至尾挨个寻找，找到位置。当遍历完没找到就说明要找的数据不存在。它不要求数据有序。该算法的时间复杂度为O(n)。 public static int seqSearch(int[] arr, int value) { for(int index = 0; index < arr.length; index++) { if(arr[index] == value) {
二分查找的代码实现--go语言
wtt234的专栏
04-13 235
二分查找的函数： 1.arr是一个有序数组，并且从小到大排序 2.先找到中间的下标midde=（leftindex+rigthindex）/2，然后让中间下标的值和findVal进行比较 2.1如果arr[middle]>findVal,就应该向 leftindex---(middle-1) 2.2 如果arr[middle]<findVal,就应该向 (middle+1)---rigthindex 2.3如果arr[middle]=findVal,就找到 3.退出递归的条件 if lef.
基于有序数组的二分查找--java代码实现
azx321的专栏
03-26 587
基于有序数组的二分查找–java代码实现 有序数组的java代码实现，其中有序数组可能是两段子有序数组，如{7，9，2，4，5}： 代码块 public class FindArrayIndexWithTarget { public static int find(int a[], int target) { if (null == a) ...
【数据结构】—— 树和二叉树
mist的博客
08-26 1384
树和二叉树、堆（顺序结构）、二叉树链式结构
数据结构：用栈实现队列（232）LeetCode
最新发布
2303_81073778的博客
08-26 722
你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。你能否实现每个操作均摊时间复杂度为 O(1) 的队列？换句话说，执行 n 个操作的总时间复杂度为 O(n) ，即使其中一个操作可能花费较长时间。你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。假设所有操作都是有效的 （例如，一个空的队列不会调用 pop 或者 peek 操作）
松下Lumix DMC-G7高级功能详细指南
手册结构清晰，提供了多样的查找方式。"目录"（P6）可以帮助用户快速定位所需章节，如"信息显示"（P370）、"菜单列表"（P374）和"故障排除"（P385），方便查找特定功能的操作步骤。 Wi-Fi功能（P290）是手册中的一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值