本文目录导航：
java有哪些算法
Java中的算法包括多种类型，关键有排序算法、搜查算法、图算法、树形算法等。
一、排序算法
Java中罕用的排序算法有冒泡排序、选用排序、拔出排序、极速排序、归并排序等。
这些算法在Java的汇合框架中有相应的成功。
例如，冒泡排序是经过不时比拟相邻元素并替换位置来将最大值或最小值移动到序列的一端。
极速排序则基于分治思维，选用一个基准元素，经过递归将小于基准的元素放在左边，大于基准的元素放在左边，从而到达排序的目的。
二、搜查算法
Java中的搜查算法关键有线性搜查、二分搜查等。
线性搜查经过遍历整个数据汇合来查找指标元素，而二分搜查则在有序数组中启动，经过不时增加搜查范围来极速定位指标元素。
此外，哈希表等数据结构在Java中也经常被用于成功高效的搜查操作。
三、图算法
Java中也有许多用于处置图的算法，如最短门路搜查算法（如Dijkstra算法和Bellman-Ford算法）、最小生成树算法（如Prim算法和Kruskal算法）等。
这些算法在处置诸如社交网络、地图导航等场景时十分有用。
四、树形算法
Java中罕用的树形算法包括二叉树遍历、堆排序等。
二叉树遍历用于处置存储在树结构中的数据，经常出现的遍历模式有前序遍历、中序遍历和后序遍历。
堆排序则是一种不凡的排序算法，基于齐全二叉树结构启动元素的调整和比拟。
Java作为一种宽泛经常使用的初级编程言语，领有丰盛的库和工具，准许开发者繁难地经常使用这些算法来处置各种实践疑问。
这些算法在各种运行程序开发中都施展着关键作用，如数据剖析、机器学习、软件开发等。
经常出现的排序算法—选用，冒泡，拔出，极速，归并
太久没看代码了，最近计划温习一下java，又突然想到了排序算法，就把几种经常出现的排序算法用java敲了一遍，这里一致将无序的序列从小到大陈列。
选用排序是一种繁难直观的排序算法。
它的上班原理是：第一次性从待排序的数据元素当选出最小的一个元素，寄存在序列的起始位置，而后再从残余的未排序元素中寻觅到最小元素，继续放在下一个位置，直到待排序元素个数为0。
选用排序代码如下：
public void Select_sort(int[] arr) {
int temp,index;
for( int i=0;i<10;i++) {
for(int j = i + 1 ; j < 10 ; j++) {
if(arr[j] < arr[index])
temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
swap(arr,i,index);
(经过选用排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr[i] + );
冒泡排序是一种比拟基础的排序算法，其思维是相邻的元素两两比拟，较大的元素放前面，较小的元素放前面，这样一次性循环上去，最大元素就会归位，若数组中元素个数为n，则经过（n-1）次后，一切元素就依次从小到大排好序了。
整个环节似乎气泡冒起，因此被称作冒泡排序。
选用排序代码如下：
public void Bubble_sort(int[] arr) {
for(int i = 0 ; i < 9 ; i++) {
for(int j = 0 ; j < 10 - i - 1 ;j++) {
if(arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
swap(arr,j,j+1);
(经过冒泡排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr[i] + );
拔出排序也是一种经常出现的排序算法，拔出排序的思维是：创立一个与待排序数组等大的数组，每次取出一个待排序数组中的元素，而后将其拔出到新数组中适合的位置，使新数组中的元素坚持从小到大的顺序。
拔出排序代码如下：
public void Insert_sort(int[] arr) {
int length = ;
int[] arr_sort = new int[length];
int count = 0;
for(int i = 0;i < length; i++) {
if(count == 0) {
arr_sort[0] = arr[0];
}else if(arr[i] >= arr_sort[count - 1]) {
arr_sort[count] = arr[i];
}else if(arr[i] < arr_sort[0]) {
insert(arr,arr_sort,arr[i],0,count);
for(int j = 0;j < count - 1; j++) {
if(arr[i] >= arr_sort[j] && arr[i] < arr_sort[j+1]) {
insert(arr,arr_sort,arr[i],j+1,count);
(经过拔出排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr_sort[i] + );
public void insert(int[] arr,int[] arr_sort,int value,int index,int count) {
for(int i = count; i > index; i--)
arr_sort[i] = arr_sort[i-1];
arr_sort[index] = value;
极速排序的效率比冒泡排序算法有大幅优化。
由于经常使用冒泡排序时，一次性外循环只能归位一个值，有n个元素最多就要口头（n-1）次外循环。
而经常使用极速排序时，一次性可以将一切元素按大小分红两堆，也就是平均状况下须要logn轮就可以成功排序。
极速排序的思维是：每趟排序时选出一个基准值（这里以首元素为基准值），而后将一切元素与该基准值比拟，并按大小分红左右两堆，而后递归口头该环节，直到一切元素都成功排序。
public void Quick_sort(int[] arr, int left, int right) {
if(left >= right)
int temp,t;
int j = right;
int i = left;
temp = arr[left];
while(i < j) {
while(arr[j] >= temp && i < j)
while(arr[i] <= temp && i < j)
arr[i] = arr[j];
arr[left] = arr[i];
arr[i] = temp;
Quick_sort(arr,left, i - 1);
Quick_sort(arr, i + 1, right);
归并排序是建设在归并操作上的一种有效的排序算法，归并排序对序列的元素启动逐层折半分组，而后从最小分组开局比拟排序，每两个小分组兼并成一个大的分组，逐层启动，最终一切的元素都是有序的。
public void Mergesort(int[] arr,int left,int right) {
if(right - left > 0) {
int[] arr_1 = new int[(right - left)/2 + 1];
int[] arr_2 = new int[(right - left + 1)/2];
for(int i = left;i <= right;i++) {
if(i <= (right + left)/2) {
arr_1[j++] = arr[i];
arr_2[k++] = arr[i];
Mergesort(arr_1,0,(right - left)/2);
Mergesort(arr_2,0,(right - left - 1)/2);
Merge(arr_1,arr_2,arr);
public void Merge(int[] arr_1,int[] arr_2,int[] arr) {
int L1 = arr_;
int L2 = arr_;
while(i < L1 && j < L2) {
if(arr_1[i] <= arr_2[j]) {
arr[k] = arr_1[i];
arr[k] = arr_2[j];
if(i == L1) {
for(int t = j;j < L2;j++)
arr[k++] = arr_2[j];
for(int t = i;i < L1;i++)
arr[k++] = arr_1[i];
归并排序这里我经常使用了left，right等变量，使其可以通用，并没有间接用数字示意那么明白，所以给出关系伪代码，便于了解。
Mergesort(arr[0...n-1])
//输入：一个可排序数组arr[0...n-1]
//输入：非降序陈列的数组arr[0...n-1]
copy arr[0...n/2-1] to arr_1[0...(n+1)/2-1]//确保arr_1中元素个数>=arr_2中元素个数
//关于总个数为奇数时，arr_1比arr_2中元素多一个；关于总个数为偶数时，没有影响
copy arr[n/2...n-1] to arr_2[0...n/2-1]
Mergesort(arr_1[0...(n+1)/2-1])
Mergesort(arr_2[0...n/2-1])
Merge(arr_1,arr_2,arr)
Merge(arr_1[0...p-1],arr_2[0...q-1],arr[0...p+q-1])
//输入：两个有序数组arr_1[0...p-1]和arr_2[0...q-1]
//输入：将arr_1与arr_2两数组兼并到arr
int i<-0;j<-0;k<-0
<p span= do<= jif arr_1[i] <= arr_2[j]
arr[k] <- arr_1[i]
else arr[k] <- arr_2[j];j<-j+1
copy arr_2[j...q-1] to arr[k...p+q-1]
else copy arr_1[i...p-1] to arr[k...p+q-1]
package test_1;
public class Test01 {
public static void main(String[] args) {
Scanner sc = new Scanner();
int[] arr_1 = new int[10];
for(int i = 0 ; i < 10 ; i++)
arr_1[i] = ();
Sort demo_1 = new Sort();
//1~5一次性只能运转一个，若多个同时运转，则只要第一个有效，前面几个是有效排序。
由于第一个运转的曾经将带排序数组排好序。
demo__sort(arr_1);//-----------------------1
//demo__sort(arr_1);//---------------------2
/* //---------------------3
demo__sort(arr_1, 0 , arr_ - 1);
(经过极速排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr_1[i] + );
//demo__sort(arr_1);//--------------------4
/* //--------------------5
demo_(arr_1,0,arr_ - 1);
(经过归并排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr_1[i] + );
class Sort {
public void swap(int arr[],int a, int b) {
arr[a] = arr[b];
public void Select_sort(int[] arr) {
int temp,index;
for( int i=0;i<10;i++) {
for(int j = i + 1 ; j < 10 ; j++) {
if(arr[j] < arr[index])
temp = arr[i];
arr[i] = arr[index];
arr[index] = temp;
swap(arr,i,index);
(经过选用排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr[i] + );
public void Bubble_sort(int[] arr) {
for(int i = 0 ; i < 9 ; i++) {
for(int j = 0 ; j < 10 - i - 1 ;j++) {
if(arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
swap(arr,j,j+1);
(经过冒泡排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr[i] + );
public void Quick_sort(int[] arr, int left, int right) {
if(left >= right)
int temp,t;
int j = right;
int i = left;
temp = arr[left];
while(i < j) {
while(arr[j] >= temp && i < j)
while(arr[i] <= temp && i < j)
arr[i] = arr[j];
arr[left] = arr[i];
arr[i] = temp;
Quick_sort(arr,left, i - 1);
Quick_sort(arr, i + 1, right);
public void Insert_sort(int[] arr) {
int length = ;
int[] arr_sort = new int[length];
int count = 0;
for(int i = 0;i < length; i++) {
if(count == 0) {
arr_sort[0] = arr[0];
}else if(arr[i] >= arr_sort[count - 1]) {
arr_sort[count] = arr[i];
}else if(arr[i] < arr_sort[0]) {
insert(arr,arr_sort,arr[i],0,count);
for(int j = 0;j < count - 1; j++) {
if(arr[i] >= arr_sort[j] && arr[i] < arr_sort[j+1]) {
insert(arr,arr_sort,arr[i],j+1,count);
(经过拔出排序后：);
for(int i = 0 ; i < 10 ; i++)
( arr_sort[i] + );
public void insert(int[] arr,int[] arr_sort,int value,int index,int count) {
for(int i = count; i > index; i--)
arr_sort[i] = arr_sort[i-1];
arr_sort[index] = value;
public void Mergesort(int[] arr,int left,int right) {
if(right - left > 0) {
int[] arr_1 = new int[(right - left)/2 + 1];
int[] arr_2 = new int[(right - left + 1)/2];
for(int i = left;i <= right;i++) {
if(i <= (right + left)/2) {
arr_1[j++] = arr[i];
arr_2[k++] = arr[i];
Mergesort(arr_1,0,(right - left)/2);
Mergesort(arr_2,0,(right - left - 1)/2);
Merge(arr_1,arr_2,arr);
public void Merge(int[] arr_1,int[] arr_2,int[] arr) {
int L1 = arr_;
int L2 = arr_;
while(i < L1 && j < L2) {
if(arr_1[i] <= arr_2[j]) {
arr[k] = arr_1[i];
arr[k] = arr_2[j];
if(i == L1) {
for(int t = j;j < L2;j++)
arr[k++] = arr_2[j];
for(int t = i;i < L1;i++)
arr[k++] = arr_1[i];
若有失误，费事斧正，不胜感谢。
java怎样成功排序
Java成功几种经常出现排序方法 日常操作中经常出现的排序方法有：冒泡排序、极速排序、选用排序、拔出排序、希尔排序，甚至还有基数排序、鸡尾酒排序、桶排序、鸽巢排序、归并排序等。
以下经常出现算法的定义1. 拔出排序：拔出排序基本操作就是将一个数据拔出到曾经排好序的有序数据中，从而获取一个新的、个数加一的有序数据，算法实用于大批数据的排序，期间复杂度为O(n^2)。
是稳固的排序方法。
拔出排序的基本思维是：每步将一个待排序的纪录，按其关键码值的大小拔出前面曾经排序的文件中适当位置上，直到所有拔出完为止。
2. 选用排序：选用排序（Selection sort）是一种繁难直观的排序算法。
它的上班原理是每一次性从待排序的数据元素当选出最小（或最大）的一个元素，寄存在序列的起始位置，直到所有待排序的数据元素排完。
选用排序是不稳固的排序方法。
3. 冒泡排序：冒泡排序（Bubble Sort），是一种计算机迷信畛域的较繁难的排序算法。
它重复地走访过要排序的数列，一次性比拟两个元素，假设他们的顺序失误就把他们替换上来。
走访数列的上班是重复地启动直到没有再须要替换，也就是说该数列曾经排序成功。
这个算法的名字由来是由于越大的元素会经由替换缓缓“浮”到数列的顶端。
4. 极速排序：极速排序（Quicksort）是对冒泡排序的一种改良。
它的基本思维是：经过一趟排序将要排序的数据宰割成独立的两局部，其中一局部的一切数据都比另外一局部的一切数据都要小，而后再按此方法对这两局部数据区分启动极速排序，整个排序环节可以递归启动，以此到达整个数据变成有序序列。
5. 归并排序：归并排序是建设在归并操作上的一种有效的排序算法,该算法是驳回分治法（Divide and Conquer）的一个十分典型的运行。
将已有序的子序列兼并，获取齐全有序的序列；即先使每个子序列有序，再使子序列段间有序。
若将两个有序表兼并成一个有序表，称为二路归并。
6. 希尔排序：希尔排序(Shell Sort)是拔出排序的一种。
也称增加增量排序，是间接拔出排序算法的一种更高效的改良版本。
希尔排序是非稳固排序算法。
希尔排序是把记载按下标的必定增量分组，对每组经常使用间接拔出排序算法排序；随着增量逐渐增加，每组蕴含的关键词越来越多，当增量减至1时，整个文件恰被分红一组，算法便中断。
java十大算法
算法一：极速排序算法极速排序是由东尼·霍尔所开展的一种排序算法。
在平均状况下，排序 n 个名目要Ο(n log n)次比拟。
在最坏状况下则须要Ο(n2)次比拟，但这种状况并不经常出现。
理想上，极速排序理论显著比其余Ο(n log n) 算法更快，由于它的外部循环（inner loop）可以在大局部的架构上很有效率地被成功进去。
极速排序经常使用分治法（Divide and conquer）战略来把一个串行（list）分为两个子串行（sub-lists）。
算法步骤：1 从数列中挑出一个元素，称为 基准（pivot），2 从新排序数列，一切元素比基准值小的摆放在基准前面，一切元素比基准值大的摆在基准的前面（相反的数可以就任一边）。
在这个分区分开之后，该基准就处于数列的两边位置。
这个称为分区（partition）操作。
3 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情景，是数列的大小是零或一，也就是永远都曾经被排序好了。
只管不时递归下去，然而这个算法总会分开，由于在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
算法二：堆排序算法堆排序（Heapsort）是指应用堆这种数据结构所设计的一种排序算法。
沉积是一个近似齐全二叉树的结构，并同时满足沉积的性质：即子结点的键值或索引总是小于（或许大于）它的父节点。
堆排序的平均期间复杂度为Ο(nlogn) 。
算法步骤：创立一个堆H[0..n-1]把堆首（最大值）和堆尾调换3. 把堆的尺寸增加1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置4. 重复步骤2，直到堆的尺寸为1算法三：归并排序归并排序（Merge sort，台湾译作：兼并排序）是建设在归并操作上的一种有效的排序算法。
该算法是驳回分治法（Divide and Conquer）的一个十分典型的运行。
算法步骤：1. 放开空间，使其大小为两个曾经排序序列之和，该空间用来寄存兼并后的序列2. 设定两个指针，最后位置区分为两个曾经排序序列的起始位置3. 比拟两个指针所指向的元素，选用相对小的元素放入到兼并空间，并移动指针到下一位置4. 重复步骤3直到某一指针到达序列尾5. 将另一序列剩下的一切元素
Java经过几种经典的算法来成功数组排序
JAVA中在运用数组启动排序配置时，普通有四种方法：极速排序法、冒泡法、选用排序法、拔出排序法。
极速排序法关键是运用了Arrays中的一个方法（）成功。
冒泡法是运用遍历数组启动比拟，经过不时的比拟将最小值或许最大值一个一个的遍历进去。
选用排序法是将数组的第一个数据作为最大或许最小的值，而后经过比拟循环，输入有序的数组。
拔出排序是选用一个数组中的数据，经过不时的拔出比拟最后启动排序。
上方我就将他们的成功方法逐一详解供大家参考。
<1>应用Arrays带有的排序方法极速排序public class Test2{ public static void main(String[] args){ int[] a={5,4,2,4,9,1}; (a);//启动排序 for(int i: a){ (i);}}}<2>冒泡排序算法public static int[] bubbleSort(int[] args){//冒泡排序算法 for(int i=0;i<-1;i++){for(int j=i+1;j<;j++){if (args[i]>args[j]){int temp=args[i];args[i]=args[j];args[j]=temp;} } } return args;}<3>选用排序算法public static int[] selectSort(int[] args){//选用排序算法for (int i=0;i<-1 ;i++ ){ int min=i; for (int j=i+1;j< ;j++ ){ if (args[min]>args[j]){min=j;} } if (min!=i){int temp=args[i];args[i]=args[min];args[min]=temp;}} return args;}<4>拔出排序算法public static int[] insertSort(int[] args){//拔出排序算法for(int i=1;i<;i++){for(int j=i;j>0;j--){if (args[j]<args[j-1]){int temp=args[j-1]; args[j-1]=args[j];args[j]=temp;}else break; } } return args; }
评论（0）