十大算法+Java代码

已于 2022-11-04 17:27:55 修改
阅读量618 收藏 1
点赞数 2
文章标签： 算法 排序算法 数据结构
于 2022-09-29 14:40:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/protecel_men/article/details/127105941
版权

由于算法非同一时间完成，所以部分未采用SwapClass

public class SwapClass {

    public  static void swap(int[] arr,int i,int j){
        int tem=arr[i];
        arr[i]=arr[j];
        arr[j]=tem;
    }
}

1、折半查找：
又叫二分查找，要求待查找序列有序。取中间位置的值与待查关键字比较，如果中间位置的数大，则向左侧数据重复此过程，否则向右侧执行此过程，如果中间值等于待查找关键字则返回，否则查找失败。

public class Binsearch {
//    递归法
    public int search(int[] arr,int a,int lo,int hi ){
        int mid=(lo+hi)/2;
        if(lo>hi) return -1;
        if(arr[mid]==a) return mid;
        else if(arr[mid]>a)
        {
            return search(arr,a,lo,mid-1);
        } else if (arr[mid] < a) {
           return search(arr,a,mid+1,hi);
        }
        else {
            System.out.println("查询失败");
            return -1;
        }
    }
}
public class MainClass {
    public static void main(String[] args) {

        int[] arr={1,2,3,4,5,6,7,8};
        int lo=0;
        int hi=arr.length-1;
        Binsearch binsearch = new Binsearch();
        int search = binsearch.search(arr, 3, lo, hi);
        if (search < 0) {
            System.out.println("不在序列中");
        }
        else{
            System.out.println("查找成功"+search);
        }
    }
}

2、冒泡排序：
比较前后两个数据，如果前面数据大于后面的数据就交换。对数组的第n-1个数据遍历一趟后，数据长度减一，继续排序。

public class BubbleSearch {
    public int[] search(int[] arr){
        int n=arr.length;
        for(int i=0;i<n;i++)
            for(int j=1;j<n-i;j++)
            {
                if(arr[j]<arr[j-1]){
                    int t;
                    t=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=t;
                }
            }
        return arr;
    }
}
int[] arr={5,4,6,8,2,1,3,5,4};
System.out.println("排序前:");
for (int i : arr) {
    System.out.print(i);
}
BubbleSearch bubbleSearch = new BubbleSearch();
int[] search = bubbleSearch.search(arr);
System.out.println("排序后:");
for (int i : search) {
    System.out.print(i);
}

3、直接插入排序：
将无序区中的数据按序插入已排序区。

public class InsertSort {
    public int[] sort(int[] arr){
        for(int i=1;i<arr.length;i++)
        {
            int insertVal=arr[i];

            int index=i-1;
            while(index>=0&&arr[index]>insertVal)
            {
                arr[index+1]=arr[index];

                arr[index]=insertVal;

                index--;
            }
        }
        return arr;
    }
}
int[] arr={6,5,4,3,2,1};
System.out.println("排序之前:");
for (int i : arr) {
    System.out.print(i);
}
InsertSort insertSort = new InsertSort();
int[] sort = insertSort.sort(arr);
System.out.println("排序之后:");
for (int i : sort) {
    System.out.print(i);
}

4、快速排序法：
从序列中选择一个基准值，将比基准值小的放在左侧，将比序列值大的放在右侧。

int[] arr={9,6,4,3,4};
System.out.println("排序前");
for (int i : arr) {
    System.out.print(i);
}
QuickSort quickSort = new QuickSort();
quickSort.sort(arr,0,arr.length-1);
System.out.println("排序后");
for (int i : arr) {
    System.out.print(i);
}
public class QuickSort {
    public void sort(int[] arr,int lo,int hi){
        int start=lo;
        int end=hi;
        int key=arr[start];
        while(start<end){
            while(start<end&&key<=arr[end]){
                end--;
            }
            if(start!=end&&key>arr[end])
            {
                arr[start]=arr[end];
                start++;
            }
            while(start<end&&key>=arr[start])
            {
                start++;
            }
            if(start!=end&&key<arr[start]){
                arr[end]=arr[start];
                end--;
            }
            if (start == end) {
                arr[start]=key;
            }
        }
        if(start>lo)
        {
           sort(arr, lo, start-1);
        }
        if(end<hi){
            sort(arr, end+1, hi);
        }
    }
}

5、希尔排序：
插入排序的一种，设置一个增量按照增量将序列分割为若干子序列，对每个子序列进行直接插入排序。减小增量循环以上操作直到增量为1。

public class ShellSort {
    public void sort(int[] arr) {
        int dk = arr.length / 2;
        while (dk >= 1) {
            insertSort(arr, dk);
            dk = dk / 2;
        }

    }


