算法——排序和查找

已于 2023-12-16 15:23:36 修改
阅读量140 收藏
点赞数 1
分类专栏： 总结 文章标签： 算法 排序算法 数据结构
于 2023-03-04 21:01:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/GJ_863/article/details/129339065
版权
本文介绍了Java中实现的四种排序算法：二分查找、分块查找、冒泡排序、选择排序和插入排序。二分查找适用于有序数组，而分块查找则适用于大数据量的情况，通过分块提高查找效率。冒泡排序、选择排序和插入排序是基础排序算法，分别通过相邻元素比较来优化序列。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.本周学习内容

  • 打印流
  • 对象流

2.部分学习内容分享

1. 二分查找

​ 也叫做折半查找

说明：元素必须是有序的，从小到大，或者从大到小都是可以的。

如果是无序的，也可以先进行排序。但是排序之后，会改变原有数据的顺序，查找出来元素位置跟原来的元素可能是不一样的，所以排序之后再查找只能判断当前数据是否在容器当中，返回的索引无实际的意义。

基本思想：也称为是折半查找，属于有序查找算法。用给定值先与中间结点比较。比较完之后有三种情况：

  • 相等

  • 要查找的数据比中间节点小

  • 要查找的数据比中间节点大

代码：

public class A02_BinarySearchDemo1 {
    public static void main(String[] args) {
       
        int[] arr = {7, 23, 79, 81, 103, 127, 131, 147};
        System.out.println(binarySearch(arr, 150));
    }

    public static int binarySearch(int[] arr, int number){
        //1.定义两个变量记录要查找的范围
        int min = 0;
        int max = arr.length - 1;

        //2.利用循环不断的去找要查找的数据
        while(true){
            if(min > max){
                return -1;
            }
            //3.找到min和max的中间位置
            int mid = (min + max) / 2;
            //4.用mid指向的元素跟要查找的元素进行比较
            if(arr[mid] > number){
                max = mid - 1;
            }else if(arr[mid] < number){
                min = mid + 1;
            }else{
                return mid;
            }

        }
    }
}

2. 分块查找

当数据表中的数据元素很多时，可以采用分块查找。

分块查找的过程：

  1. 需要把数据分成N多小块，块与块之间不能有数据重复的交集。
  2. 给每一块创建对象单独存储到数组当中
  3. 查找数据的时候，先在数组查，当前数据属于哪一块
  4. 再到这一块中顺序查找

代码示例：

public class A03_BlockSearchDemo {
    public static void main(String[] args) {
      
        int[] arr = {16, 5, 9, 12,21, 18,
                     32, 23, 37, 26, 45, 34,
                     50, 48, 61, 52, 73, 66};

        //创建三个块的对象
        Block b1 = new Block(21,0,5);
        Block b2 = new Block(45,6,11);
        Block b3 = new Block(73,12,17);

        //定义数组用来管理三个块的对象（索引表）
        Block[] blockArr = {b1,b2,b3};

        //定义一个变量用来记录要查找的元素
        int number = 37;

        //调用方法，传递索引表，数组，要查找的元素
        int index = getIndex(blockArr,arr,number);

        System.out.println(index);



    }

    //利用分块查找的原理，查询number的索引
    private static int getIndex(Block[] blockArr, int[] arr, int number) {
        //1.确定number是在那一块当中
        int indexBlock = findIndexBlock(blockArr, number);

        if(indexBlock == -1){
            //表示number不在数组当中
            return -1;
        }

        int startIndex = blockArr[indexBlock].getStartIndex();
        int endIndex = blockArr[indexBlock].getEndIndex();

        for (int i = startIndex; i <= endIndex; i++) {
            if(arr[i] == number){
                return i;
            }
        }
        return -1;
    }


    //确定number在哪一块当中
    public static int findIndexBlock(Block[] blockArr,int number){ 
        for (int i = 0; i < blockArr.length; i++) {
            if(number <= blockArr[i].getMax()){
                return i;
            }
        }
        return -1;
    }



}

class Block{
    private int max;//最大值
    private int startIndex;//起始索引
    private int endIndex;//结束索引


    public Block() {
    }

