冒泡排序（核心思想:通过两两比较将最小/大值移至数组末位）
public static void main(String[] args) {
int array[]= new int[9]; //定义数组
int temp;//定义临时变量
int isChange ;//定义变量用来标识是否改变
int num=0;//置换次数
for (int i = 0; i <9 ; i++) {
array[i]=new Random().nextInt(50);
}//初始化数组
for (int i = 0; i < array.length-1; i++) {
isChange=0;
for (int j = 0; j < array.length-i-1; j++) {
temp=array[j];
if (array[j]>array[j+1])
{
//大的数字往后移
temp=array[j+1];
array[j+1]=array[j];
array[j]=temp;
//说明发生改变
isChange=1;
num++;
}
}
if (isChange==0)
{
break;
}
}
//遍历数组
for (int i : array) {
System.out.println(i);
}
System.out.println(num+"asdad");
}
选择排序（核心思想:通过两两比较获取最大/小值下标与数组末置位置换）
public static void main(String[] args) {
int array[]= new int[9]; //定义数组
int temp;//定义临时变量
// int isChange ;//定义变量用来标识是否改变
int pos;//用来置换变量
for (int i = 0; i <9 ; i++)
{
array[i]=new Random().nextInt(50);
}//初始化数组
for (int i = 0; i <array.length-1 ; i++) {
pos=0;
for (int j = 0; j < array.length-i; j++) {
if(array[j]>array[pos])
{
//将数组大的地址给它
pos=j;
}
//交换
temp=array[pos];
array[pos]=array[array.length-1-i];
array[array.length-1-i]=temp;
}
}
for (int i : array) {
System.out.println(i);
}
}
插入排序（核心思想:）
public static void main(String[] args) {
int arrays[] = new int[9]; //定义数组
int temp;//定义临时变量
for (int i = 0; i < 9; i++) {
arrays[i] = new Random().nextInt(50);
}//初始化数组
//外层循环控制需要排序的趟数(从1开始因为将第0位看成了有序数据)
for (int i = 1; i < arrays.length; i++) {
temp = arrays[i];
//如果前一位(已排序的数据)比当前数据要大，那么就进入循环比较[参考第二趟排序]
int j = i - 1;
while (j >= 0 && arrays[j] > temp) {
//往后退一个位置，让当前数据与之前前位进行比较
arrays[j + 1] = arrays[j];
//不断往前，直到退出循环
j--;
}
//退出了循环说明找到了合适的位置了，将当前数据插入合适的位置中
arrays[j + 1] = temp;
}
//遍历数组
for (int array : arrays) {
System.out.println(array);
}
}
快速排序（核心思想：自定义一个支点（一个用来比较的数字）,将比支点大的数字放在左边，比支点小的数字放在支点右边）【递归思想】
public static void main(String[] args) {
int arrays[] = new int[19]; //定义数组
int temp;//定义临时变量
for (int i = 0; i < 19; i++) {
arrays[i] = new Random().nextInt(50);
}//初始化数组
for (int array : arrays) {
System.out.print(array+"->");
}
System.out.println();
//初始化数组
quickSort(arrays,0,arrays.length-1);
for (int array : arrays) {
System.out.print(array+"->");
}
}
public static void quickSort(int []arrays,int L,int R) {
int i=L;
int j=R;
//支点
int pivot=arrays[(L+R)/2];//取中心点,只要两端没有交替,就一直扫描
//左右两边扫描,
while (i<=j)
{
//寻找直到比支点大的数
while (pivot>arrays[i])
i++;
//寻找直到比支点小的数
while (pivot<arrays[j])
j--;
//此时已经分别找到了比支点小的数的右边,比支点大的数在左边，它们进行交换
if(i<=j)
{
int temp=arrays[i];
arrays[i]=arrays[j];
arrays[j]=temp;
i++;
j--;
}
}
//以上步骤完成第一躺排序操作,左边表示比支点小，右边表示比支点大
//左边进行排序,查到左边之剩下一个数
if (L<j)
quickSort(arrays,L,j);
//右边进行排序,查到右边之剩下一个数
if (i<R)
quickSort(arrays,i,R);
}
希尔排序：（核心思想，先分组，最后插入排序）
public static void main(String[] args) {
int arrays[] = new int[9]; //定义数组
int temp;//定义临时变量
for (int i = 0; i < 9; i++) {
arrays[i] = new Random().nextInt(50);
}//初始化数组
for (int array : arrays) {
System.out.print(array+"->");
}
System.out.println();
shellSort(arrays);
for (int array : arrays) {
System.out.print(array+"->");
}
System.out.println();
}
public static void shellSort(int[] arrays) {
//增量每次都/2
for (int step = arrays.length / 2; step > 0;
step /= 2) {
//从增量那组开始进行插入排序，直至完毕
for (int i = step; i < arrays.length; i++) {
int j = i;
int temp = arrays[j];
// j - step 就是代表与它同组隔壁的元素
while (j - step >= 0 && arrays[j - step] > temp) {
arrays[j] = arrays[j - step];
j = j - step;
}
arrays[j] = temp;
}
}
}
堆排序：（核心思想：将数组构造为二叉树形式，利用比较，置换将根节点变成最大，拿出，重复以上动作）
归并排序：（核心思想：将数组分组直到不能分为止,然后进行比较后排序，合并排序好的分组）
二分查找算法：（核心思想：查找的值每次与数组中间的值比较，确定下一步操作）
int binarysearch(int array[], int low, int high, int target) {
if (low > high) return -1;
int mid = low + (high - low) / 2;
if (array[mid] > target)
return binarysearch(array, low, mid - 1, target);
if (array[mid] < target)
return binarysearch(array, mid + 1, high, target);
return mid;
}
浙公网安备 33010602011771号