基本的查找你知道几个？

关于查找

查找又称检索，是从大量的数据中找出所需的数据，也可以简单地说是确定一个已给定的数据是否出现在某个数据表中。表通常是指文件，而文件是记录的集合，每个记录都是由若干个数据项组成的，其间一个或一组能唯一识别该记录的数据项称为该记录的关键字（keyword）。查找包括很多种：顺序查找、折半查找、分块查找以及哈希查找法。

顺序查找

核心思想：把序列中的元素进行遍历，找到符合条件的结果就结束

比较次数：最快1次，最慢n次

何时使用：

• 针对于无序序列，如果要实现查找序列中的所有满足条件的元素，那么比较次数一定是n次，因为找到其中一个，并不一定意味着找到所有的，因而要把所有的元素都遍历一遍才行。
• 如果是有序序列，要查找序列中所有满足条件的元素，比较次数要少一些，只需从开始满足的地方，到第一个不满足的地方就可以结束了，不必要等到序列末尾。

        int Find(int[] ary, int target)
        {
            for (int i = 0; i < ary.Length; i++)
            {
                if (ary[i] == target)
                {
                    //找到了就返回找到的位置
                    return i;
                }
            }
            //没找到就返回-1，表示没找到
            return -1;
        }

折半查找

核心思想：先确定待查找记录所在的的区间，然后逐步缩小查找范围，直到找到或找不到记录为止

时间复杂度：折半查找算法的效率是O(logn)

何时使用：

• 当表的长度n很大时，该方法很能显示出其时间效率
• 适合表中元素很少发生改动

int binary(int v[],int n,int cha)
{
    int low,high,mid;
    low=0;
    high=n-1;

    while(low<=high)
    {
       mid=(low+high)/2; //折半
       if(cha<v[mid])
       {
            high=mid-1;    //前半部分查找
       }
       else if(cha>v[mid])
       {
            low=mid+1;     //后半部分查找
       }
       else
            return mid;
    }
    return 0;    //没找到
}            

PS:折半查找查找的表还是线性表

分块查找

核心思想：分块查找是顺序查找和折半查找的结合体

时间复杂度：介于顺序与折半

何时使用：

• 要求表中元素是逐段有序的，块与块之间可以无序
  

        int SeqSearch(SeqList<int> R, int Key)
        {
            int i;
            R.Data[R.GetLength()] = Key;
            for (i = 0; R.Data[i] != Key; i++) ;
            if (i > R.Maxsize - 2)
                return -2;
            else
                return i;
        }

哈希法（散列法）

简介一下：哈希法不同于前面三种查找方法（这三种都是通过对关键字进行一系列的比较，逐步缩小范围，知道确定节点的存储位置或确定查找失败），哈希法不经过任何比较，一次存取就能得到所查元素，因此必须在记录的存储位置和它的关键字之间建立一个确定的对应关系，使得每个关键字和结构中一个唯一的存储位置相对应，这样查找时只需对节点进行某种运算就能确定节点在表中的位置

核心思想：找到哈希函数（比较次数与所含节点的个数无关）

Search

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

namespace DataStructure
{
    public interface IListDS<T>
    {
        int GetLength();             //求长度
        void Clear();                //清空操作
        bool IsEmpty();              //判断线性表是否为空
        bool IsFull();               //判断数据表是否已满
        void Append(T item);         //附加操作
        void Insert(T item, int i);  //插入操作
        T Delete(int i);             //删除操作
        T GetElement(int i);         //取表元
        int Locate(T value);         //按值查找
        void Reserve();              //倒置 
    }

    public class SeqList<T> : IListDS<T>
    {
        private int maxsize;        //顺序表的容量
        private T[] data;           //数组，用于存储数据表中的数据元素
        private int last;           //指示数据表中最后一个元素的位置

        //索引器
        public T this[int index]
        {
            get { return data[index]; }
            set { data[index] = value; }
        }

        public T[] Data
        {
            get { return data; }
            set { data = value; }
        }

        //属性 最后一个元素的位置
        public int Last
        {
            get { return last; }
        }

        //属性 容量
        public int Maxsize
        {
            get { return maxsize; }
            set { maxsize = value; }
        }

        //构造函数
        public SeqList(int size)
        {
            data = new T[size];
            maxsize = size;
            last = -1;
        }

        public int GetLength()
        {
            return last + 1;
        }

        public void Clear()
        {
            last = -1;
        }

        public bool IsEmpty()
        {
            if (last == -1)
                return true;
            else
                return false;
        }

