十大算法

最新推荐文章于 2024-03-16 03:45:00 发布
最新推荐文章于 2024-03-16 03:45:00 发布
阅读量162 收藏
点赞数 1
分类专栏： java

1、归并排序

public class MergeSort {

    public static void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;// 左指针
        int j = mid + 1;// 右指针
        int k = 0;
        // 把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (a[i] < a[j]) {
                temp[k++] = a[i++];
            } else {
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖nums数组
        for (int k2 = 0; k2 < temp.length; k2++) {
            a[k2 + low] = temp[k2];
        }
    }

    public static void mergeSort(int[] a, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左边
            mergeSort(a, low, mid);
            // 右边
            mergeSort(a, mid + 1, high);
            // 左右归并
            merge(a, low, mid, high);
            System.out.println(Arrays.toString(a));
        }

    }

    public static void main(String[] args) {
        int a[] = { 51, 46, 20, 18, 65, 97, 82, 30, 77, 50 };
        mergeSort(a, 0, a.length - 1);
        System.out.println("排序结果：" + Arrays.toString(a));
    }
}

2、计数排序

public static int[] countSort2(int[] arr){
  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[] help = new int[max - min + 1];
   
  //找出每个数字出现的次数
  for(int i = 0; i < arr.length; i++){
    int mapPos = arr[i] - min;
    help[mapPos]++;
  }
   
  //计算每个数字应该在排序后数组中应该处于的位置
  for(int i = 1; i < help.length; i++){
    help[i] = help[i-1] + help[i];
  }
   
  //根据help数组进行排序
  int res[] = new int[arr.length];
  for(int i = 0; i < arr.length; i++){
    int post = --help[arr[i] - min];
    res[post] = arr[i];
  }
   
  return res;
}

 


public static int[] countSort1(int[] arr){
  if (arr == null || arr.length == 0) {
    return null;
  }
   
  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 help[] = new int[max];
   
  //找出每个数字出现的次数
  for(int i = 0; i < arr.length; i++){
    int mapPos = arr[i] - min;
    help[mapPos]++;
  }
   
  int index = 0;
  for(int i = 0; i < help.length; i++){
    while(help[i]-- > 0){
      arr[index++] = i+min;
    }
  }
   
  return arr;
}

 

3、桶排序

public static void bucketSort(int[] arr){
    
    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) / arr.length + 1;
    ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketNum);
    for(int i = 0; i < bucketNum; i++){
        bucketArr.add(new ArrayList<Integer>());
    }
    
    //将每个元素放入桶
    for(int i = 0; i < arr.length; i++){
        int num = (arr[i] - min) / (arr.length);
        bucketArr.get(num).add(arr[i]);
    }
    
    //对每个桶进行排序
    for(int i = 0; i < bucketArr.size(); i++){
        Collections.sort(bucketArr.get(i));
    }
    
    System.out.println(bucketArr.toString());
    
}

 

#include<iterator>
#include<iostream>
#include<vector>
using namespace std;
const int BUCKET_NUM = 10;
struct ListNode{
    explicit ListNode(int i=0):mData(i),mNext(NULL){}
    ListNode* mNext;
    int mData;
};
ListNode* insert(ListNode* head,int val){
    ListNode dummyNode;
    ListNode *newNode = new ListNode(val);
    ListNode *pre,*curr;
    dummyNode.mNext = head;
    pre = &dummyNode;
    curr = head;
    while(NULL!=curr && curr->mData<=val){
        pre = curr;
        curr = curr->mNext;
    }
    newNode->mNext = curr;
    pre->mNext = newNode;
    return dummyNode.mNext;
}
ListNode* Merge(ListNode *head1,ListNode *head2){
    ListNode dummyNode;
    ListNode *dummy = &dummyNode;
    while(NULL!=head1 && NULL!=head2){
        if(head1->mData <= head2->mData){
            dummy->mNext = head1;
            head1 = head1->mNext;
        }else{
            dummy->mNext = head2;
            head2 = head2->mNext;
        }
        dummy = dummy->mNext;
    }
    if(NULL!=head1) dummy->mNext = head1;
    if(NULL!=head2) dummy->mNext = head2;

    return dummyNode.mNext;
}
void BucketSort(int n,int arr[]){
    vector<ListNode*> buckets(BUCKET_NUM,(ListNode*)(0));
    for(int i=0;i<n;++i){
        int index = arr[i]/BUCKET_NUM;
        ListNode *head = buckets.at(index);
        buckets.at(index) = insert(head,arr[i]);
    }
    ListNode *head = buckets.at(0);
    for(int i=1;i<BUCKET_NUM;++i){
        head = Merge(head,buckets.at(i));
    }
    for(int i=0;i<n;++i){
        arr[i] = head->mData;
        head = head->mNext;
    }
}