    public Block(int max, int startIndex, int endIndex) {
        this.max = max;
        this.startIndex = startIndex;
        this.endIndex = endIndex;
    }

    /**
     * 获取
     * @return max
     */
    public int getMax() {
        return max;
    }

    /**
     * 设置
     * @param max
     */
    public void setMax(int max) {
        this.max = max;
    }

    /**
     * 获取
     * @return startIndex
     */
    public int getStartIndex() {
        return startIndex;
    }

    /**
     * 设置
     * @param startIndex
     */
    public void setStartIndex(int startIndex) {
        this.startIndex = startIndex;
    }

    /**
     * 获取
     * @return endIndex
     */
    public int getEndIndex() {
        return endIndex;
    }

    /**
     * 设置
     * @param endIndex
     */
    public void setEndIndex(int endIndex) {
        this.endIndex = endIndex;
    }

    public String toString() {
        return "Block{max = " + max + ", startIndex = " + startIndex + ", endIndex = " + endIndex + "}";
    }
}

1. 冒泡排序

  1. 相邻的元素两两比较，大的放右边，小的放左边
  2. 第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推
  3. 如果数组中有n个数据，总共只要执行n-1轮的代码就可以
public class A01_BubbleDemo {
    public static void main(String[] args) {
        /*
            冒泡排序：
            核心思想：
            1，相邻的元素两两比较，大的放右边，小的放左边。
            2，第一轮比较完毕之后，最大值就已经确定，第二轮可以少循环一次，后面以此类推。
            3，如果数组中有n个数据，总共我们只要执行n-1轮的代码就可以。
        */


        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};

        for (int i = 0; i < arr.length - 1; i++) {
            for (int j = 0; j < arr.length - 1 - i; j++) {
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }

        printArr(arr);

    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }
}

2. 选择排序

  1. 从0索引开始，跟后面的元素一一比较
  2. 小的放前面，大的放后面
  3. 第一次循环结束后，最小的数据已经确定
  4. 第二次循环从1索引开始以此类推
  5. 第三轮循环从2索引开始以此类推
  6. 第四轮循环从3索引开始以此类推。
public class A02_SelectionDemo {
    public static void main(String[] args) {

        //1.定义数组
        int[] arr = {2, 4, 5, 3, 1};

            if(arr[0] > arr[i]){
                int temp = arr[0];
                arr[0] = arr[i];
                arr[i] = temp;
            }
        }*/
        for (int i = 0; i < arr.length -1; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if(arr[i] > arr[j]){
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }


        printArr(arr);


    }
    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

}

3. 插入排序

将0索引的元素到N索引的元素看做是有序的，把N+1索引的元素到最后一个当成是无序的。

遍历无序的数据，将遍历到的元素插入有序序列中适当的位置，如遇到相同数据，插在后面。

N的范围：0~最大索引

package com.itheima.mysort;


public class A03_InsertDemo {
    public static void main(String[] args) {
        int[] arr = {3, 44, 38, 5, 47, 15, 36, 26, 27, 2, 46, 4, 19, 50, 48};
        int startIndex = -1;
        for (int i = 0; i < arr.length; i++) {
            if(arr[i] > arr[i + 1]){
                startIndex = i + 1;
                break;
            }
        }
        for (int i = startIndex; i < arr.length; i++) {
           
            int j = i;

            while(j > 0 && arr[j] < arr[j - 1]){
                int temp = arr[j];
                arr[j] = arr[j - 1];
                arr[j - 1] = temp;
                j--;
            }

        }
        printArr(arr);
    }