        public bool IsFull()
        {
            if (last == maxsize - 1)
                return true;
            else
                return false;
        }

        public void Append(T item)
        {
            if (IsFull())
            {
                Console.WriteLine("List is full !");
                return;
            }
            data[++last] = item;
        }

        public void Insert(T item, int i)
        {
            if (IsFull())
            {
                Console.WriteLine("List is Full !");
                return;
            }
            if (i < 1 || i > last + 2)
            {
                Console.WriteLine("Postion is Error !");
                return;
            }
            if (i == last + 2)
            {
                data[i - 1] = item;
            }
            else
            {
                for (int j = last; j >= i - 1; j--)
                {
                    data[j + 1] = data[j];
                }
                data[i - 1] = item;
            }
            ++last;
        }

        public T Delete(int i)
        {
            T tem = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return tem;
            }
            if (i < 1 || i > last + 1)
            {
                Console.WriteLine("Postion is Error !");
                return tem;
            }
            if (i == last + 1)
            {
                tem = data[last--];
                return tem;
            }
            else
            {
                tem = data[i - 1];
                for (int j = i; j <= last; j++)
                {
                    data[j] = data[j + 1];
                }
            }
            --last;
            return tem;
        }

        public T GetElement(int i)
        {
            if (IsEmpty() || i < 1 || i > last + 1)
            {
                Console.WriteLine("List is Empty or Postion is Error !");
                return default(T);
            }
            return data[i - 1];
        }