完美：
import java.util.ArrayList;

import java.util.LinkedList;

import java.util.List;

import java.util.ListIterator;

 

public class Main {

 

    public static void main(String[] args) {

        // 输入元素均在 [0, 10) 这个区间内

        float[] arr = new float[] { 0.12f, 2.2f, 8.8f, 7.6f, 7.2f, 6.3f, 9.0f, 1.6f, 5.6f, 2.4f };

        bucketSort(arr);

        printArray(arr);

    }

 

    public static void bucketSort(float[] arr) {

        // 新建一个桶的集合

        ArrayList<LinkedList<Float>> buckets = new ArrayList<LinkedList<Float>>();

        for (int i = 0; i < 10; i++) {

            // 新建一个桶，并将其添加到桶的集合中去。

            // 由于桶内元素会频繁的插入，所以选择 LinkedList 作为桶的数据结构

            buckets.add(new LinkedList<Float>());

        }

        // 将输入数据全部放入桶中并完成排序

        for (float data : arr) {

            int index = getBucketIndex(data);

            insertSort(buckets.get(index), data);

        }

        // 将桶中元素全部取出来并放入 arr 中输出

        int index = 0;

        for (LinkedList<Float> bucket : buckets) {

            for (Float data : bucket) {

                arr[index++] = data;

            }

        }

    }

 

    /**

     * 计算得到输入元素应该放到哪个桶内

     */

    public static int getBucketIndex(float data) {

        // 这里例子写的比较简单，仅使用浮点数的整数部分作为其桶的索引值

        // 实际开发中需要根据场景具体设计

        return (int) data;

    }

 

    /**

     * 我们选择插入排序作为桶内元素排序的方法 每当有一个新元素到来时，我们都调用该方法将其插入到恰当的位置

     */

    public static void insertSort(List<Float> bucket, float data) {

        ListIterator<Float> it = bucket.listIterator();

        boolean insertFlag = true;

        while (it.hasNext()) {

            if (data <= it.next()) {

                it.previous(); // 把迭代器的位置偏移回上一个位置

                it.add(data); // 把数据插入到迭代器的当前位置

                insertFlag = false;

                break;

            }

        }

        if (insertFlag) {

            bucket.add(data); // 否则把数据插入到链表末端

        }

    }

 

    public static void printArray(float[] arr) {

        for (int i = 0; i < arr.length; i++) {

            System.out.print(arr[i] + ", ");

        }

        System.out.println();

    }

 

}

4、基数排序


public void radixSort(){ 
        
       int max = array[0]; 
       for(int i=0;i<array.length;i++){ //找到数组中的最大值 
          if(array[i]>max){ 
              max = array[i]; 
          } 
       } 
        
       int keysNum = 0; //关键字的个数，我们使用个位、十位、百位...当做关键字，所以关键字的个数就是最大值的位数 
       while(max>0){ 
          max /= 10; 
          keysNum++; 
       } 
               
       List<ArrayList<Integer>> buckets = new ArrayList<ArrayList<Integer>>(); 
       for(int i=0;i<10;i++){ //每位可能的数字为0~9，所以设置10个桶 
          buckets.add(new ArrayList<Integer>()); //桶由ArrayList<Integer>构成 
       } 
        
       for(int i=0;i<keysNum;i++){ //由最次关键字开始，依次按照关键字进行分配 
            
          for(int j=0;j<array.length;j++){ //扫描所有数组元素，将元素分配到对应的桶中 
              //取出该元素对应第i+1位上的数字，比如258，现在要取出十位上的数字，258%100=58,58/10=5 
              int key =array[j]%(int)Math.pow(10, i+1)/(int)Math.pow(10, i); 
              buckets.get(key).add(array[j]); //将该元素放入关键字为key的桶中 
          } 
            
          //分配完之后，将桶中的元素依次复制回数组 
          int counter = 0; //元素计数器 
          for(int j=0;j<10;j++){ 
              ArrayList<Integer> bucket =buckets.get(j); //关键字为j的桶 
              while(bucket.size()>0){ 
                  array[counter++] = bucket.remove(0); //将桶中的第一个元素复制到数组，并移除 
              } 
          } 
          System.out.print("第"+(i+1)+"轮排序："); 
          display(); 
       } 
        
   }

 

5、冒泡排序

 


/**

 * 冒泡排序 算法

 */


public class BubbleSort {