    private void insertSort(int[] array, int dt) {
        for (int i = dt; i < array.length; i++) {
            int insert = array[i];
            for (int j = i - dt; j >= 0; j = j - dt) {
                if (array[j] > insert) {
                    array[j + dt] = array[j];
                    array[j] = insert;
                }
            }
        }
    }
}


        System.out.println("排序前");
        for (int i : arr) {
            System.out.print(i);
        }
        ShellSort shellSort = new ShellSort();
        shellSort.sort(arr);
        System.out.println("排序后");
        for (int i : arr) {
            System.out.print(i);
        }

6、归并排序：
递归划分，迭代合并。
在这里插入图片描述

 归并排序
        System.out.println("排序前");
        for (int i : arr) {
            System.out.print(i);
        }
        MergeSort mergeSort = new MergeSort();
        mergeSort.mergeSortFun(arr);
        System.out.print("排序后");
        for (int i : arr) {
            System.out.print(i);
        }
public class MergeSort {
    public void mergeSortFun(int[] arr){
        sort(arr,0,arr.length-1);
    }
    private void sort(int[] arr,int left,int right){
        int center=(left+right)/2;
        if(left<right)
        {
            sort(arr,left,center);
            sort(arr,center+1,right);
            merge(arr,left,center,right);
        }
    }


    private void merge(int[] arr,int le,int mid,int ri){



        int[] tmpArr=new int[arr.length];
        int l_pos=le;
        int r_pos=mid+1;
        int tmp=le;
        int third=le;

        while(l_pos<=mid&&r_pos<=ri){
            if(arr[l_pos]<=arr[r_pos])
            {
                tmpArr[tmp++]=arr[l_pos++];
            }
            if(arr[l_pos]>arr[r_pos])
            {
                tmpArr[tmp++]=arr[r_pos++];
            }
        }
        while (l_pos<=mid){
            tmpArr[tmp++]=arr[l_pos++];
        }
        while (r_pos<=ri){
            tmpArr[tmp++]=arr[r_pos++];
        }
        while(third<=ri)
        {
            arr[third]=tmpArr[third++];
        }

    }
}

7、桶排序：
将序列分成若干份序列分布在桶中，将每个桶排序，最后合并。

System.out.println("排序前");
for (int i : arr) {
    System.out.print(i);
}
BucketSort bucketSort = new BucketSort();
bucketSort.Sort(arr,3);
System.out.println("排序后");
for (int i : arr) {
    System.out.print(i);
}


public class BucketSort {

    /**
     *
     * @param arr  待排序序列
     * @param bucketSize 每个桶数据个数
     */

    public void Sort(int[] arr,int bucketSize){

//        找出序列中最大值和最小值
        int max=Integer.MIN_VALUE;
        int min=Integer.MAX_VALUE;
        for(int i=0;i<arr.length;i++){
            max=Math.max(max,arr[i]);
            min=Math.min(min,arr[i]);
        }



//        按照一个桶装一个数据计算需要多少桶
        int bucketNum=(max-min)/bucketSize+1;
//        创建桶
        int[][] buckets=new int[bucketNum][0];


        for(int i=0;i<arr.length;i++){
            int index=(arr[i]-min)/bucketSize;
            buckets[index]=arrAppend(buckets[index],arr[i]);
        }


//        对桶排序
        int arrIndex=0;
        for (int[] bucket : buckets) {
            InsertSort insertSort = new InsertSort();
            insertSort.sort(bucket);
            for (int i : bucket) {
                arr[arrIndex++]=i;
            }

        }

    }
    private static int[] arrAppend(int[] arr,int val){
        int[] ar = Arrays.copyOf(arr, arr.length + 1);
        ar[ar.length-1]=val;
        return ar;
    }
}

8、基数排序：
根据基数将数据从低位到高位依次排序，基数一般为进制数。

System.out.println("排序前");
for (int i : arr) {
    System.out.print(i);
}
RadixSort radixSort = new RadixSort();
radixSort.sort(arr);
System.out.println("排序后");
for (int i : arr) {
    System.out.print(i);
}




public class RadixSort {
    public void sort(int[] arr) {
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max < arr[i]) {
                max = arr[i];
            }
        }
//        根据数组的最大值求位数
        int time = 0;
        while (max > 0) {
            max /= 10;
            time++;
        }
        List<ArrayList> queue = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            ArrayList<Integer> queue1 = new ArrayList<>();
            queue.add(queue1);
        }
        for (int i = 0; i < time; i++) {
//            为容器中设置数据
            for (int j = 0; j < arr.length; j++) {
                int index = arr[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
                ArrayList<Integer> queue2 = queue.get(index);
                queue2.add(arr[j]);
                queue.set(index, queue2);
            }
//            将容器中的数据放入arr
            int arrIndex = 0;
            for (int k = 0; k < 10; k++) {
                while (queue.get(k).size() > 0) {
                    ArrayList<Integer> queue3 = queue.get(k);
                    arr[arrIndex++] = queue3.get(0);
                    queue3.remove(0);
                }
            }


        }

    }

}

