冒泡排序
冒泡排序用顺序比较的方法，用第一个和第二个比，小的换到左边，接着第二个和第三个比，小的换到左边，这样一直比到最后一位，一轮过后，便把最大的放到了最右边，第二轮便比第一轮少了一次比较，一共比较（数组的长度-1）轮结束。
import java.util.Arrays;
public class Test1 {
public static void main(String[] args) {
int []arr = {3,6,34,43,-12,7,9,22,5};
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 a=arr[j];
arr[j]=arr[j+1];
arr[j+1]=a;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
选择排序
选择排序先用数组第一个数分别和其他的数比较，如果有比它小的就和它交换，这样一轮过后，第一位数就是最小的了，然后开始第二轮的用第二个数和后面的数比较，第二轮比较次数比第一轮次数少一次，一共比较（数组的长度-1）轮结束。
import java.util.Arrays;
public class Test2 {
public static void main(String[] args) {
int []arr = {3,6,34,43,-12,7,9,22,5};
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]>arr[j]){
int a=arr[i];
arr[i]=arr[j];
arr[j]=a;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
直接插入排序
插入排序是思想最为简单的一种，直接将一个新数字插到一个有序数组中，使之仍然保持有序，再插入新的，再调整保持有序，直到全部插入。
例如:
49,38,65,97,76,13,27 原始数据
[49],38,65,97,76,13,27 从1索引开始插入
[38,49], ,65,97,76,13,27
[38,49,65] 97,76,13,27
[38,49,65,97] 76,13,27
[38,49,65,76,97]13,27
[13,27,38,49,65,76,97],27
[13,27,38,49,65,76,97]
import java.util.Arrays;
public class Test3 {
public static void main(String[] args) {
int []arr = {3,6,34,43,-12,7,9,22,5};
for(int i=1;i<arr.length;i++){
for(int j=i;j>0;j--){
if(arr[j]<arr[j-1]){
int a=arr[j];
arr[j]=arr[j-1];
arr[j-1]=a;
}
}
}
System.out.println(Arrays.toString(arr));
}
}
希尔排序
希尔排序通过选择一个合适的间隔，然后将相同间隔的两个数字比较小的放左边，然后缩小间隔，再继续比较相同间隔的两个数字，直到间隔缩小为一，排序完毕。
这样说完包括我在内肯定都听不懂，所以展示一个例子。、
间隔的选取，建议采用knuth方法，间隔定为h*3+1；h的初始值为1，最大间隔时：h小于等于数组长度的三分之一。
import java.util.Arrays;
public class Test4 {
public static void main(String[] args) {
int []arr = {3,6,34,43,-12,7,9,22,5};
int jiange=1;
while(jiange<=arr.length/3){
jiange=jiange*3+1;
}
for(int h=jiange;h>0;h=(h-1)/3){
for(int i=h;i<arr.length;i++){
for(int j=i;j>=h; j-=h){
if(arr[j]<arr[j-h]){
int a = arr[j];
arr[j] = arr[j-h];
arr[j-h]=a;
}
}
}
}
System.out.println(Arrays.toString(arr));
}
}
归并排序
归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
图片来源：https://www.cnblogs.com/chengxiao/p/6194356.html
import java.util.Arrays;
public class Test5 {
public static void main(String[] args) {
int []arr = {3,6,34,43,-12,7,9,22,5};
GuiBing gb = new GuiBing();
gb.chaiFen(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
class GuiBing{
public void chaiFen(int[]arr,int start,int end){
if(start<end){
int center=(start+end)/2;
chaiFen(arr,start,center);
chaiFen(arr,center+1,end);
guiBing(arr,start,center,end);
}
}
private void guiBing(int[] arr, int start, int center, int end) {
int[]tempArr=new int[end-start+1];
int index=0;
int i=start,j=center+1;
while(i<=center&&j<=end){
if(arr[i]<arr[j]){
tempArr[index]=arr[i];
i++;
}else{
tempArr[index]=arr[j];
j++;
}
index++;
}
while(i<=center){
tempArr[index]=arr[i];
i++;
index++;
}
while(j<=end){
tempArr[index]=arr[j];
j++;
index++;
}
for (int k = 0; k < tempArr.length; k++) {
arr[k+start]=tempArr[k];
}
}
}
快速排序
1、从数组中取出一个数，作为基准数。
2、分区：将比这个数大或等于的数全放到他的右边，小于他的数
全放到他的左边。
3.再对左右区间重复第二步，直到各区间只有一个数。
实现思想：挖坑填数
1、将基准数挖出形成第一个坑。
2、由后向前找比他小的数，找到后挖出此数填到前一个坑中。
3、由前向后找比他大或等于的数，找到后也挖出此数填到前一个坑中。
4、再重复执行2，3两步骤。
import java.util.Arrays;
class Test6{
public static void main(String[] args) {
int []arr = {3,6,34,43,-12,7,9,22,5};
quickSort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
public static void quickSort(int[]arr,int start,int end){
if(start<end) {
int index = getIndex(arr, start, end);
quickSort(arr, start, index - 1);
quickSort(arr, index + 1, end);
}
}
public static int getIndex(int[]arr,int start,int end){
int i=start;
int j=end;
int x=arr[i];
while(i<j){
while(i<j&&arr[j]>x){
j--;
}
if(i<j){
arr[i]=arr[j];
i++;
}
while(i<j&&arr[i]<x){
i++;
}
if(i<j){
arr[j]=arr[i];
j--;
}
}
arr[i]=x;
return i;
}
}
基数排序
基数排序的实现不需要进行对关键字的比较，只需要对关键字进行“分配”与“收集”两种操作即可完成。
例如对无序表 {50，123，543，187，49，30，0，2，11，100} 进行基数排序，由于每个关键字都是整数数值，且其中的最大值由个位、十位和百位构成，每个数位上的数字从 0 到 9，首先将各个关键字按照其个位数字的不同进行分配分配表如下图所示：
通过按照各关键字的个位数进行分配，按照顺序收集得到的序列变为：{50，30，0，100，11，2，123，543，187，49}。在该序列表的基础上，再按照各关键字的十位对各关键字进行分配，得到的分配表如下图所示
由上表顺序收集得到的记录表为：{0、100、2、11、123、30、543、49、50、187}。在该无序表的基础上，依次将表中的记录按照其关键字的百位进行分配，得到的分配如下图所示：
最终通过三次分配与收集，最终得到的就是一个排好序的有序表：{0、2、11、30、49、50、100、123、187、543}。
import java.util.Arrays;
import static java.lang.Math.pow;
public class RadixSort {
public static void main(String[] args) {
int []arr={11,15,27,16,20,52};
radixSort(arr);
System.out.println(Arrays.toString(arr));
}
public static void radixSort(int[]arr){
int max=getmax(arr);
int len = String.valueOf(max).length();
int[][]tempArr=new int[10][arr.length];
int[]index=new int[10];
for(int n=0;n<len;n++) {
for (int i = 0; i < arr.length; i++) {
int a = arr[i] / (int) pow(10, i) % 10;
tempArr[a][index[a]++] = arr[i];
}
int x = 0;
for (int i = 0; i < index.length; i++) {
if(index[i]!=0){
for (int j = 0; j < index[i]; j++){
arr[x]=tempArr[i][j];
}
}
System.out.println(index[i]);
index[i]=0;
}
}
}
private static int getmax(int[] arr) {
int a=arr[0];
for (int i = 1; i < arr.length; i++) {
if(a<arr[i]){
a=arr[i];
}
}
return a;
}
}
二分查找
二分查找首先要保证数组是有序的，这里写的二分查找数组的顺序是由小到大，首先找到中间数，若你要找的数大于中间数，则在后一半中找中间数继续比较，如果你要找的数小于中间数，则在前一半中找中间数继续比较，以此类推最终找到。
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int[] arr = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
Scanner sc = new Scanner(System.in);
System.out.println("输入想要查找的数字：");
int i = sc.nextInt();
int index = findIndex(arr,i);
System.out.println("索引为："+index);
}
private static int findIndex(int[] arr, int i) {
int start = 0;
int end = arr.length-1;
int center = (start+end)/2;
while(start<=end){
if(arr[center]==i){
return center;
}else if(arr[center]>i){
end = center-1;
}else if(arr[center]<i){
start = center+1;
}
center = (start+end)/2;
}
return center;
}
}
444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
