1.冒泡排序
大的数字往上去,一趟冒泡排序可以找到这个数组中最大的元素
核心代码:
public class Main{
public static void main(String[] args) throws Exception{
int[] so=new int[]{23,24,42,13,43};
for(int i=0;i<so.length-1;i++){//冒泡次数(总共有几项要比)
//冒泡步骤(每一项要和几个项比)
for(int j=0;j<so.length-1-i;i++)
if(so[j]>so[j+1]){
int t=so[j];
so[j]=so[j+1];
so[j+1]=t; } } }}
2.选择排序:
public class Main{
public static void main(String[] args) throws Exception{
int[] so=new int[]{23,24,42,13,43};
for(int i=0;i<so.length-1;i++){//选择排序次数(总共有几项要比)
int min=i;
//每轮需要比较的次数为n-i
for(int j=i+1;j<so.length;j++){
if(so[j]<so[min]){
min=j;
}
}
//将找到的最小值和i位置所在的值进行交换
if(i!=min){
int t=so[i];
so[i]=so[min];
so[min]=t;
}
} }}
3.插入排序:
public static void insertSort(int[] arr){
for(int i=1;i<arr.length;i++)//len-1(从第二个元素开始判断是否往左边移动)
{
int insertIndex=i;
int insertValue=arr[i];//要比较的值保留在这个变量中
//插入的值要比当前索引的前一个值才能插进去
while(insertIndex>0&&insertValue<arr[insertIndex-1]){
arr[insertIndex]=arr[insertIndex-1];//arr[1]=arr[0]
insertIndex--;
}
arr[insertIndex]=insertValue;
}
}
}
4.希尔排序
普通的插入排序是间隔一个比,步长为1
希尔排序的步长是变的
5.快速排序
public static void quickSort(int[] arr,int left,int right){
int l=left;
int r=right;
int mid=arr[(left+right)/2];
int temp=0;
while(l<r){
while(arr[l]<mid)
l++;
while(arr[r]>mid)
r--;
if(l>=r)
break;
//如果发生左索引和右索引停住了,就需要交换值
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
//如果碰到了 6(mid) 7 6这种僵持的情况,需要右索引打破僵局
if(arr[l]==mid)
r--;
//如果碰到了 6 7 6(mid)这种僵持的情况,需要左索引打破僵局
if(arr[r]==mid)
l++;
}
//第一次循环结束后,选择的基准点将数组分为两部分
if(l==r){
l++;
r--;
}
if(left<r)//左半部分的排序
quickSort(arr,left,r);
if(right>l)//右半部分的排序
quickSort(arr,l,right);
}
}
例题:
输入格式
第 11 行为一个正整数 NN,第 22 行包含 NN 个空格隔开的正整数 a_ia
i,为你需要进行排序的数,数据保证了 A_iA i不超过 10^910
输出格式
将给定的 NN 个数从小到大输出,数之间空格隔开,行末换行且无空格。
输入输出样例
输入 #1复制
5
4 2 4 5 1
输出 #1复制
1 2 4 4 5
说明/提示
对于 20%20% 的数据,有 N\leq 10^3N≤10 3
对于 100%100% 的数据,有 N\leq 10^5N≤10 5 。
import java.util.Scanner;
public class Main{
//记住这种开数组的方式,先定义一个static的不定义大小的数组,后面在主函数中在定义数组的大小
static int []arr;
static void quickSort(int left,int right){
int l=left;
int r=right;
int mid=arr[(l+r)/2];
int temp=0;
while(l<r){
while(arr[l]<mid)
l++;
while(arr[r]>mid)
r--;
if(l>=r)
break;
temp=arr[l];
arr[l]=arr[r];
arr[r]=temp;
if(mid==arr[r])
l++;
if(mid==arr[l])
r--;
}
if(l==r){
l++;
r--;
}
if(l<right)
quickSort(l,right);
if(r>left)
quickSort(left,r);
}
public static void main(String[] args) {
Scanner in=new Scanner(System.in);
int n=in.nextInt();
arr =new int[n];
for(int i=0;i<n;i++){
arr[i]=in.nextInt();
}
quickSort(0,n-1);
for(int i=0;i<n;i++)
{
System.out.print(arr[i]);
if(i<n-1)
System.out.print(" ");
}
}
}
6.二分查找法:
使用前提:
数组已经按照升序排列
基本原理:
首先要将查找的元素(key)与数组的中间元素比较
1.如果Key小于中间元素,只需要在数组的前一半元素中继续查找
2.如果Key等于中间元素,匹配成功,查找结束
3.如果key大于中间元素,只需要在数组的后一半元素中继续查找
import java.util.*;
public class Main{
public static int SecondSearch(String[] nn,String q){
int min=0;
int max=nn.length-1;
int mid=0;
while(min<=max){
mid=(min+max)/2;
if(Integer.parseInt(q)<Integer.parseInt(nn[mid])){//在左边
max=mid-1;
}
if(Integer.parseInt(q)>Integer.parseInt(nn[mid]))//在右边
{
min=mid+1;
}
if(Integer.parseInt(q)==Integer.parseInt(nn[mid])){
return mid+1;
}
}
return -1;
}
public static void main(String[] args){
Scanner in=new Scanner(System.in);
String q=in.nextLine();
String[] one=in.nextLine().split(" ");
String[] two=in.nextLine().split(" ");
for(int i=0;i<two.length;i++){
System.out.print(SecondSearch(one,two[i]));
if(i<two.length-1)
System.out.print(" ");
}
}
}