	public static void main(String[] args) {

		// TODO Auto-generated method stub

		int a[] ={13,15,37,89,60,39,12,109,56,72} ;
		int i = 0;
		int j = 0;
		for(i=0;i<10;i++)
			System.out.print(a[i]+"  ");
		System.out.println();		

		for(i=0;i<a.length;i++)
			for(j=0;j<a.length-i-1;j++)
			{
				if(a[j]>a[j+1])
				{
					int temp;
					temp=a[j];
					a[j]=a[j+1];
					a[j+1]=temp;
				}
			}
		for(i=0;i<10;i++)
			System.out.print(a[i]+"  ");
	}

}

 

6、选择排序


/**

 * 选择排序

 */

public class SelectSort {
	public static void main(String[] args) {
		int a[] ={13,15,37,89,60,39,12,109,56,72} ;
		int i;
		int j;
		for(i = 0;i<a.length;i++)
			System.out.print(a[i]+"  ");
		System.out.println();
		
		for(i = 0;i<a.length;i++){
			int min = a[i];
			for(j = i+1;j<a.length;j++){
				if(min>a[j]){
					int temp;
					temp = min;
					min = a[j];
					a[j] = temp;
				}
			}
			a[i] = min;
		}
		for(i = 0;i<a.length;i++)
			System.out.print(a[i]+"  ");
	}
}

 

7、插入排序


import java.util.Arrays;

 

/**

 * 插入排序

 */

public class InsertSort {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int a[] ={13,15,37,89,60,39,12,109,56,72} ;
		a = insertSort(a);
		String s = Arrays.toString(a);
		System.out.println(s);
	}
	
	public static int[] insertSort(int[] ary){
		for(int i = 1;i < ary.length;i++){
			int temp = ary[i];
			int j;
			for(j = i-1;j>=0;j--){
				if(temp < ary[j]){
					ary[j+1] = ary[j];
				}
				else
					break; //找到插入位置
			}
			ary[j+1] = temp;
		}
		return ary;
	}
}

 

8、快速排序


public class QuickSort {

    public static void quickSort(int[] arr,int low,int high){

        int i,j,temp,t;

        if(low>high){

            return;

        }

        i=low;

        j=high;

        //temp就是基准位

        temp = arr[low];

 

        while (i<j) {

            //先看右边，依次往左递减

            while (temp<=arr[j]&&i<j) {

                j--;

            }

            //再看左边，依次往右递增

            while (temp>=arr[i]&&i<j) {

                i++;

            }

            //如果满足条件则交换

            if (i<j) {

                t = arr[j];

                arr[j] = arr[i];

                arr[i] = t;

            }

 

        }

        //最后将基准为与i和j相等位置的数字交换

         arr[low] = arr[i];

         arr[i] = temp;

        //递归调用左半数组

        quickSort(arr, low, j-1);

        //递归调用右半数组

        quickSort(arr, j+1, high);

    }

 

 

    public static void main(String[] args){

        int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};

        quickSort(arr, 0, arr.length-1);

        for (int i = 0; i < arr.length; i++) {

            System.out.println(arr[i]);

        }

    }

}

 

