基础排序算法，java实现（快速，冒泡，选择，堆排序，插入）
Posted GJS
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了基础排序算法，java实现（快速，冒泡，选择，堆排序，插入）相关的知识，希望对你有一定的参考价值。
1.冒泡排序：
（1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
（2）外面再套个循环就行。
算法复杂度：O(N2) 不罗嗦，上代码：
//冒泡排序（两两交换，外加一个外循环）
public static void bubbleSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=0;i<len-1;i++){
for (j=1;j<len-i;j++){
if (sortData[j-1] > sortData[j]){
swap(sortData,j-1,j);
}
}
}
}
2. 选择排序
（1）每次从剩下无序中选择最小的元素，进行交换
算法复杂度：O(N2) 不罗嗦，上代码：
//选择排序（从剩下的选最大的交换） public static void selectionSort(int sortData[]){ int i,j,min,index,temp; int len = sortData.length; for (i=0;i<len;i++){ min = sortData[i]; index = i; for (j=i+1;j<len;j++){ if (sortData[j] < min){ min = sortData[j]; index = j; } } swap(sortData,i,index); } }
3.插入排序：
（1）基本操作就是将一个数据插入到已经排好序的有序数据中：
//插入排序，把大的往后移动
public static void insertSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=1;i<len;i++){
temp = sortData[i];
for (j = i-1;j>=0 && temp < sortData[j];j--){
sortData[j+1] = sortData[j];
}
sortData[j+1] = temp;
}
}
3.希尔排序：
是插入排序的改进版，主要是希尔通过引入增量，加强了插入排序的威力。随着增量的减少，就有序了。
//希尔排序 public static void shellSort(int sortData[]){ int i,j,temp; int len = sortData.length; int gap = len/2; while(gap>=1){ for (i=gap;i<len;i++){ temp = sortData[i]; for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){ sortData[j+gap] = sortData[j]; } sortData[j+gap] = temp; } gap = gap/2; } }
4.堆排序
（1）初始堆 （2）adjust到最小堆或最大堆的格式 （3）排序，根位置和最后一个位置换一下位置，再adjust。
public static void heapSort(int sortData []){
buildMaxHeap(sortData);
for(int i=sortData.length-1;i>=1;i--){
swap(sortData,0,i);
maxHeap(sortData,i,0);
}
}
public static void buildMaxHeap(int sortData[]){
int half = sortData.length/2;
for(int i=half;i>=0;i--){
maxHeap(sortData,sortData.length,i);
}
}
public static void maxHeap(int sortData[],int heapSize,int index){
int left = 2*index+1;
int right = 2*index+2;
int largest = index;
if (left < heapSize && sortData[left]>sortData[index]){
largest = left;
}
if(right < heapSize && sortData[right]>sortData[index]){
largest = right;
}
if (index != largest){
swap(sortData,index,largest);
maxHeap(sortData,heapSize,largest);
}
}
5. 快速排序：
其实是二分法，一般来说以第一个位置做为分界点，把小的放到这个分界点前面，大的放到后面。递归这两部分。
//快速排序
public static void quickSort(int sortData[],int start,int end){
if (start >=end) return;
int i=start,j=end,value = sortData[i];
boolean flag = true;
while(i!=j){
if (flag){
if (value > sortData[j]){
swap(sortData,i,j);
flag=false;
}else{
j--;
}
}else{
if (value<sortData[i]){
swap(sortData,i,j);
flag=true;
}else{
i++;
}
}
}
//printValue(sortData);
quickSort(sortData,start,j-1);
quickSort(sortData,i+1,end);
}
所有可运行代码：
//gjs public class sort { public static void printValue(int sortData[]){ for (int i = 0;i<sortData.length;i++){ System.out.print(sortData[i]+" "); } System.out.println(); } public static void swap(int [] data ,int pos1, int pos2){ int temp = data[pos1]; data[pos1] = data[pos2]; data[pos2] = temp; } //冒泡排序（两两交换，外加一个外循环） public static void bubbleSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=0;i<len-1;i++){ for (j=1;j<len-i;j++){ if (sortData[j-1] > sortData[j]){ swap(sortData,j-1,j); } } } } //选择排序（从剩下的选最大的交换） public static void selectionSort(int sortData[]){ int i,j,min,index,temp; int len = sortData.length; for (i=0;i<len;i++){ min = sortData[i]; index = i; for (j=i+1;j<len;j++){ if (sortData[j] < min){ min = sortData[j]; index = j; } } swap(sortData,i,index); } } //插入排序，把大的往后移动 public static void insertSort(int sortData[]){ int i,j,temp; int len = sortData.length; for (i=1;i<len;i++){ temp = sortData[i]; for (j = i-1;j>=0 && temp < sortData[j];j--){ sortData[j+1] = sortData[j]; } sortData[j+1] = temp; } } //希尔排序 public static void shellSort(int sortData[]){ int i,j,temp; int len = sortData.length; int gap = len/2; while(gap>=1){ for (i=gap;i<len;i++){ temp = sortData[i]; for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){ sortData[j+gap] = sortData[j]; } sortData[j+gap] = temp; } gap = gap/2; } } public static void heapSort(int sortData []){ buildMaxHeap(sortData); for(int i=sortData.length-1;i>=1;i--){ swap(sortData,0,i); maxHeap(sortData,i,0); } } public static void buildMaxHeap(int sortData[]){ int half = sortData.length/2; for(int i=half;i>=0;i--){ maxHeap(sortData,sortData.length,i); } } public static void maxHeap(int sortData[],int heapSize,int index){ int left = 2*index+1; int right = 2*index+2; int largest = index; if (left < heapSize && sortData[left]>sortData[index]){ largest = left; } if(right < heapSize && sortData[right]>sortData[index]){ largest = right; } if (index != largest){ swap(sortData,index,largest); maxHeap(sortData,heapSize,largest); } } //快速排序 public static void quickSort(int sortData[],int start,int end){ if (start >=end) return; int i=start,j=end,value = sortData[i]; boolean flag = true; while(i!=j){ if (flag){ if (value > sortData[j]){ swap(sortData,i,j); flag=false; }else{ j--; } }else{ if (value<sortData[i]){ swap(sortData,i,j); flag=true; }else{ i++; } } } //printValue(sortData); quickSort(sortData,start,j-1); quickSort(sortData,i+1,end); } public static void main(String[] args) { int [] a={2,4,1,5,8,9,43,3,7,8,9,0,3}; printValue(a); //bubbleSort(a); //selectionSort(a); //insertSort(a); //heapSort(a); //shellSort(a); quickSort(a,0,a.length-1); printValue(a); } }
以上是关于基础排序算法，java实现（快速，冒泡，选择，堆排序，插入）的主要内容，如果未能解决你的问题，请参考以下文章
七大排序算法（插排，希尔，选择排序，堆排，冒泡，快排，归并）--图文详解
八大排序算法C语言过程图解+代码实现（插入，希尔，选择，堆排，冒泡，快排，归并,计数）
常见排序算法基本原理及实现（快排，归并，堆排，直接插入.....）
常见排序算法基本原理及实现（快排，归并，堆排，直接插入.....）