文章标题

排序算法汇总(一)(Java实现)

一、冒泡排序(最容易理解也是一种比较常用的排序算法)
思想：依次比较相邻的两个数,如果发现前一个数比后一个数大,就交换两个数的位置,这样每一组比较下来,就能将该组中最大的一个数放在最后.该算法的时间复杂度为O(n2)
代码实现:
public static void main(String[] args) {
int[] array = new int[]{1,45,7,4,68,1,4,5};
bubbleSort(array);
print(array);
}
public static void bubbleSort(int[] array){
for(int i = array.length - 1;i >= 0;i–){
for(int j = 0;j < i;j++){
if(array[j] > array[j+1]){
int temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
}
public static void print(int[] array){
for(int i = 0;i < array.length;i++){
System.out.print(array[i]+” “);
}
}
二、直接插入排序：
思想：从待排序列的第二个元素开始,依次与前面排列好的元素比较,发现比该元素小的一个元素,就插入到这个元素的后面.该算法的时间复杂度为O(n2)
代码实现：
public static void main(String[] args) {
int[] array = new int[]{1,45,7,4,68,1,4,5};
insrtSort(array);
print(array);
}
public static void insrtSort(int[] array){
for(int i = 1;i < array.length;i++){
if(array[i] > array[i-1]){//如果发现刚开始排序的第一个数比前一个数大,直接继续下一组排序
continue;
}
for(int j = i-1;j >= 0;j–){
if(array[i] >= array[j]){
int temp = array[i];
for(int k = i - 1;k >= j+1;k–){
array[k+1] = array[k];
}
array[j+1] = temp;
break;
}
}
}
}
public static void print(int[] array){
for(int i = 0;i < array.length;i++){
System.out.print(array[i]+” “);
}
}
三、直接选择排序:
思想：从待排序列的第一个元素开始,依次查找出该序列中最小的元素,并将该元素与待排序列的第一个元素交换.时间复杂度为O(n2)
代码实现:
public static void main(String[] args) {
int[] array = new int[]{1,45,7,4,68,1,4,5};
selectSort(array);
print(array);
}
public static void selectSort(int[] array){
for(int i = 0;i < array.length-1;i++){
int index = i;
for(int j = i;j < array.length-1;j++){
if(array[index] > array[j+1]){
index = j+1;
}
}
int temp = array[i];
array[i] = array[index];
array[index] = temp;
}
}
public static void print(int[] array){
for(int i = 0;i < array.length;i++){
System.out.print(array[i]+” “);
}
}
四、快速排序：
思想：第一步是在待排序列中找一个基数(一般是该序列的第一个元素),通过一次比较将小于该基数的元素放在该基数的左边,大于该基数的元素放在该基数的右边,这样一次快速排序就完成了,一般要通过递归调用快速排序才能将该序列变成有序.时间复杂度为O(nlogn).
代码实现:
public static void main(String[] args) {
int[] array = new int[]{1,45,7,4,68,1,4,5};
quickSort(array,0,array.length-1);
print(array);
}
public static void quickSort(int[] array,int low,int high){
int l = low;
int h = high;
int sign = array[low];//待排序列的基数,一般取该序列的第一个值
while(l < h){
while(l < h && array[h] >= sign){
h–;
}
if(l < h){
int temp = array[h];
array[h] = array[l];
array[l] = temp;
l++;
}
while(l < h && array[l] <= sign){
l++;
}
if(l < h){
int temp = array[l];
array[l] = array[h];
array[h] = temp;
h–;
}
}
if(l > low){
quickSort(array,low,l-1);
}
if(h < high){
quickSort(array, l+1, high);
}
}
public static void print(int[] array){
for(int i = 0;i < array.length;i++){
System.out.print(array[i]+” “);
}
}
五、归并排序：
思想：归并排序算法采用的是一种分治思想,将容量比较大的序列划分成两个子序列进行排序,最后将每个子序列合并。时间复杂度是O(nlogn).
代码实现：
public static void main(String[] args) {
int[] array = new int[]{1,5,1,4,7,3,6};
mergeSort(array, 0, array.length - 1);
printArray(array);
}
private static void printArray(int[] array) {
for(int i = 0;i < array.length;i++){
System.out.print(array[i]+” “);
}
}
public static int[] mergeSort(int[] array,int low,int high){
int mid = (low+high)/2;
if(low < high){
mergeSort(array, low, mid);
mergeSort(array, mid + 1, high);
merge(array,low,mid,high);
}
return array;
}
private static void merge(int[] array, int low, int mid, int high) {
int[] temp = new int[high - low + 1];
int i = low;
int j = mid + 1;
int k = 0;
while(i <= mid && j <= high){
if(array[i] <= array[j]){
temp[k++] = array[i++];
}else{
temp[k++] = array[j++];
}
}
while(i <= mid){
temp[k++] = array[i++];
}
while(j <= high){
temp[k++] = array[j++];
}
for(int m = 0;m < temp.length;m++){
array[m+low] = temp[m];
}
}