9、简单选择排序：
从无序区选择最小的关键字，放入有序区最后。

 简单选择排序
        System.out.println("排序前");
        for (int i : arr) {
            System.out.print(i);
        }
        System.out.println("\n");
        SelectSort selectSort = new SelectSort();
        selectSort.sort(arr);
        System.out.println("排序后");
        for (int i : arr) {
            System.out.print(i);
        }

public class SwapClass {

    public  static void swap(int[] arr,int i,int j){
        int tem=arr[i];
        arr[i]=arr[j];
        arr[j]=tem;
    }
}

public class SelectSort {
    public void sort(int[] arr){
        for(int j=0;j<arr.length-1;j++){
            int minPos=j;
            for(int i=j+1;i<arr.length;i++){
                if(arr[i]<=arr[minPos]){
                    minPos=i;
                }
            }
            if(minPos==j){
                continue;
            }
            SwapClass.swap(arr,j,minPos);
        }
    }
}

10、堆排序：
将待排序根据索引构建为完全二叉树，索引顺序为从左到右，从上到下，将完全二叉树排序为大顶堆，将堆顶元素与堆尾元素交换，视作堆尾为不在结构中，无序区减少，重复以上操作最终根据索引列出序列。
堆排序根据大，小顶堆的特性，将序列选择排序，根据序列的排序需求选择每次需要排序为大顶堆还是小顶堆。

堆排序
        int[] arr={5,4,3,2,1};
        System.out.println("排序前");
        for (int i : arr) {
            System.out.print(i);
        }
        HeapSort heapSort = new HeapSort();
        heapSort.sort(arr,arr.length);
        System.out.println("\n");
        System.out.println("排序后");
        for (int i : arr) {
            System.out.print(i);
        }


public class HeapSort {
    /**
     *
     * @param arr 待排序列
     * @param l    序列长度
     */

//   求i节点的父节点，为(i-1)/2
//    序列的总长为l，则堆的首个非叶子节点为((n-1)-1)/2,为n/2-1
    public void sort(int[] arr,int l){


//        建堆
        for(int i=l/2-1;i>=0;i--){
            heapify(arr,l,i);
        }
//        排序
        for (int i=l-1;i>0;i--) {
            SwapClass.swap(arr,i,0);
            heapify(arr,i,0);
        }
    }
//    维护堆,使堆元素保持为大顶堆状态
//    根节点的左节点为i*2+1，右节点为i*2+2