    private static void printArr(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
        System.out.println();
    }

}
数据结构与算法——排序算法
caoxuan666的博客
02-23 2223
排序算法的重要性不言而喻在算法竞赛中经常考到因此我们要好好学习！使用恒定的额外空间，只需要使用他给你的数据一个就地排序算法使用恒定的的额外空间来产生输出（仅修改给定的数组）。它仅通过修改线性表中元素的顺序来对线性表进行排序。例如，插入排序和选择排序是就地排序算法，因为它们不使用任何额外的空间来对线性表进行排序。而归并排序和计数排序的经典实现就不是就地排序算法待排序数据，是否可以一次性的载入到内存中当所有待排序记录不能被一次载入内存进行处理时，这样的排序就被称为外部排序。
数据结构与算法——查找与排序
福气哥110的博客
08-10 1003
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录概述一、查找算法顺序存储结构的查找链式存储结构的查找折半查找（二分查找）其他查找算法二、排序算法简单选择排序冒泡排序插入排序归并排序堆排序快速排序排序比较器 概述 以前看到这样一句话，语言只是工具，算法才是程序设计的灵魂。的确，算法在计算机科学中的地位真的很重要，在很多大公司的笔试面试中，算法掌握程度的考察都占据了很大一部分。不管是为了面试还是自身编程能力的提升，花时间去研究常见的算法还是很有必要的。下面是自己对于算法这部分的学习
算法——查找和排序
热门推荐
zhenaoxi1077的博客
05-11 1万+
查找算法：顺序查找、二分查找、哈希表查找、二叉排序树查找。 排序算法：插入排序、冒泡排序、归并排序、快速排序等。 以下皆为转载： 原文地址： https://www.cnblogs.com/wxisme/p/5243631.html 1.1 冒泡排序： 冒泡排序是最简单的排序之一了，其大体思想就是通过与相邻元素的比较和交换来把小的数交换到最前面。这个过程类似于水泡向上升一样，因此而得...
算法——》排序&&查找
小仙~
11-29 278
一、排序算法 用于将一组数据`按照特定的规则进行排序`。 排序算法可以分为`内部`排序和`外部`排序两种。 不同的排序算法在时间复杂度、空间复杂度和稳定性等方面有所差异，选择合适的排序算法取决于具体的应用场景和数据规模。 二、查找算法 查找算法 = 搜索算法，是一种用于在数据集中`查找特定元素`的算法。 查找算法可以应用于各种数据结构，如数组、链表、树等。
算法——二分查找算法
qq_73201597的博客
02-05 2972
简单来说，"二分"指的是将查找的区间一分为二，通过比较目标值与中间元素的大小关系，确定目标值可能在哪一半区间内，从而缩小查找范围。这个过程不断重复，每次都将当前区间二分，直到找到目标值或确定目标值不存在为止。这种分而治之的策略使得二分查找算法具有较高的效率，时间复杂度为O(log n)。大致图解如下即通过二段性，在每次判断过后可以一次性减少将近一半的数据，然后通过不断的挪移左右区间来筛选出最后的结果。
必学排序算法——堆排序
ycs66的博客
10-27 2208
堆排序算法是必须掌握的一种基础算法，在一些比较出名的竞赛acm、蓝桥杯，并且在一些公司面试题中都可能会出现，而且作为简单题我们必须要拿下，所以我们要引起重视，下面让我们来深入了解堆排序算法。堆排序（Heap Sort）是一种基于堆数据结构的比较排序算法。堆是一个近似完全二叉树的结构，分为最大堆和最小堆。在最大堆中，父节点的值总是大于或等于其子节点的值；而在最小堆中，父节点的值总是小于或等于其子节点的值。堆排序通常使用最大堆来升序排序数组，使用最小堆则可以降序排序数组。
排序算法——希尔排序
weixin_50702814的博客
10-09 848
记录知识点
常见算法——七大查找算法和八大排序
weixin_43022263的博客
04-16 2112
目录查找算法摘要七大查找算法排序算法摘要八大排序算法 查找算法摘要     查找是在大量的信息中寻找一个特定的信息元素，在计算机应用中，查找是常用的基本运算，例如编译程序中符号表的查找。本文简单概括性的介绍了常见的七种查找算法，说是七种，其实二分查找、插值查找以及斐波那契查找都可以归为一类——插值查找。插值查找和斐波那契查找是在二分查找的基础上的优化查找算法。树表查找和哈希查找会在后续的博文中进行...
二分查找算法——在排序数组中查找元素的第一个和最后一个位置
2301_80689220的博客
10-05 484
【代码】二分查找算法——在排序数组中查找元素的第一个和最后一个位置。
十大经典排序算法——java语言
weixin_56781779的博客
11-11 6729
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
常用算法——查找算法
hz_zhangrl的博客
03-16 3260
本篇介绍查找算法，查找指在一些数据元素中，通过一定的方法找出与给定关键字相同数据的元素的过程称为查找。实现查找的方法称查找算法。常用查找算法大致可分为七大查找算法：顺序查找、二分查找、插值查找、Fibonacci查找、分块查找、树表查找和HashTable查找。本篇详细介绍其中的顺序查找、二分查找、插值查找、Fibonacci(斐波那契)查找四种查找算法。
经典算法——二分查找
Lifelong learning
08-09 3912
任何被明确定义的计算过程都可以称作算法，它将某个值或一组值作为输入，并产生某个值或一组值作为输出。所以算法可以被称作将输入转为输出的一系列的计算步骤。说白了就是步骤明确的解决问题的方法。由于是在计算机中执行，所以通常先用伪代码来表示，清晰的表达出思路和步骤，这样在真正执行的时候，就可以使用不同的语言来实现出相同的效果。.........
算法可视化系列——排序算法——插入排序
04-19
综上所述，插入排序是计算机科学中基础且重要的排序算法之一，理解和掌握它的原理和实现方式对提升编程技能具有重要意义。通过算法可视化，我们可以更好地学习和传授这种排序方法，加深对算法本质的理解。
算法基础知识——排序与查找
Remoa的休闲茶馆
03-10 1320
算法基础知识——排序与查找 一、基础知识 1、排序（基本类型、结构体或类） 2、查找（线性查找、二分查找） 二、应用实例 1、排序【华中科技大学】 2、成绩排序【清华大学】 3、成绩排序2【清华大学】 4、特殊排序【华中科技大学】 5、整数奇偶排序【北京大学】 6、小白鼠排队【北京大学】 7、奥运拍讯问题【浙江大学】 8、找x【浙江大学】 9、查找【北京邮电大学】 10、找最小数【北京邮电大学】 11、打印极值点下标【北京大学】 12找位置【华中科技大学】
【力扣hot100题】（073）数组中的第K个最大元素
s478527548的博客
04-09 600
当左指针在右指针左边时，移动左指针到第一个大于mid的位置，移动右指针到第一个小于mid的位置，若左指针在右指针左边，则交换两者元素，循环以上。循环最终结果：左指针指向从左往右第一个大于mid的元素，右指针指向从右往左第一个小于mid的元素，且左指针不在右指针左边。（选择排序做法）继续递归右指针往右部分的数组和右指针往左部分的数组。（这道题做法）若右指针的位置在k右边，则递归右指针往左部分，否则递归右指针往右部分。初写时犯了不少错误，也有很多问题：错误一：最后将mid移至left的位置。
棋盘问题（DFS）
m0_74995784的博客
04-06 880
在一个给定形状的棋盘（形状可能是不规则的）上面摆放棋子，棋子没有区别。要求摆放时任意的两个棋子不能放在棋盘中的同一行或者同一列，请编程求解对于给定形状和大小的棋盘，摆放 kk 个棋子的所有可行的摆放方案数目 CC。
算法刷题记录——LeetCode篇(1.8) [第71~80题](持续更新)
最新发布
weixin_42826353的博客
04-10 816
LeetCode71-80个人刷题总结。
算法篇（八）【递归】
原来是猿的成长足迹
04-08 771
什么是递归？递归就是自己调用自己
二叉树——队列bfs专题
xsc2004zyj的博客
04-06 546
我们之前遇到过二叉树的层序遍历，只需要用队列先进先出的特性就可以达到层序遍历的目的。而这里不是二叉树，也就是说让节点的孩子入队列时不仅仅是左右孩子了，而是它的所有孩子。而我们看这棵多叉树的构造，它的孩子是存储在数组中的。所以我们在让孩子入队时只需要依次让数组中的所有节点入队列即可。而这道题的要求是返回一个二维数组，数组的元素就是每一层的层序遍历结果。
深入解析常用排序与查找算法及其结构
标题《常用排序查找算法详解》与描述《各种排序查找算法》共同指向了一个主题，即深入解析和阐述计算机科学中基础且重要的一类问题——数据排序与查找，并对常用算法进行详尽的讲解。本内容不仅关注于理论讲解，还...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值