精华内容
下载资源
问答
  • 查找排序
    千次阅读
    2013-11-22 22:25:24

     

    查找

    1、静态查找(基于线性表的查找法)

    1)顺序查找

    2)有序表折半查找(二分查找)

    3)索引查找(分块查找)

    2、动态查找(基于树的查找法)

    1)二叉排序树

    2)平衡二叉排序树

    3)B_树B+树

    3、哈希表查找(计算式查找法)

    排序

    一、内部排序

    1、插入类

    1直接插入排序

    2折半插入排序

    3希尔排序

    2、交换类

    1冒泡排序

    2快速排序

    3、选择类

    1简单选择排序

    2堆排序

    4、归并类

    1归并排序

    5、基数类

    1多关键字排序

    2链式基数排序

    二、外部排序

     

    更多相关内容
  • 谢谢你的阅读 再见
  • 查找排序.zip,查找排序,c1015.txt,c1077.txt,c1-1009.txt,c1011.txt,查找排序题目.txt,c1099.txt,c1010.txt,c1014.txt,c1013.txt,c1012.txt,c1016.txt,c1098.txt
  • shujujiegou.rar_查找排序

    2022-09-23 12:43:07
    数据结构的各种排序查找 冒泡排序 折半排序 希尔排序
  • 常用数据结构,包括链表、二叉树、栈、循环队列,以及查找排序算法:二分查找,插入排序,选择排序、冒泡排序
  • 最近在研究数据结构这本书,自己动手实现的一个二叉查找排序树的类BinSortTree,实现数据的插入,查找,删除,层序遍历,中序遍历等操作,熟悉数据结构的朋友都知道,根据二叉排序树的定义,中序遍历后得到的序列...
  • 查找排序算法应用

    2018-08-04 17:25:57
    c语言实现查找排序算法应用,1.掌握查找的不同方法,并能用高级语言实现查找算法。 2.熟练掌握顺序表和有序表的顺序查找和二分查找方法。 3.掌握排序的不同方法,并能用高级语言实现排序算法。 4.熟练掌握...
  • 包括链表、线性表、二叉树、栈、多种查找排序算法
  • 1.堆排序 2.快速排序 3.归并排序 4.冒泡排序 5.选择排序 6.顺序查找 7.二分查找

    📃个人主页:个人主页

    🔥系列专栏:数据结构与算法

    💬推荐一款模拟面试、刷题神器,从基础到大厂面试题👉点击跳转刷题网站进行注册学习

    目录

    1.堆排序

    2.快速排序

    3.归并排序

    4.冒泡排序

    5.选择排序

    6.顺序查找

    7.二分查找

    查找图解:

    代码详解:

     代码


    1.堆排序

    堆排序(超详细图解 java版)_一个热爱编程的小白白的博客-CSDN博客

    2.快速排序

    快速排序法(java版,分治法,递归)_一个热爱编程的小白白的博客-CSDN博客

    3.归并排序

    归并排序java(内附超详解图文讲解)_一个热爱编程的小白白的博客-CSDN博客_归并排序java

    4.冒泡排序

    java冒泡排序以及优化,并用vue+element在网页上进行可视化排序_一个热爱编程的小白白的博客-CSDN博客

    5.选择排序

    选择排序以及选择排序优化_一个热爱编程的小白白的博客-CSDN博客



    6.顺序查找

    顺序查找以及带哨兵的顺序查找java版本_一个热爱编程的小白白的博客-CSDN博客

    7.二分查找


    请对一个有序数组进行二分查找{1,3,5,9,20},输入一个数看看该数组是否存在此数,并且求出下标,如果没有就返回-1。

    查找图解:
     

    代码详解:

    这里我们加大难度:

    产生一个随机数组,并产生一个随机数 用二分查找 查找该随机数

    //产生一个随机数组
    Random r = new Random();
    int arr[] = new int[10];
    for (int i = 0; i < arr.length; i++) {
        arr[i] = r.nextInt(10);
    }

    并产生一个随机数:
    int n=r.nextInt(10);
    

    因为二分查找的条件:有序数组

    故此采用:  

    Arrays.sort(arr); //先进行排序

    检查是否排序完成:
    System.out.println("数组排序后:"+Arrays.toString(arr));
    调用方法:
    System.out.println("要查询的数:"+n);
    System.out.println("该数字索引位置:"+BinarySort(arr, 0, arr.length-1, n));
    
    方法:BinarySort(int[] arr,int left,int right,int n)

    left表示最左边下标  right表示最右边下标 n表示要查找的数

    mid 表示中间数的下标

    mid = (left+right)/2;  求中间下标
    if(left>right){
        return -1;
    }

    表示 如果左边的下标大于右边 则查找失败

    if(n>arr[mid]){//如果要查的数比中间的数大 那么中间下标+1 然后递归
          mid++;
                         //mid作为下次的最左边下标 right作为右下标
          return BinarySort(arr,mid,right,n);
      }
    if (n<arr[mid]){//如果要查的数比中间的数小 那么中间下标-1 然后递归
          mid--;
                          //left作为左下标 mid作为右下标 
          return BinarySort(arr,left,mid,n);
      }
    //如果查找的数字 不大于 也不小于 那么只能等于了 所以返回mid
      return mid;

     代码

    import java.util.Arrays;
    import java.util.Random;
    public class binarySort {
        public static void main(String[] args) {
            //产生一个随机数组
            Random r = new Random();
            int arr[] = new int[10];
            for (int i = 0; i < arr.length; i++) {
                arr[i] = r.nextInt(10);
            }
            System.out.println("产生的随机数组:"+Arrays.toString(arr));
            Arrays.sort(arr);
            System.out.println("数组排序后:"+Arrays.toString(arr));
            int n=r.nextInt(10);
            System.out.println("要查询的数:"+n);
            System.out.println("该数字索引位置:"+BinarySort(arr, 0, arr.length-1, n));
        }
    
        private static int BinarySort(int[] arr,int left,int right,int n) {
            int mid;
            mid = (left+right)/2;
            if(left>right){
                return -1;
            }
            else{
                if(n>arr[mid]){
                    mid++;
                    return BinarySort(arr,mid,right,n);
                }
              if (n<arr[mid]){
                    mid--;
                    return BinarySort(arr,left,mid,n);
                }
                return mid;
    
            }
        }}
    

    结束语:

    今天的分享就到这里啦!快快通过下方链接注册加入刷题大军吧!各种大厂面试真题在等你哦!

     💬刷题神器,从基础到大厂面试题👉点击跳转刷题网站

     

    展开全文
  • 数据结构讲义树图查找排序PPT学习教案.pptx
  • 二分查找排序算法.zip

    2019-10-28 15:39:11
    二分查找排序算法.zip,二分查找排序算法,Binary_Insert_Sort.py,二分查找排序算法.doc
  • 数据结构中的树图查找排序PPT学习教案.pptx
  • 查找排序等功能.rar

    2019-12-07 06:38:01
    从TXT文档内读取查找排序已有人物数据 要求文档内数据包括 1 ssn 2 名 3 姓 4 出生年月 5 所在州
  • 陕 西 科 技 大 学 实 验 报 告 班 级 实 验 日 期 学 号 室 温 姓 名 报 告 日 期 实 验 组 别 成 绩 报告内容目的和要求原理步骤数据计算小结等 实验名称查找排序算法的实现和应用 实验目的 掌握顺序表中查找的...
  • 学生管理系统的设计与实现(查找排序)实验报告文档
  • C++模板类实现的动态数组、双向循环链表、队列、栈等数据结构,以及基于迭代器的静态查找排序算法,包括顺序查找、折半查找、简单选择排序(用于单向迭代器)、快速排序(双向迭代器)、堆排序(随机迭代器)
  • 内部查找排序

    2012-12-18 17:08:46
    内部查找排序的科件,讲叙了内部排序查找的6种方法和比较
  • DataGrid 查找排序

    2013-05-03 10:49:31
    DataGrid 绑定sql数据库。实现对表的排序和特定的条件的查找,并结合分页技术
  • 利用二叉排序树完成动态查找表的建立、指定关键字的查找、插入与删除指定关键字结点。 算法输入:指定一组数据。 算法输出:显示二叉排序树的中序遍历结果、查找成功与否的信息、插入和删除后的中序遍历结果(排序...
  • 排序包括希尔、冒泡、快排、选择排序、堆排序、归并排序查找包括顺序、折半、二叉排序树(包括关键字添加删除)、B树.
  • 排序查找的基本运算

    2018-09-03 15:37:09
    本程序共设计了排序查找的6个基本操作运算,分别是直接插入排序,冒泡排序,直接选择排序,堆排序,希尔排序,以及二分查找等6个操作。附带实验报告。
  • C实现数的查找排序

    2012-03-02 15:14:42
    用一维数组的形式存储数据并用冒泡法实现数据的查找排序
  • 各类介绍: 各类实战 代码如下: (包括五种,自己可以逐个测试) #include "pch.h" ...//折半查找 int BinarySearchFunc(int key, int a[], int n) { int low, mid, high; //查找标记 int count ...

    各类介绍:

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

    各类实战

    代码如下:
    (包括五种,自己可以逐个测试)

    #include "pch.h"
    #include <iostream>
    using namespace std;
    
    //折半查找
    
    int BinarySearchFunc(int key, int a[], int n)
    {
    	int low, mid, high;		//查找标记
    	int count = 0;			//统计查找次数
    	low = 0;
    	high = n - 1;
    	int countT = 0;
    
    	while (low <= high)
    	{
    		count++;
    		mid = (high + low) / 2;
    
    		if (key == a[mid])
    		{
    			cout << "查找成功,位置查找次数为:" << count << "对应的位置是:a[" << mid << "]" << endl;
    			countT++;
    			break;
    		}
    		else if (key < a[mid])	//查找数据是在low-mid之间
    		{
    			high = mid - 1;
    		}
    		else if (key > a[mid])	//查找数据是在mid-high之间
    		{
    			low = mid + 1;
    		}
    
    	}
    	if (countT == 0)
    	{
    		cout << "查找key失败!" << endl;
    	}
    	return 0;
    }
    
    int main()
    {
    	cout << "折半查找:" << endl;
    	int key;
    	int array[10] = { 1,2,13,34,45,56,78,79,88,92 };
    	cout << "请输入要查找的数据:";
    	cin >> key;
    	BinarySearchFunc(key, array, 10);
    
    	return 0;
    }
    
    
    哈希表
    
    //#define N  11
    //#define L  13
    //
    //int Data[N] = { 10,23,33,26,56,11,88,56,66,22,74 };	//原始表
    //int Hash[L] = { 0 };								//哈希表
    //
    //创建使用哈希表
    //void CreateHash()
    //{
    //	for (int i = 0; i < N; i++)
    //	{
    //		int j=Data[i] % L;	//计算哈希地址
    //		while (Hash[j])
    //		{
    //			j = (++j) % L;
    //		}
    //		Hash[j] = Data[i];
    //	}
    //}
    //
    //查找哈希表里的数据
    //int HashSearch(int key)
    //{
    //	int i = key % L;				//计算哈希地址
    //	while (Hash[i]&&Hash[i]!=key)	//不是我要查找的值
    //	{
    //		i = (++i) % L;				//更换哈希地址
    //	}
    //	if (Hash[i]==0)			//找到开放空间的时候,查找失败
    //	{
    //		return -1;			//查找失败
    //	}
    //	else
    //	{
    //		return i;
    //	}
    //}
    //
    //int main()
    //{
    //	int key;
    //	CreateHash();
    //	cout << "哈希表中的值为:" << endl;
    //	for (int i = 0; i < L; i++)
    //	{
    //		cout << Hash[i] << " ";
    //	}
    //	cout << endl;
    //
    //	cout << "请输入所要查找的值:";
    //	cin >> key;
    //	int IP=HashSearch(key);
    //	if (IP==-1)
    //	{
    //		cout << "查找失败!" << endl;
    //	}
    //	else
    //	{
    //		cout << "查找成功!所对应的下标为:" << IP << endl;
    //	}
    //
    //	return 0;
    //}
    
    //直接插入排序
    
    //int DirInsertSortFunc(int arraa[], int length)
    //{
    //	int j;
    //	for (int i = 2; i <=length; i++)
    //	{
    //		arraa[0] = arraa[i];//给监视哨赋值,a【0】用来做比较
    //		j = i - 1;			//确定要比较的元素
    //		while (arraa[0]<arraa[j])
    //		{
    //			arraa[j + 1] = arraa[j];//数据右移
    //			j--;					//下标前移
    //		}
    //		arraa[j + 1] = arraa[0];	//在确定位置插入arraa[i]
    //	}
    //	return 0;
    //}
    //
    //
    //int main()
    //{
    //
    //	cout << "插入排序:"<<endl;
    //	int arry[6] = { 0,12,33,66,55,22 };
    //	DirInsertSortFunc(arry, 5);
    //	cout << "插入排序后的结果为:";
    //	for (int i = 1; i <= 5; i++)
    //	{
    //		cout << arry[i] << " ";
    //	}
    //	cout << endl;
    //	return 0;
    //}
    
    //冒泡排序
    
    //void Func(int a[])
    //{
    //	int temp;
    //	for (int i = 1; i < 5; i++)
    //	{
    //		for (int j = 0; j < 5-i; j++)
    //		{
    //			if (a[j]>a[j+1])
    //			{
    //				temp = a[j];
    //				a[j] = a[j + 1];
    //				a[j + 1] = temp;
    //			}
    //		}
    //	}
    //}
    //
    //int main()
    //{
    //	cout << "冒泡排序:" << endl;
    //	int a[5] = { 1,55,64,99,23 };
    //
    //	Func(a);
    //	cout << "冒泡排序的结果为:";
    //	for (int i = 0; i < 5; i++)
    //	{
    //		cout << a[i] << " ";
    //	}
    //	cout << endl;
    //
    //	return 0;
    //}
    
    //快速排序
    
    //int QsortFunc(int a[], int start, int end)
    //{
    //	int i, j;
    //	i = start;			//每组首个元素给i
    //	j = end;			//每组末尾元素给j
    //	a[0] = a[start];	//设置基准值
    //
    //	while (i<j)
    //	{
    //		//基准值左边
    //		while (i<j&&a[0]<a[j])
    //		{
    //			j--;	//位置左移
    //		}
    //		if (i<j)
    //		{
    //			a[i] = a[j];
    //			i++;	//位置右移
    //		}
    //		//基准值右边
    //		while (i < j&&a[i] <= a[0])
    //		{
    //			i++;	//位置左移
    //		}
    //		if (i < j)
    //		{
    //			a[j] = a[i];
    //			j--;	//位置右移
    //		}
    //	}
    //	a[i] = a[0];	//将基准值放入指定位置
    //	if (start<i)
    //	{
    //		QsortFunc(a, start, j - 1);
    //	}
    //	if (i < end)
    //	{
    //		QsortFunc(a, j + 1, end);
    //	}
    //	return 0;
    //}
    //
    //int main()
    //{
    //	cout << "快速排序:" << endl;;
    //	int a[11] = { 0,66,6,666,332,12,87,45,12,45,6 };
    //
    //	QsortFunc(a, 1, 10);
    //	cout << "快速排序的结果为:";
    //	for (int i = 1; i <=10; i++)
    //	{
    //		cout << a[i] << " ";
    //	}
    //	return 0;
    //}
    
    

    五种结果分别为:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

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

    展开全文
  • 本文通过C++代码实现对数据结构课本中的排序查找算法。 查找算法 静态查找表:顺序查找 有序表查找 索引顺序表查找 动态查找表:二叉排序树 平衡二叉树 B-树、 B+树 哈希表:哈希函数构造方法 处理冲突的方法 ...
  • 查找排序

    2018-12-21 21:10:24
    关于排序的7个算法,包括插入排序,希尔排序,交换排序,快速排序,选择排序,堆排序,归并排序,基数排序
  • c++各种排序算法的swf展示,二分查找, 分块查找,规并排序,基数排序, 快速排序,冒泡排序, 顺序查找, 希儿排序, 直接插入排序, 直接选择排序
  • 数据结构 实验 顺序查找 排序 源码
  • 算法——查找排序

    万次阅读 多人点赞 2018-05-11 16:52:34
    查找算法:顺序查找、二分查找、哈希表查找、二叉排序查找排序算法:插入排序、冒泡排序、归并排序、快速排序等。 以下皆为转载: 原文地址: https://www.cnblogs.com/wxisme/p/5243631.html 1.1 冒泡...

    查找算法:顺序查找、二分查找、哈希表查找、二叉排序树查找。
    排序算法:插入排序、冒泡排序、归并排序、快速排序等。


    图片来源:https://blog.csdn.net/u011552404/article/details/78973058
    查找总结:
    查找算法分析
    排序总结:
    排序算法分析


    以下皆为转载:
    原文地址:
    https://www.cnblogs.com/wxisme/p/5243631.html

    1.1 冒泡排序:

    冒泡排序是最简单的排序之一了,其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样,因此而得名。
    举个栗子,对5,3,8,6,4这个无序序列进行冒泡排序。首先从后向前冒泡,4和6比较,把4交换到前面,序列变成5,3,8,4,6。同理4和8交换,变成5,3,4,8,6,3和4无需交换。5和3交换,变成3,5,4,8,6.这样一次冒泡就完了,把最小的数3排到最前面了。对剩下的序列依次冒泡就会得到一个有序序列。冒泡排序的时间复杂度为O(n^2)。
    实现代码:

    /**
     *冒泡排序算法实现
     */
    public class BubbleSort {
    
        public static void bubbleSort(int[] arr) {
            if(arr == null || arr.length == 0)
                return ;
            for(int i=0; i<arr.length-1; i++) {
                for(int j=arr.length-1; j>i; j--) {
                    if(arr[j] < arr[j-1]) {
                        swap(arr, j-1, j);
                    }
                }
            }
        }
    
        public static void swap(int[] arr, int i, int j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }

    1.2 选择排序

    选择排序的思想其实和冒泡排序有点类似,都是在一次排序后把最小的元素放到最前面。但是过程不同,冒泡排序是通过相邻的比较和交换。而选择排序是通过对整体的选择。
    举个栗子,对5,3,8,6,4这个无序序列进行简单选择排序,首先要选择5以外的最小数来和5交换,也就是选择3和5交换,一次排序后就变成了3,5,8,6,4.对剩下的序列一次进行选择和交换,最终就会得到一个有序序列。其实选择排序可以看成冒泡排序的优化,因为其目的相同,只是选择排序只有在确定了最小数的前提下才进行交换,大大减少了交换的次数。选择排序的时间复杂度为O(n^2)
    实现代码:

    /**
     *@Description:<p>简单选择排序算法的实现</p>
     *@author 王旭
     *@time 2016-3-3 下午9:13:35
     */
    public class SelectSort {
    
        public static void selectSort(int[] arr) {
            if(arr == null || arr.length == 0)
                return ;
            int minIndex = 0;
            for(int i=0; i<arr.length-1; i++) { //只需要比较n-1次
                minIndex = i;
                for(int j=i+1; j<arr.length; j++) { //从i+1开始比较,因为minIndex默认为i了,i就没必要比了。
                    if(arr[j] < arr[minIndex]) {
                        minIndex = j;
                    }
                }
    
                if(minIndex != i) { //如果minIndex不为i,说明找到了更小的值,交换之。
                    swap(arr, i, minIndex);
                }
            }
    
        }
    
        public static void swap(int[] arr, int i, int j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    
    }

    1.3 插入排序

    插入排序不是通过交换位置而是通过比较找到合适的位置插入元素来达到排序的目的的。相信大家都有过打扑克牌的经历,特别是牌数较大的。在分牌时可能要整理自己的牌,牌多的时候怎么整理呢?就是拿到一张牌,找到一个合适的位置插入。这个原理其实和插入排序是一样的。举个栗子,对5,3,8,6,4这个无序序列进行简单插入排序,首先假设第一个数的位置时正确的,想一下在拿到第一张牌的时候,没必要整理。然后3要插到5前面,把5后移一位,变成3,5,8,6,4.想一下整理牌的时候应该也是这样吧。然后8不用动,6插在8前面,8后移一位,4插在5前面,从5开始都向后移一位。注意在插入一个数的时候要保证这个数前面的数已经有序。简单插入排序的时间复杂度也是O(n^2)。

    实现代码:

    /**
     *@Description:<p>简单插入排序算法实现</p>
     *@author 王旭
     *@time 2016-3-3 下午9:38:55
     */
    public class InsertSort {
    
        public static void insertSort(int[] arr) {
            if(arr == null || arr.length == 0)
                return ;
    
            for(int i=1; i<arr.length; i++) { //假设第一个数位置时正确的;要往后移,必须要假设第一个。
    
                int j = i;
                int target = arr[i]; //待插入的
    
                //后移
                while(j > 0 && target < arr[j-1]) {
                    arr[j] = arr[j-1];
                    j --;
                }
    
                //插入 
                arr[j] = target;
            }
    
        }
    
    }

    1.4 快速排序

    快速排序一听名字就觉得很高端,在实际应用当中快速排序确实也是表现最好的排序算法。快速排序虽然高端,但其实其思想是来自冒泡排序,冒泡排序是通过相邻元素的比较和交换把最小的冒泡到最顶端,而快速排序是比较和交换小数和大数,这样一来不仅把小数冒泡到上面同时也把大数沉到下面。

    举个栗子:对5,3,8,6,4这个无序序列进行快速排序,思路是右指针找比基准数小的,左指针找比基准数大的,交换之。

    5,3,8,6,4 用5作为比较的基准,最终会把5小的移动到5的左边,比5大的移动到5的右边。

    5,3,8,6,4 首先设置i,j两个指针分别指向两端,j指针先扫描(思考一下为什么?)4比5小停止。然后i扫描,8比5大停止。交换i,j位置。

    5,3,4,6,8 然后j指针再扫描,这时j扫描4时两指针相遇。停止。然后交换4和基准数。

    4,3,5,6,8 一次划分后达到了左边比5小,右边比5大的目的。之后对左右子序列递归排序,最终得到有序序列。

    上面留下来了一个问题为什么一定要j指针先动呢?首先这也不是绝对的,这取决于基准数的位置,因为在最后两个指针相遇的时候,要交换基准数到相遇的位置。一般选取第一个数作为基准数,那么就是在左边,所以最后相遇的数要和基准数交换,那么相遇的数一定要比基准数小。所以j指针先移动才能先找到比基准数小的数。

    快速排序是不稳定的,其时间平均时间复杂度是O(nlgn)。

    实现代码:

    /**
     *@Description:<p>实现快速排序算法</p>
     *@author 王旭
     *@time 2016-3-3 下午5:07:29
     */
    public class QuickSort {
        //一次划分
        public static int partition(int[] arr, int left, int right) {
            int pivotKey = arr[left];
            int pivotPointer = left;
    
            while(left < right) {
                while(left < right && arr[right] >= pivotKey)
                    right --;
                while(left < right && arr[left] <= pivotKey)
                    left ++;
                swap(arr, left, right); //把大的交换到右边,把小的交换到左边。
            }
            swap(arr, pivotPointer, left); //最后把pivot交换到中间
            return left;
        }
    
        public static void quickSort(int[] arr, int left, int right) {
            if(left >= right)
                return ;
            int pivotPos = partition(arr, left, right);
            quickSort(arr, left, pivotPos-1);
            quickSort(arr, pivotPos+1, right);
        }
    
        public static void sort(int[] arr) {
            if(arr == null || arr.length == 0)
                return ;
            quickSort(arr, 0, arr.length-1);
        }
    
        public static void swap(int[] arr, int left, int right) {
            int temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
        }
    
    }

    其实上面的代码还可以再优化,上面代码中基准数已经在pivotKey中保存了,所以不需要每次交换都设置一个temp变量,在交换左右指针的时候只需要先后覆盖就可以了。这样既能减少空间的使用还能降低赋值运算的次数。优化代码如下:

    /**
     *@Description:<p>实现快速排序算法</p>
     *@author 王旭
     *@time 2016-3-3 下午5:07:29
     */
    public class QuickSort {
    
        /**
         * 划分
         * @param arr
         * @param left
         * @param right
         * @return
         */
        public static int partition(int[] arr, int left, int right) {
            int pivotKey = arr[left];
    
            while(left < right) {
                while(left < right && arr[right] >= pivotKey)
                    right --;
                arr[left] = arr[right]; //把小的移动到左边
                while(left < right && arr[left] <= pivotKey)
                    left ++;
                arr[right] = arr[left]; //把大的移动到右边
            }
            arr[left] = pivotKey; //最后把pivot赋值到中间
            return left;
        }
    
        /**
         * 递归划分子序列
         * @param arr
         * @param left
         * @param right
         */
        public static void quickSort(int[] arr, int left, int right) {
            if(left >= right)
                return ;
            int pivotPos = partition(arr, left, right);
            quickSort(arr, left, pivotPos-1);
            quickSort(arr, pivotPos+1, right);
        }
    
        public static void sort(int[] arr) {
            if(arr == null || arr.length == 0)
                return ;
            quickSort(arr, 0, arr.length-1);
        }
    
    }

    总结快速排序的思想:冒泡+二分+递归分治,慢慢体会。。。

    2. 查找

    数据结构–七大查找算法总结
    查找是在大量的信息中寻找一个特定的信息元素,在计算机应用中,查找是常用的基本运算,例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法,说是七种,其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。树表查找和哈希查找会在后续的博文中进行详细介绍。

      查找定义:根据给定的某个值,在查找表中确定一个其关键字等于给定值的数据元素(或记录)。

      查找算法分类:
      1)静态查找和动态查找;
        注:静态或者动态都是针对查找表而言的。动态表指查找表中有删除和插入操作的表。
      2)无序查找和有序查找。
        无序查找:被查找数列有序无序均可;
        有序查找:被查找数列必须为有序数列。
      平均查找长度(Average Search Length,ASL):需和指定key进行比较的关键字的个数的期望值,称为查找算法在查找成功时的平均查找长度。
      对于含有n个数据元素的查找表,查找成功的平均查找长度为:ASL = Pi*Ci的和。
      Pi:查找表中第i个数据元素的概率。
      Ci:找到第i个数据元素时已经比较过的次数。

    2.1. 顺序查找

      说明:顺序查找适合于存储结构为顺序存储或链接存储的线性表。
      基本思想:顺序查找也称为线形查找,属于无序查找算法。从数据结构线形表的一端开始,顺序扫描,依次将扫描到的结点关键字与给定值k相比较,若相等则表示查找成功;若扫描结束仍没有找到关键字等于k的结点,表示查找失败。
      复杂度分析: 
      查找成功时的平均查找长度为:(假设每个数据元素的概率相等) ASL = 1/n(1+2+3+…+n) = (n+1)/2 ;
      当查找不成功时,需要n+1次比较,时间复杂度为O(n);
      所以,顺序查找的时间复杂度为O(n)。
      C++实现源码:

    //顺序查找
    int SequenceSearch(int a[], int value, int n)
    {
        int i;
        for(i=0; i<n; i++)
            if(a[i]==value)
                return i;
        return -1;
    }

    2.2 折半查找/二分查找

    说明:元素必须是有序的,如果是无序的则要先进行排序操作。

      基本思想:也称为是折半查找,属于有序查找算法。用给定值k先与中间结点的关键字比较,中间结点把线形表分成两个子表,若相等则查找成功;若不相等,再根据k与该中间结点关键字的比较结果确定下一步查找哪个子表,这样递归进行,直到查找到或查找结束发现表中没有这样的结点。

      复杂度分析:最坏情况下,关键词比较次数为 log2(n+1) l o g 2 ( n + 1 ) ,且期望时间复杂度为 O(log2n) O ( l o g 2 n )

      注:折半查找的前提条件是需要有序表顺序存储,对于静态查找表,一次排序后不再变化,折半查找能得到不错的效率。但对于需要频繁执行插入或删除操作的数据集来说,维护有序的排序会带来不小的工作量,那就不建议使用。——《大话数据结构》
      
      折半查找算法要求数组本身是排序好的,折半查找算法每次可以排除掉一半的数字,采用了递归的方法。折半查找法不适合采用链式物理结构。
    实现代码:

    /*查找算法练习*/
    #include<stdio.h>
    
    int search(int *p_num,int size,int num){
        int pos = 0;
        for (pos = 0;pos <= size - 1;pos++){
            if (*(p_num + pos) == num){
                return pos;
            }
        }
    }
    
    //折半查找函数
    int half_search(int *p_num,int size,int num){
        if (size > 0){
            if (*(p_num + size / 2) == num){
                return size / 2;
            }
            else if (*(p_num + size / 2) > num){
                return half_search(p_num,size / 2,num);
            }
            else {
                return half_search(p_num + size / 2 + 1,size -
                        size / 2 - 1,num) + size / 2 + 1;   
            }
        }
        else {
            return -1;
            }
    }
    
    int main(){
        //int num[] = {6,9,3,2,10,7,8};
        int num[] = {1,2,3,4,5,6,7,8};
        printf("数字7的下标是%d\n",half_search(num,8,7));
        return 0;
    }

    2.3. 插值查找

      在介绍插值查找之前,首先考虑一个新问题,为什么上述算法一定要是折半,而不是折四分之一或者折更多呢?
      打个比方,在英文字典里面查“apple”,你下意识翻开字典是翻前面的书页还是后面的书页呢?如果再让你查“zoo”,你又怎么查?很显然,这里你绝对不会是从中间开始查起,而是有一定目的的往前或往后翻。
      同样的,比如要在取值范围1 ~ 10000 之间 100 个元素从小到大均匀分布的数组中查找5, 我们自然会考虑从数组下标较小的开始查找。
      经过以上分析,折半查找这种查找方式,不是自适应的(也就是说是傻瓜式的)。二分查找中查找点计算如下:
      mid=(low+high)/2, 即mid=low+1/2*(high-low);
      通过类比,我们可以将查找的点改进为如下:
      mid=low+(key-a[low])/(a[high]-a[low])*(high-low),
      也就是将上述的比例参数1/2改进为自适应的,根据关键字在整个有序表中所处的位置,让mid值的变化更靠近关键字key,这样也就间接地减少了比较次数。
      基本思想:基于二分查找算法,将查找点的选择改进为自适应选择,可以提高查找效率。当然,差值查找也属于有序查找。
      注:对于表长较大,而关键字分布又比较均匀的查找表来说,插值查找算法的平均性能比折半查找要好的多。反之,数组中如果分布非常不均匀,那么插值查找未必是很合适的选择。
      复杂度分析:查找成功或者失败的时间复杂度均为O(log2(log2n))。
      C++实现源码:
      

    /插值查找
    int InsertionSearch(int a[], int value, int low, int high)
    {
        int mid = low+(value-a[low])/(a[high]-a[low])*(high-low);
        if(a[mid]==value)
            return mid;
        if(a[mid]>value)
            return InsertionSearch(a, value, low, mid-1);
        if(a[mid]<value)
            return InsertionSearch(a, value, mid+1, high);
    }
    展开全文
  • 数据结构 :查找 排序 迷宫(dijkstra) 最短路径,
  • 包括常见的排序算法,以及折半查找,首先对要查找的数据排好序,然后用递归调用的方式实现折半查找(包括了两种实现方式)。指定一个排好序的数组和要查找的值,同时指定要查找的左边界和有边界。左右边界要位于数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 729,214
精华内容 291,685
关键字:

查找排序