    /**
     *
     * @param arr 待排序列
     * @param l   序列长度
     * @param i   当前节点索引
     */
    public void heapify(int[] arr,int l,int i){
        int largest=i;
        int l_nod=i*2+1;
        int r_nod=i*2+2;
        if(l_nod<l&&arr[l_nod]>arr[largest])
        {
            largest=l_nod;
        }
        if(r_nod<l&&arr[r_nod]>arr[largest])
        {
            largest=r_nod;
        }
        if(largest!=i){
            SwapClass.swap(arr,largest,i);
            heapify(arr,l,largest);
        }
    }
}
The ☞smile☜
关注
玩转十大经典排序算法（动图+Java代码）
clonechen
03-07 3270
总结 选择排序 实现一： /** * 选择排序1 * 每次遍历查找剩余元素的最小值然后放到对应的位置 * * @param arr */ public static void SelectionSort1(int[] arr) { int n = arr.length; for (int i = 0;...
java算法代码大全
08-20
这个文档主要为大家提供了一些java中常用函数的代码，便于大家的学习。
算法 | Java 常见排序算法（纯代码）
多氯环己烷的博客
03-22 871
常见十大排序方法：冒泡排序，选择排序，插入排序，快速排序，归并排序，希尔排序，堆排序，计数排序，桶排序，基数排序；
Java 常见算法
最新发布
菜可夫斯基的博客
08-20 1390
也称为折半查找，要求待查找的数组是已排序的。它先将待排序的数组分割成若干个子序列，分别对这些子序列进行插入排序，然后逐步减少子序列的间隔，重复进行插入排序，直到间隔为 1 时，就相当于对整个数组进行了一次插入排序。首先将待排序的数组构建成一个最大堆（或最小堆），然后将堆顶元素（最大或最小元素）与数组的最后一个元素交换，再对剩余的元素进行堆调整，重复这个过程，直到整个数组有序。从一个任意的顶点开始，每次选择一条连接已加入树的顶点和未加入树的顶点的最小权边，将新顶点加入树中，直到所有顶点都在树中。
java算法代码_java经典算法代码
weixin_34316162的博客
02-22 263
java经典算法代码 Java实现ftp功能 import .ftp.*; import .*; import java.awt.*; import java.awt.event.*; import java.applet.*; import java.io.*; public class FtpApplet extends Applet { FtpClient aftp; DataOutputS...
【Java】——基础算法Java代码
qq_50497708的博客
07-09 1323
算法基础笔记，随学随更
基本算法思想Java实现的详细代码
whieenz的专栏
04-25 442
算法是一个程序的灵魂，一个好的算法往往可以化繁为简，高效的求解问题。在程序设计中算法是独立于语言的，无论使用哪一种语言都可以使用这些算法，本文笔者将以Java语言为例介绍一些常用的算法思想。
十大排序算法代码（Java）
10-08
十大排序算法十大排序算法源码，自己整理的，可以直接运行，Java版本
Sortalgorithm:十大排序算法的java实现代码
05-13
本篇将详细介绍"十大排序算法的Java实现代码"，这些算法包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序、计数排序、桶排序和基数排序。 1. 冒泡排序（Bubble Sort）：冒泡排序是最简单的...
数据挖掘十大算法Java实现。.zip
01-14
跨平台性（Write Once, Run Anywhere）： Java的代码可以在不同的平台上运行，只需编写一次代码，就可以在任何支持Java的设备上执行。这得益于Java虚拟机（JVM），它充当了代码和底层硬件之间的中介。 面向对象： ...
Java算法代码模板整理 通用篇
trigger的博客
02-15 1286
目录 常规代码模板 核心代码模式 ACM模式 map set 遍历 自定义比较器 建立大跟堆、小根堆 常规代码模板 核心代码模式 函数名，输入参数，输出参数类型都已经写好，只需要写函数体即可。 ACM模式 啥都没有，需要自己写 这里提供一个模板，主要是读入示例，自己构建出输入参数，那么就可以转化为核心代码模式了，方便过渡。 读入大致是分为两类，数字和字符串。 import java.util.*; public class Main { public.
java 各类算法实现代码
11-01
java 各类算法实现代码
java算法大全源码
09-24
java算法大全源码包，多种多样的算法，可以让你大开眼界，从此不再为算法而烦恼
算法分析与设计代码（全）
09-08
本代码主要简单实现了算法分析中常见的一些基本算法： 1.Ackerman 1.fibonacci 1.hanoi 1.阶乘函数 1.整数划分问题 1.排列问题 2.大整数乘法 2.排序 2.特殊棋盘非递归 3.线性时间查找问题 4.最大子段和 6.背包问题优化 最多约数问题（优化）等
Java中常用算法的代码实现
rico_rico的博客
04-12 706
1、二分查找   **思想：**二分查找又叫做折半查找，它的基本思想是将n个元素分成大致相等的两份，取a[n/2]与x做比较，如果x=a[n/2]，则找到x，算法终止；如果x<a[n/2]，则要在数组a的左半部分按照上述规则继续搜索x；如果x>a[n/2]，则只要在数组a的右半部分搜索x。   如题：使用二分查找找字符串数组{“a”,“b”,“c”,“d”,“e”,“f”,“g”,“h...
常见算法的java实现代码（持续更新中）
孙孙孙孙小四的博客
09-16 1269
还是先写写算法吧，确实自己算法和数据结构的基础很差，还是练习练习这方面
算法 经典的八大排序算法详解和代码实现
菜鸟心声：学的不仅是技术，更是梦想！
12-20 4292
算法 经典的八大排序算法详解和代码实现排序算法的介绍排序的分类算法的时间复杂度时间频度示例图表理解时间复杂度的特点时间复杂度常见的时间复杂度空间复杂度排序算法的时间复杂度冒泡排序基本思想图解代码示例结果展示代码优化结果展示选择排序基本思想图解代码实现结果展示插入排序基本思想图解代码实现结果展示希尔排序基本思想图解代码实现结果展示快速排序基本思想图解代码实现结果展示归并排序基本思想图解代码实现结果展示基数排序基本思想图解代码实现 排序算法的介绍 排序也称排序算法，排序时将一组数据，依指定的顺序进行排列的过程
八种基本算法和代码讲解
class2class的博客
05-09 837
八种基本算法和代码讲解一 冒泡排序通过无序区中相邻记录关键字间的比较和位置的交换,使关键字最小的记录如气泡一般逐渐往上“漂浮”直至“水面” -时间复杂度 最好情况下：正序有序，则只需要比较n次。故，为O(n) 最坏情况下: 逆序有序，则需要比较(n-1)+(n-2)+……+1，故，为O(N*N) 代码演示public void Merge(int[] str)
Java实现十大排序算法详解
"这篇文档介绍了Java中实现的十大排序算法，包括冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序、计数排序、桶排序、基数排序和希尔排序，并提供了每种排序算法的详细描述和Java代码实现。" ### 1. ...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值