排序（选择，插入，冒泡，二分法，递归，随机排序）

最新推荐文章于 2024-06-21 17:14:10 发布

泠宛

最新推荐文章于 2024-06-21 17:14:10 发布

阅读量37

点赞数

文章标签：算法 java 数据结构

本文链接：https://blog.csdn.net/m0_65560855/article/details/132286325

版权

排序

选择排序

表现最稳定的排序算法之一，因为无论什么数据进去都是**O(n2)**的时间复杂度，所

以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间

工作原理

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-tbOA4Z2O-1692019814975)(https://gitee.com/zhou-ying-ying/images/raw/master/images/%E9%80%89%E6%8B%A9%E6%8E%92%E5%BA%8F.gif)]

public static void main(String[] args) {
        int[] arr= new int[]{1,52,6,4,3,7,9,2};
        for (int i = 0;i< arr.length;i++){
            int current = arr[i];//为数组元素分配空间  定义一个最小值
            int minIndex = i;//最小元素的下标
            for (int j=i+1;j< arr.length;j++){//
                if(arr[minIndex]>arr[j]){
                    minIndex = j;//得到下标的索引
                }
            }
            arr[i]=arr[minIndex];
            arr[minIndex]=current;
        }
        for(int a:arr) {
            System.out.println(a);
        }
}

插入排序

工作原理

是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

从第一个元素开始，该元素可以认为已经被排序；
取出下一个元素，在已经排序的元素序列中从后向前扫描；
如果该元素（已排序）大于新元素，将该元素移到下一位置；
重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；将新元素插入到该位置后；
重复步骤2~5

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-z4Vtsoy9-1692019814976)(https://gitee.com/zhou-ying-ying/images/raw/master/images/%E6%8F%92%E5%85%A5%E6%8E%92%E5%BA%8F.gif)]

public static void main(String[] args) {
        int[] arr= new int[]{1,12,21,4,35,19,25,2};
        for (int i=1;i<arr.length;i++){
            int current = arr[i];
            int index = i-1;
            while(index >= 0 && current<arr[index]){
                arr[index+1]=arr[index];
                index--;
            }
            arr[index+1]=current;
        }
        for (int a:arr) {
            System.out.println(a);
        }
    }

冒泡排序

它重复地走访过要排序的数组，一次比较两个元素，如果它们的顺序错误就把它们交

换过来。走访数组的工作是重复地进行直到没有再需要交换，也就是说该数列已经排

序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端

 public static void main(String[] args) {
        int[] arr = {25,5,19,2,15,4};
      for (int j=0;j< arr.length;j++){//遍历次数
          for (int i= 0;i< arr.length-1;i++){//两个两个比较
              if(arr[i]<arr[i+1]){
                  int temp =arr[i];
                  arr[i]=arr[i+1];
                  arr[i+1]=temp;
              }
          }
      }
    }

二分法

二分查找（Binary Search）算法，也叫折半查找算法。二分查找的思想非常简单，有

点类似分治的思想。二分查找针对的是一个有序的数据集合，每次都通过跟区间的中

间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间

被缩小为 0

public static void main(String[] args) {
        //二分查找
        int[] arr = {1, 2, 4, 6, 7, 9, 10, 29, 30, 34, 56};
        int key = 30;
        int start = 0;
        int end = arr.length - 1;
        int mid = (start + end) / 2;
        while (end >= start) {
            if (arr[mid] == key) {
                System.out.println(mid);
                break;
            } else if (arr[mid] > key) {
                end = mid - 1;
            } else {
                start = mid + 1;
            }
            mid = (end + start) / 2;
        }
        if (start > end) {
            System.out.println(-1);
        }
    }

随机排名

// 输入成绩随机排名
public static void main(String[] args) {
        // 打乱数组
        int[] nums = new int[5];
        Scanner sc = new Scanner(System.in);
        for (int i = 0; i < nums.length; i++) {
            System.out.println("请输入" + (i + 1) + "个成绩");
            nums[i] = sc.nextInt();
        }
        for (int num : nums) {
            System.out.print(num + "\t");
        }
        System.out.println();
        Random rand = new Random();
        for (int i = 0; i < nums.length; i++) {
            int index = rand.nextInt(nums.length);
            nums[i] = nums[i] ^ nums[index];
            nums[index] = nums[i] ^ nums[index];
            nums[i] = nums[i] ^ nums[index];
        }
        for (int num : nums) {
            System.out.print(num + "\t");
        }

    }

核心：遍历过程中，没获取一个元素，同时随机生成一个索引，让当前索引位置的元素和随机索引位置的元素互换

//需求：某公司开发部5名开发人员，要进行项目进展汇报演讲，现在采取随机排名后进行汇
//报。请先依次录入5名员工的工号，然后展示出一组随机的排名顺序。
public static void main(String[] args) {
// 目标：完成随机排名
// 1、定义一个动态初始化的数组用于存储5名员工的工号
int[] codes = new int[5];
// 2、提示用户录入5名员工的工号。
Scanner sc = new Scanner(System.in);
for (int i = 0; i < codes.length; i++) {
// i = 0 1 2 3 4
System.out.println("请您输入第" + (i + 1) +"个员工的工
号：");
int code = sc.nextInt();
codes[i] = code;
}
// 3、打乱数组中的元素顺序。
// [12, 33, 54, 26, 8]
// i index
Random r = new Random();
for (int i = 0; i < codes.length; i++) {
// codes[i]
// 每遍历到一个数据，都随机一个数组索引范围内的值。
//然后让当前遍历的数据与该索引位置处的值交换。
int index = r.nextInt(codes.length); // 0 - 4
// 定义一个临时变量记住index位置处的值
int temp = codes[index];
// 把i位置处的值赋值给index位置处
codes[index] = codes[i];
// 把index位置原来的值赋值给i位置处
codes[i] = temp;
}
// 4、遍历数组中的工号输出即可
for (int i = 0; i < codes.length; i++) {
System.out.print(codes[i] + " ");
}
}

递归

在 Java 中，递归是指一个方法或函数在执行过程中调用自身的过程。递归可以用来解决许多问题，特别是那些需要对某种数据结构进行深度优先搜索或遍历的问题。递归函数通常包含两部分：基本情况和递归情况。基本情况是指问题可以直接解决的情况，通常是递归函数的终止条件，避免无限递归。递归情况是指问题需要进一步分解才能解决的情况，通常是递归函数中调用自身的部分。
在递归函数中，每次递归都会将问题规模减小，直到达到基本情况，然后开始回溯并合并解决方案，直到最终解决整个问题。递归在某些情况下可以让程序更加简洁和优雅，但也可能会带来性能问题和堆栈溢出等问题。

public class JieCheng {
    public static int factorial(int num) {
        if (num == 1 || num == 0) {
            return 1;
        }
        return num * factorial(num - 1);
    }

    public static void main(String[] args) {
        System.out.println(factorial(5));
    }
}

if (num == 1 || num == 0) {
return 1;
}
return num * factorial(num - 1);
}

public static void main(String[] args) {
    System.out.println(factorial(5));
}

}

泠宛

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
排序（选择，插入，冒泡，二分法，递归，随机排序）

基本情况是指问题可以直接解决的情况，通常是递归函数的终止条件，避免无限递归。在递归函数中，每次递归都会将问题规模减小，直到达到基本情况，然后开始回溯并合并解决方案，直到最终解决整个问题。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。核心：遍历过程中，没获取一个元素，同时随机生成一个索引，让当前索引位置的元素和随机索引位置的元素互换。间元素对比，将待查找的区间缩小为之前的一半，直到找到要查找的元素，或者区间。
复制链接

扫一扫