Richard678
关注
专栏目录
十大经典算法
04-15
第十名：Huffman coding（霍夫曼编码） 霍夫曼编码(Huffman Coding)是一种编码方式，是一种用于无损数据压缩的熵编码（权编码）算法。1952年，David A. Huffman在麻省理工攻读博士时所发明的，并发表于《一种构建极小多余编码的方法》（A Method for the Construction of Minimum-Redundancy Codes）一文。
机器学习十大算法.zip
01-06
《机器学习十大算法》压缩包包含了十个在机器学习领域中广泛应用的算法的详细介绍，每份PDF文件分别对应一个算法。这些算法是机器学习初学者和专业研究者必备的基础知识，涵盖了监督学习、非监督学习以及关联规则...
真正统治世界的十大算法
Embeded system Development
06-10 4665
本文由 伯乐在线 - Justin Wu 翻译自 Marcos Otero。欢迎加入技术翻译小组。转载请参见文章末尾处的要求。 不久前的某一天，我在浏览Reddit发现了一篇有趣的文章《统治世界的十大算法》，作者George Dvorsky在那篇文章中试图解释算法之于当今世界的重要性，以及哪些算法对人类文明最为重要。 此时此刻，如果你已经学过算法的话，那么在你阅读那篇文章时
十大算法排序总结
无雨
07-23 195
十大算法排序总结 排序算法的总结： #基础排序 a.冒泡 谁大谁上，每一轮都把最大的顶到天花板 效率太低O(n²)——掌握swap b.选择排序，效率较低，但经常用它内部的循环方式来找最大值和最小值——怎么一次性求出数组的最大值和最小值 O(n²) c.插排，虽然平均效率低，但是在序列基本有序时，它很快，所以也有其适用范围 Arrays这个工具类在1.7里面做了较大改动 d.希尔（缩小增量排序），是插排的改良，对空间思维训练有帮助 #分治法 1.子问题拆分 2.递归求解子问题 3.合并子问题的解 e.快
十大算法精讲资料.rar
10-21
《十大算法精讲资料》是一份综合性的学习资源，涵盖了数据结构与算法的多个核心领域。这份压缩包中，你将找到对树、图、线性表、栈、队列、动态规划以及回溯等重要算法的详尽解析。下面，我们将深入探讨这些算法的...
数学建模十大算法程序详解.zip
05-19
"数学建模十大算法程序详解.zip"这个压缩包包含了十个常用的数学建模算法，这些算法通常在解决实际问题时扮演着重要角色。下面，我们将详细讨论这些算法及其在MATLAB环境中的应用。 1. **线性规划**：线性规划是一...
数据挖掘十大算法.pdf
09-15
数据挖掘十大算法是该领域内影响力和应用范围最广的算法集合，对于数据分析师和数据科学工程师而言，掌握这些算法是必要的技能之一。 1. C4.5算法：C4.5是一种决策树算法，它是基于信息增益准则来选择特征，构建...
十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）
2301_80215560的博客
03-10 1万+
十大排序算法（冒泡排序、插入排序、选择排序、希尔排序、堆排序、快排、归并排序、桶排序、计数排序、基数排序）十大排序的思想和代码的实现！！！
改变世界的十大算法
程序猿DD
04-16 799
点击上方蓝色“程序猿DD”，选择“设为星标”回复“资源”获取独家整理的学习资料！来源 |乱炖pythonReddit有篇帖子介绍了算法对我们现在生活的重要性，以及哪些算法对现代文明所做...
应用数学十大算法
Er8cJiang的博客
04-01 2751
应用数学十大算法在JCSE2000年2月发表的论文中,Jack Dongarra and Francis Sullivan 挑选了”21世纪科学和工程实践和发展最具影响力的十大算法”,并展示了这些算法的文章,他们具有许可编纂.(Barry Cipra的SIAM新闻文章给出了谁不能访问原始论文的概述).这十大列表吸引了很多人的注意力. 16年后,我虽然很想用不同的方式生成一个列表,看看与原来的top
当今世界十大经典算法
热门推荐
wangkechuang的专栏
08-22 3万+
当今世界，已经被发现或创造的经典算法数不胜数。如果，一定要投票选出你最看重的十大算法，你会作何选择列?有国外网友在StackExchange上发起过投票，让人们投票选出心目中最为经典的算法，最终产生了下面得票数最高的十大经典算法（投票数统计截止到2011年3月7日）： 第十名：Huffman coding（霍夫曼编码）     霍夫曼编码(Huffman Coding)是一种编码方式，是一种用
机器学习和数据挖掘-十大算法.rar
03-11
"机器学习和数据挖掘-十大算法.rar"这个压缩包文件显然聚焦于介绍十种在这些领域广泛应用的算法。这些算法是解决问题的基础工具，对于理解和解决复杂问题具有深远的影响。以下是关于这十大算法的详细解释： 1. **...
多种排序算法代码
zhouyu的博客
12-05 187
冒泡排序 O(n²) public static void bubbleSort(int[] array){ int length = array.length; if(length <= 1){ return; } for(int i = 0; i < length; i++){ boolean flag = true; for(int j = 0; j <length - i - 1; j++){
机器学习——十大算法
最新发布
Like_July_moon的博客
03-16 1万+
线性回归是机器学习中最基础也是应用最广泛的算法之一。它主要用于预测一个或多个自变量（输入特征）与一个因变量（输出标签）之间的线性关系。线性回归模型试图找到一条直线（在二维空间中）或一个超平面（在更高维空间中），使得所有数据点到这条直线或超平面的垂直距离之和最小，这样的直线或超平面称为最佳拟合线或最佳拟合超平面。线性回归模型通常表示为：其中：*y 是因变量，即我们想要预测的输出。*x 是自变量，即输入特征。*w 是权重，表示每个特征对输出影响的程度。
常用十大算法
weixin_54950870的博客
09-25 7163
这里的讲解图主要使用的是尚硅谷韩顺平老师的图，请周知。 目录 二分查找（非递归） 分治算法 动态规划算法 KMP算法 贪心算法 普利姆（Prim）算法 克鲁斯卡尔（Kruskal）算法 迪杰斯特拉（Dijkstra）算法 弗洛伊德（Floyd）算法 骑士周游算法 总结 二分查找（非递归） 二分查找（非递归）算法：前面我们涉及的是递归实现二分查找算法。如今实现的是非递归的方式。同样，二分查找只适用于有序数列。二分查找的运行时间为对数时间O（log2n），即查找到需要的目标...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值