常用排序算法
分类结构图
复杂度
分类
交换冒泡排序
import java.util.Arrays;
public class BubbleExchangeSort{
public static void main(String[] args){
int[] arr=new int[]{5,7,1,3,5,1,0,6};
sort(arr);
System.out.println(Arrays.toString(arr));
}
private static void sort(int[] arr){
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[j]<arr[i]){
int temp=arr[j];
arr[j]=arr[i];
arr[i]=temp;
}
}
}
}
}
交换快速排序
徒手写代码
- 第一次写出错地方：improt java.utils.arrays—>improt java.util.Arrays
sort(arr,0,arr.length);—->sort(arr,0,arr.length-1);
import java.util.Arrays; public class QuickChangeSort{ //切分算法 private static int partition(int[] arr,int lo,int hi){ int key=arr[lo]; while(lo<hi){ while(arr[hi]>=key&&lo<hi) hi--; arr[lo]=arr[hi]; while(arr[lo]<=key&&lo<hi) lo++; arr[hi]=arr[lo]; } arr[hi]=key; return hi; } //排序算法 private static void sort(int[] arr,int lo,int hi){ //终止条件以及异常处理 if(arr==null||lo>=hi)return; int index=partition(arr,lo,hi); sort(arr,lo,index-1); sort(arr,index+1,hi); } //test public static void main(String[] args){ int[] arr=new int[]{5,4,8,6,7,9}; sort(arr,0,arr.length-1); System.out.println(Arrays.toString(arr)); } }
插入直接排序
思路：
- 第一步：从第二个元素开始一次加一，依次和前面所有元素比较。
- 第二步：若该元素小于比较的元素，前面的元素后移；接着比较前面的元素，接着后移。不满足“小于”的条件，将该元素插入到空下的位置。
- 重复一二步骤。
实现
import java.util.Arrays; public class DircetInsertSort{ public static void main(String[] args){ int[] arr=new int[]{5,3,1,4,2,6,9}; sort(arr); System.out.println(Arrays.toString(arr)); } //直接插入排序 private static void sort(int[] arr){ //标记待比较的值 int temp=0; for(int i=1;i<arr.length;i++){ temp=arr[i]; int j; for(j=i-1;j>=0;j--){ //注意这个比较条件，和待比较数据比较 if(temp<arr[j]){ //是所有大于待比较数据都要后移 arr[j+1]=arr[j]; }else break; } arr[j+1]=temp; } } }
插入希尔排序排序
import java.util.Arrays;
public class ShellInsertSort{
public static void main(String[] agrs){
int[] arr=new int[]{4,5,2,7,6,27,2,8,2,5};
sort(arr);
System.out.println(Arrays.toString(arr));
}
/* 0. 获取数组长度：int a=数组长度;
1.a的一半为增量值。
2. 以该增量为基数，对比数据，将小的数据交换到前面。遍历所有数据。
3. 重复1、2步骤。终止条件：增量值小于1。
*/
private static void sort(int[] arr){
//获取初试增量值
int incrementNum=arr.length/2;
while(incrementNum>0){
for(int i=0;i<arr.length;i++){
for(int j=i+incrementNum;j<arr.length;j+=incrementNum){
if(arr[j]<arr[i]){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
}
}
incrementNum/=2;
}
}
}
选择简单排序
思路：每轮比较出最小的值的索引，然后和待比较值交换位置。接着比较下一个，一直进行即可。
import java.util.Arrays; public class SimpleChooseSort{ //简单选择算法 private static void sort(int[] arr){ int minIndex=0; for(int i=0;i<arr.length-1;i++){ minIndex=i; for(int j=i+1;j<arr.length;j++){ // 这里是和arr[min]比较，不是和arr[i]比较 if(arr[j]<arr[minIndex]){ minIndex=j; } } if(minIndex!=i){ int temp=arr[i]; arr[i]=arr[minIndex]; arr[minIndex]=temp; } } } public static void main(String[] args){ int[] arr=new int[]{5,7,1,3,5,1,0,6}; sort(arr); System.out.println(Arrays.toString(arr)); } }
选择堆排序
/*
* 堆选择排序
*/
public static void heapChooseSort(int[] array) {
buildHeap(array);// 构建堆
int n = array.length;
int i = 0;
for (i = n - 1; i >= 1; i--) {
swap(array, 0, i);
heapify(array, 0, i);
}
}
public static void buildHeap(int[] array) {
int n = array.length;// 数组中元素的个数
for (int i = n / 2 - 1; i >= 0; i--)
heapify(array, i, n);
}
public static void heapify(int[] A, int idx, int max) {
int left = 2 * idx + 1;// 左孩子的下标（如果存在的话）
int right = 2 * idx + 2;// 左孩子的下标（如果存在的话）
int largest = 0;// 寻找3个节点中最大值节点的下标
if (left < max && A[left] > A[idx])
largest = left;
else
largest = idx;
if (right < max && A[right] > A[largest])
largest = right;
if (largest != idx) {
swap(A, largest, idx);
heapify(A, largest, max);
}
}
public static void swap(int[] array, int i, int j) {
int temp = 0;
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
归并排序
import java.util.Arrays;
public class MergeSort{
/*
* 思路：以mid为分界线，左右两边依次比较，取小的放到临时数组中。直到所有全部处理完。再把临时数据放到arr[lo,hi]中。
* 1. 在满足lo<hi的前提下，取左开始指针lp=lo，右指针rp=mid+1;
* 2. 左右指针的值对比，取小的放到临时数组中，所对应指针加一，临时数组指针加一。
* 3.
*/
private static void merge(int[] arr,int lo,int mid,int hi){
//临时数组
int[] tempArr=new int[hi-lo+1];
//临时数组下标
int index=0;
//左右指针
int lp=lo,rp=mid+1;
while(lp<=mid&&rp<=hi){
if(arr[lp]<arr[rp]){
tempArr[index++]=arr[lp++];
}else{
tempArr[index++]=arr[rp++];
}
}
while(lp<=mid)
tempArr[index++]=arr[lp++];
while(rp<=hi)
tempArr[index++]=arr[rp++];
//归并
for(int i=0;i<tempArr.length;i++){
arr[lo++]=tempArr[i];
}
}
private static void sort(int[] arr,int lo,int hi){
if(arr==null||lo>=hi)return;
int mid=(lo+hi)/2;
sort(arr,lo,mid);
sort(arr,mid+1,hi);
merge(arr,lo,mid,hi);
}
public static void main(String[] agrs){
int[] arr=new int[]{4,5,2,7,6,27,2,8,2,5};
sort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
}
基数排序
/*
* 基数排序法
*/
public static void radixSort(int[] number, int d) {
int k = 0;
int n = 1;
int m = 1;
int[][] temp = new int[number.length][number.length];
int[] order = new int[number.length];
while (m <= d) {
for (int i = 0; i < number.length; i++) {
int lsd = ((number[i] / n) % 10);
temp[lsd][order[lsd]] = number[i];
order[lsd]++;
}
for (int i = 0; i < d; i++) {
if (order[i] != 0)
for (int j = 0; j < order[i]; j++) {
number[k] = temp[i][j];
k++;
}
order[i] = 0;
}
n *= 10;
k = 0;
m++;
}
}
扫一扫
3157
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
