冒泡排序算法
冒泡排序算法的运作如下:(从后往前)
比较相邻的元素。如果第一个比第二个大,就交换他们两个。
对每个一对相邻元素作同样的工作,从开始第一对到结尾的最后一对,在这一点,最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤,除了最后一个。
持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。
public class Test{
public static void main(String[] agrs){
int[] nums = {34,4,56,17,90,65}; //待排序的数列
//外循环控制轮数
for(int i = 0; i<nums.length-1;i++){
for(int j = 0; j<nums.length-1-i;j++){
if(nums[j]>nums[j+1]){
int temp = nums[j];
nums[j] = nums[j+1];
nums[j+1] = temp;
}
}
//输出结果
for(int n: nums){
System.out.println(n);
}
}
/**
34 4 56 17 90 65
4 34 17 56 65 90 //第一轮 5次
4 17 34 56 65 //第二轮 4次
4 17 34 56 //第三轮 3次
4 17 34 //第四轮 2次
4 17 //第五轮 1次
*/
}
}
总结:冒泡排序算法是常见面试基础算法之一,心法:N个数字来排队,两两相比比小靠前;外层循环N-1,内层循环N-1-i;
选择排序算法
每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好的数列的最后,直到全部待排序的数据元素排完,选择排序是不稳定的排序方法。
public class test3(){
public static void main(String[] args){
int[] nums = {34,4,54,17,90,65};//待排序的数列
int minIndex = 0; //用于记录每次比较的最小值的下标
//控制轮数
for(int i = 0; i<nums.length-1;i++){
minIndex = i //每轮假设一个最小值下标
for(int j = i+1;j<nums.length;j++){
if(nums[minIndex]>nums[j]){
minIndex = j;
}
}
//判断需要交换的数下标是否为自己
if(minIndex!=i){
nums[minIndex] = nums[minIndex]+nums[i];
nuns[i] = nums[minindex]-nums[i];
nums[minIndex] = nums[minIndex]- nums[i];
}
}
//输出结果:
for(int n:nums){
System.out.println(n);
}
}
/*
34 4 56 17 90 65
4 34 56 17 90 65 //第一轮 5次
4 17 56 34 90 65 //第二轮 4次
4 17 34 56 90 65 //第三轮 3次
4 17 34 56 90 65 //第四轮 2次
4 17 34 56 65 90 //第五轮 1次
*/
总结:选择排序是必记的基础算法,数据规模越小越好,好处是不占用额外的内存空间。
直接插入排序算法
(从后向前找到适合位置后插入)
基本思想:每步将一个待排序的记录,按其顺序码大小插入到前面已经排序的子序列的合适位置(从后向前找到合适位置后),直到全部插入排序完为止。
public class test14{
public static void main(String[] agrs){
int[] nums = {34,4,56,17,90,65};//待排序的数列
//控制比较的轮数:
for(int i=1;i<nums.length;i++){
int temp = nums[i]; //记录操作数
int j = 0;
for(j=i-1;j>=0;j--){
if(nums[j]>temp){
nums[j+1] = nums[j];
}else{
break;
}
}
if(nums[j+1]!=temp){
nums[j+1] = temp;
}
}
//输出结果
for(int n :nums){
System.out.println(n);
}
}
}