        public int Locate(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is Empty !");
                return -1;
            }
            int i = 0;
            for (i = 0; i <= last; i++)
            {
                if (value.Equals(data[i]))
                    break;
            }
            if (i > last)
            {
                return -1;
            }
            return i;
        }

        public void Reserve()
        {
            T tem;
            int len = GetLength();
            for (int i = 0; i <= len / 2; i++)
            {
                tem = data[i];
                data[i] = data[len - 1];
                data[len - 1] = tem;
            }
        }

        /// <summary>
        /// 将两个升序整型顺序表合并成一个升序顺序表
        /// 思路：依次扫描La Lb中的元素，比较La和Lb中当前元素，将较小的元素值赋值给Lc,如此直到一个被扫描完，然后把未完的那个剩余的元素付给Lc
        /// </summary>
        /// <param name="La"></param>
        /// <param name="Lb"></param>
        /// <returns></returns>
        public SeqList<int> Merge(SeqList<int> La, SeqList<int> Lb)
        {
            SeqList<int> Lc = new SeqList<int>(La.Maxsize + Lb.Maxsize);
            int i = 0;
            int j = 0;

            while ((i <= La.GetLength() - 1) && (j <= Lb.GetLength() - 1))
            {
                if (La[i] < Lb[j])
                {
                    Lc.Append(La[i++]);
                }
                else
                {
                    Lc.Append(Lb[j++]);
                }
            }
            //如果La中还有元素
            while (i <= La.GetLength() - 1)
            {
                Lc.Append(La[i++]);
            }
            //如果Lb中还有元素
            while (i < Lb.GetLength() - 1)
            {
                Lc.Append(Lb[i++]);
            }

            return Lc;
        }

        /// <summary>
        /// 已知顺序表La 构造顺序表Lb 使其包含La中所有不相同的数据元素 
        /// 思路： 先把La中的第一个元素付给Lb 然后从La的第二个元素开始 每一个元素与Lb的每一个元素比较 不同则附加到Lb末尾 
        /// </summary>
        /// <param name="La"></param>
        /// <returns></returns>
        public SeqList<int> Purge(SeqList<int> La)
        {
            SeqList<int> Lb = new SeqList<int>(La.Maxsize);
            Lb.Append(La[0]);
            for (int i = 1; i <= La.GetLength() - 1; ++i)
            {
                int j = 0;
                for (j = 0; j <= Lb.GetLength() - 1; ++j)
                {
                    if (La[i].CompareTo(Lb[j]) == 0)
                    {
                        break;
                    }
                }
                //没有相同的元素，把La中的元素附加到Lb
                if (j > Lb.GetLength() - 1)
                {
                    Lb.Append(La[i]);
                }
            }
            return Lb;
        }


       

    }

    /// <summary>
    /// 定义解决冲突的链表的结点类型
    /// </summary>
    public class chaintype
    {
        private int key;
        private chaintype next;

        public int Key
        {
            get { return key; }
            set { key = value; }
        }

        public chaintype Next
        {
            get { return next; }
            set { next = value; }
        }
    }


    public class SearchArithMetic
    {

        /// <summary>
        /// 插入排序
        /// </summary>
        /// <param name="R"></param>
        public void InsertSort(SeqList<int> R)
        {
            for (int i = 1; i < R.Maxsize; i++)
            {
                if (R.Data[i] < R.Data[i - 1])
                {
                    int temp = R.Data[i];
                    int j = 0;
                    for (j = i - 1; j >= 0 && temp < R.Data[j]; j--)
                    {
                        R.Data[j + 1] = R.Data[j];
                    }
                    R.Data[j + 1] = temp;
                }
            }
        }
       
        /// <summary>
        /// 顺序查找算法
        /// </summary>
        /// <param name="R"></param>
        /// <param name="Key"></param>
        /// <returns></returns>
        public int SeqSearch(SeqList<int> R, int Key)
        {
            int i;
            R.Data[R.GetLength()] = Key;
            for (i = 0; R.Data[i] != Key; i++) ;
            if (i > R.Maxsize - 2)
                return -2;
            else
                return i;
        }

        /// <summary>
        /// 二分查找算法
        /// </summary>
        /// <param name="R"></param>
        /// <param name="Key"></param>
        /// <returns></returns>
        public int BinSearch(SeqList<int> R, int Key)
        {
            int low = 0, high = R.GetLength() - 1, mid;  //设置当前查找区间的上下界的初值
            while (low <= high)
            {
                mid = (low + high) / 2;
                if (R.Data[mid] == Key) return mid;
                if (R.Data[mid] > Key)
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            return -1;
        }

        /// <summary>
        /// 除模取余法的哈希函数
        /// </summary>
        /// <param name="key"></param>
        /// <param name="Mod"></param>
        /// <returns></returns>
        public int Hash(int key, int Mod)
        {
            return key % Mod;
        }

        /// <summary>
        /// 在哈希表中插入记录，用链表法解决冲突
        /// </summary>
        /// <param name="a"></param>
        /// <param name="key"></param>
        /// <param name="Mod"></param>
        /// <returns></returns>
        public bool HashInsert(chaintype[] a, int key, int Mod)
        {
            int i;
            i = Hash(key, Mod);
            chaintype pre;
            chaintype cur;
            pre = a[i];
            cur = a[i];

            while (cur != null && cur.Key != key)
            {
                pre = cur;
                cur = cur.Next;
            }

            /*未查找到时插入该记录在对应的链表尾*/
            if (cur == null)
            {
                cur = new chaintype();
                cur.Key = key;
                cur.Next = null;
                /*在该链插入第一个记录*/
                if (a[i] == null)
                    a[i] = cur;
                else
                    pre.Next = cur;
                return true;
            }
            return false;
        }


        public chaintype HashSearch(chaintype[] a, int key, int Mod)
        {
            chaintype p;
            int i = Hash(key, Mod);
            p = a[i];
            while (p != null && p.Key != key)
            { p = p.Next; }
            if (p == null) return null;
            else
                return p;
        }
    }
    class Search
    {
        /*
        /// <summary>
        /// 顺序查找
        /// </summary>
        /// <param name="R"></param>
        /// <param name="Key"></param>
        /// <returns></returns>
        public static int SeqSearch(SeqList<int> R, int Key)
        {
            int i;
            R.Data[R.GetLength()] = Key;
            for (i = 0; R.Data[i] != Key; i++) ;
            if (i > R.Maxsize - 2)
                return -2;
            else
                return i;
        }

        /// <summary>
        /// 二分查找
        /// </summary>
        /// <param name="R"></param>
        /// <param name="Key"></param>
        /// <returns></returns>
        public static int BinSearch(SeqList<int> R, int Key)
        {
            int low = 0, high = R.GetLength() - 1, mid;  //设置当前查找区间的上下界的初值
            while (low <= high)
            {
                mid = (low + high) / 2;
                if (R.Data[mid] == Key) return mid;
                if (R.Data[mid] > Key)
                    high = mid - 1;
                else
                    low = mid + 1;
            }
            return -2;
        }


        static void Main()
        {
            SeqList<int> queue = new SeqList<int>(10);
            queue.Append(10);
            queue.Append(20);
            queue.Append(30);
            queue.Append(40);
            queue.Append(50);
            queue.Append(60);
            queue.Append(70);
            queue.Append(80);
            queue.Append(90);

            //int location = SeqSearch(queue, 90);
            int location = BinSearch(queue, 90);
            Console.WriteLine("您查找的数据为表中第{0}位!", location + 1);
            Console.ReadKey();

        }
        */

        public static void Main()
        {
            SeqList<int> numList = null;

            numList = new SeqList<int>(12);
            chaintype[] a = new chaintype[13];

            char selectFlag;
            while (true)
            {
                Console.WriteLine("请输入操作选项：");
                Console.WriteLine("1.创建顺序表");
                Console.WriteLine("2.对顺序表执行顺序查找");
                Console.WriteLine("3.对顺序表执行二分查找");
                Console.WriteLine("4.创建哈希表");
                Console.WriteLine("5.在哈希表中查找关键字");
                Console.WriteLine("6.退出");
                selectFlag = Convert.ToChar(Console.ReadLine());
                SearchArithMetic searchA = new SearchArithMetic();
                switch (selectFlag)
                {
                    case '1':
                        {
                            numList.Insert(70, numList.GetLength() + 1);
                            numList.Insert(30, numList.GetLength() + 1);
                            numList.Insert(40, numList.GetLength() + 1);
                            numList.Insert(10, numList.GetLength() + 1);
                            numList.Insert(80, numList.GetLength() + 1);
                            numList.Insert(20, numList.GetLength() + 1);
                            numList.Insert(90, numList.GetLength() + 1);
                            numList.Insert(100, numList.GetLength() + 1);
                            numList.Insert(75, numList.GetLength() + 1);
                            numList.Insert(60, numList.GetLength() + 1);
                            numList.Insert(45, numList.GetLength() + 1);

                            Console.WriteLine("已插入顺序表的数字是：");
                            Console.WriteLine("70 30 40 10 80 20 90 100 75 60 45");
                            break;
                        }
                    case '2':
                        {
                            Console.WriteLine("请输入要查找的数字:");
                            long time1 = System.DateTime.Now.Ticks;
                            int num = Convert.ToInt32(Console.ReadLine());
                            int i = searchA.SeqSearch(numList, num);
                            if (i == -1)
                                Console.WriteLine("{0}在数字列表中不存在", num);
                            else
                                Console.WriteLine("{0}在数字列表中的序号为{1}", num, i);
                            long time2 = System.DateTime.Now.Ticks;
                            Console.WriteLine("顺序查找用时{0}", time2 - time1);
                            break;
                        }
                    case '3':
                        {
                            long time1 = System.DateTime.Now.Ticks;
                            new SearchArithMetic().InsertSort(numList);
                            long time2 = System.DateTime.Now.Ticks;
                            Console.WriteLine("请输入要查找的数字:");
                            int num = Convert.ToInt32(Console.ReadLine());
                            long time3 = System.DateTime.Now.Ticks;
                            int i = searchA.BinSearch(numList, num);
                            if (i == -1)
                                Console.WriteLine("{0}在数据列表中不存在", num);
                            else
                                Console.WriteLine("{0}在数字列表中的序号为{1}", num, i + 1);
                            long time4 = System.DateTime.Now.Ticks;
                            Console.WriteLine("排序用时{0}", time2 - time1);
                            Console.WriteLine("二分查找用时{0}", time4 - time3);
                            Console.WriteLine("查找总用时{0}", time4 - time1);
                            break;
                        }
                    case '4':
                        {
                            searchA.HashInsert(a, 70, 13);
                            searchA.HashInsert(a, 30, 13);
                            searchA.HashInsert(a, 40, 13);
                            searchA.HashInsert(a, 10, 13);
                            searchA.HashInsert(a, 80, 13);
                            searchA.HashInsert(a, 20, 13);
                            searchA.HashInsert(a, 90, 13);
                            searchA.HashInsert(a, 100, 13);
                            searchA.HashInsert(a, 75, 13);
                            searchA.HashInsert(a, 60, 13);
                            searchA.HashInsert(a, 45, 13);
                            break;
                        }
                    case '5':
                        {
                            Console.WriteLine("请输入要查找的数字：");
                            long time1 = System.DateTime.Now.Ticks;
                            int num = Convert.ToInt32(Console.ReadLine());
                            chaintype p = searchA.HashSearch(a, num, 13);
                            if(p==null)
                                Console.WriteLine("{0}在数据列表中不存在", num);
                            else
                                Console.WriteLine("您查找的关键字是：{0}",p.Key );
                            long time2 = System.DateTime.Now.Ticks;
                            Console.WriteLine("哈希表查找用时{0}", time2 - time1);
                            break;
                        }
                    case '6':
                        {
                            return;
                        }


                }
                Console.WriteLine("按任意键继续");
                Console.ReadLine();
            }
        }
        
    }
}

结语

适当的情景使用适当的算法，慢慢在实际中摸索，IT小菜鸟成长ing