冒泡排序
假设一个数组中有n个元素;
从数组的第一个元素开始,中是比较与后一个元素,如果前一个元素大于后一个元素,就交换位置,否则继续比较后面的元素,直到选出最大的元素。这样的排序类似于水中的冒泡,越大的泡上升的速度越快。这样一共比较n次,第i趟比较n-i-1次。
实现:
package org.westos.demo;
import java.util.logging.Level;
public class Sort {
public static void main(String[] args) {
int[] array={43,12,76,32,9,59};
sortByBub(array);
String s=bianLi(array);
System.out.println(s);
}
//遍历数组,以字符串的形式输出
private static String bianLi(int[] array) {
String s="[";
for (int i=0;i<array.length;i++){
if(i==array.length-1){
s+=array[i]+"]";
}else{
s+=array[i]+",";
}
}
return s;
}
private static void sortByBub(int[] array) {
//循环的趟数
for (int i=0;i<array.length-1;i++){
//每趟比较最大的数
for (int j=0;j<array.length-i-1;j++){
if(array[j]>array[j+1]){
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
}
}
}
}
}
选择排序
相当于将数组分成有序和无序两部分,前面的部分为从小到大的有序部分,每一次拿无序部分的第一个元素和剩余的元素挨个去比较,每一次比较都选出无序部分最小的那一个放到无序的第一个。
实现:
private static void sortBySelect(int[] array) {
for (int i=0;i<array.length-1;i++){
int index=i;
//选出每趟中最小的数往有序部分中依次插入
for(int j=index;j<array.length-1;j++){
if(array[index]>array[j+1]){
int tmp=array[index];
array[index]=array[j+1];
array[j+1]=tmp;
}
}
}
}
n=6
第一趟:index=0;排序后:9, 43,76,32,12,59
第二趟:index=1;排序后:9,12, 76,43,32,59
第三趟:index=2;排序后:9,12,32, 76,43,59
第四趟:index=3;排序后:9,12,32,43, 76,59
第五趟:index=4;排序后:9,12,32,43,59 76
插入排序
和选择排序原理基本相同,分为逻辑上的有序和无序部分,只是插入排序每次从无序序列中选出第一个元素,然后在有序序列中找到合适的位置进行排序。而选择排序是每次从无序序列中选出最小的那一个,直接放在有序序列的最后一个位置。
package org.westos.demo;
public class InsetSort {
public static void main(String[] args) {
int[] array={43,65,21,3,798,45,67};
insertSort(array);
travelArray(array);
}
public static void insertSort(int[] array){
//控制插入元素的个数,也就是控制次数
for (int i=0;i<array.length-1;i++){
//将无序序列中的第一个元素与有序序列中的比较
//找到合适的位置
int j=i;
//循环比较,直到前面的数比要插入的数小为止
while (j>=0&&array[j]>array[j+1]){
int tmp=array[j];
array[j]=array[j+1];
array[j+1]=tmp;
j--;
}
}
}
public static void travelArray(int[] array){
for (int i=0;i<=array.length-1;i++){
if(i==0){
System.out.print("["+array[i]+",");
}else if(i==array.length-1){
System.out.print(array[i]+"]");
}else {
System.out.print(array[i]+",");
}
}
}
}
二分法查找
输入一个有序数组和一个要查找的值elem,如果数组中存在elem则返回这个数的索引,则否返回-1;
实例:
private static int searchBydichotomy(int[] array, int elem) {
int maxIndex=array.length-1;
int minIndex=0;
int midIndex=(maxIndex+minIndex)/2;
//循环终止条件中间的索引不再小于最大数的索引
while (midIndex<maxIndex){
if(elem==array[midIndex]){
//如果找到就返回这个数的索引
return midIndex;
//如果被查的数小于中间的数则将最大数的索引变为中间索引减1,相当于下次将查找数组的前半部分
}else if(elem<array[midIndex]){
maxIndex=midIndex-1;
// 如果被查的数小于中间的数则将最小数的索引变为中间索引加1,下次差查找数组的后半部分
}else if(elem>array[midIndex]){
minIndex=midIndex+1;
}
midIndex=(maxIndex+minIndex)/2;
}
//如果没找到则返回-1
return -1;
}
快速排序
使用递归算法,每次找出基数的正确位置将数组分成逻辑的两部分,继续将左右两部分进行快速排序,每次保证左边索引小于右边索引。
扫描二维码关注公众号,回复:
4145744 查看本文章
package org.westos.Sort;
public class QuiklySort {
public static void main(String[] args) {
int[] array = {54, 32, 76, 90, 102, 5, 23, 78};
quickSort(array, 0, array.length-1);
//将数组遍历成字符形式
for (int i=0;i<=array.length-1;i++){
if(i==0){
System.out.print("["+array[i]+",");
}else if(i==array.length-1){
System.out.print(array[i]+"]");
}else {
System.out.print(array[i]+",");
}
}
}
private static void quickSort(int[] array, int left, int right) {
if (left < right) {
int index = getIndex(array, left, right);
quickSort(array,left,index-1);
quickSort(array,index+1,right);
}
}
public static int getIndex(int[] array, int left, int right) {
int mid = array[left];
//循环直到左边的所有数小于基数,右边的所有基数大于基数,直到找出基数正确的位置
while (left < right) {
//从右向左找,如果右边的数大于基数,则继续right--
while (left<right&&mid <= array[right]) {
right--;
}
//直到找到小于基数的那个数,填入左边的坑,换左边的数开始比较
if(left<right){
array[left] = array[right];
left++;
}
//从左向右找,如果左边的数小于基数,则继续像右找,left++
while (left<right&&mid > array[left]) {
left++;
}
//直到在左边找到比基数大的数,将它填入右边的坑,再比较右边的数
if(left<right){
array[right] = array[left];
right--;
}
}
//把基数填到数组空缺中,并返回它的索引
array[left]=mid;
return left;
}
}