目录
一、冒泡排序
（平均时间复杂度为O(n²)）
从左到右依次俩俩比较，并进行交换，知道最右边最大为止（也可以从大到小）
代码实现：
public class array {
public static void main(String[] args){
int[] a=new int[] {1,5,8,7,25,7,6};
for(int i=0;i<a.length;i++) {
for(int j=0;j<a.length-1-i;j++) {
if(a[j]>a[j+1]){
int b=a[j];
a[j]=a[j+1];
a[j+1]=b;
}
}
}
System.out.print("冒泡排序结果:");
for (int i = 0;i<a.length;i++){
System.out.print(a[i]+",");
}
}
}二、简单选择排序
（平均时间复杂度为 O(n²)）
1、先找到整个序列中最小的值，然后跟最左边0位进行换位操作；
2、从1位（即就是第二个数字）开始找到最小的数跟1位进行换位操作；
3、依此进行最小值的查找并进行换位操作，直至最后。
代码实现：
public class array {
public static void main(String[] args){
int[] a=new int[] {-1,1,5,8,7,25,7,6545,545};
for(int i=0;i<a.length;i++) {
int min=a[i];
//记录最小值的位置，坐标为0
int minIndex=0;
for(int j=i+1;j<a.length;j++) {
if(min>a[j]){
min=a[i];
minIndex=j;
a[minIndex]=a[i];
a[i]=min;
}
}
}
System.out.print("简单选择排序的结果是：");
for (int i = 0;i<a.length;i++){
System.out.print(a[i]+",");
}
}
}三、堆排序
（平均时间复杂度为 O(nlogn)）
设当前元素在数组中以R[i]表示，那么，
(1) 它的左孩子结点是：R[2*i+1];
(2) 它的右孩子结点是：R[2*i+2];
(3) 它的父结点是：R[(i-1)/2];
(4) R[i] <= R[2*i+1] 且 R[i] <= R[2i+2]。
首先，按堆的定义将数组R[0..n]调整为堆（这个过程称为创建初始堆），交换R[0]和R[n]；
然后，将R[0..n-1]调整为堆，交换R[0]和R[n-1]；
如此反复，直到交换了R[0]和R[1]为止。
以上思想可归纳为两个操作：
（1）根据初始数组去构造初始堆（构建一个完全二叉树，保证所有的父结点都比它的孩子结点数值大）。
（2）每次交换第一个和最后一个元素，输出最后一个元素（最大值），然后把剩下元素重新调整为大根堆。
当输出完最后一个元素后，这个数组已经是按照从小到大的顺序排列了。
代码实现：
public class dui {
public static void main(String[] args) {
int[] arr = new int[] {5,9,2,1,7,6,3,4,8,0};
sort(arr);
System.out.println(Arrays.toString(arr));
}
public static void sort(int[] arr) {
for(int i = (arr.length -1) /2 ;i>=0;i--) {
adjustHeap(arr, i, arr.length);
}
// 对顶元素和最后一个元进行位置互换
for(int i = arr.length-1; i>0 ;i--) {
int temp = arr[i];
arr[i] = arr[0];
arr[0] = temp;
// 重新构建大顶堆
adjustHeap(arr, 0, i);
}
}
public static void adjustHeap(int[] arr,int parent,int length) {
int temp = arr[parent];
//左孩子
int leftChild = 2* parent +1;
while (leftChild < length) {
int rightChild = leftChild +1;
if (rightChild < length && arr[leftChild] < arr[rightChild]) {
leftChild = rightChild;
}
//判断父节点的值是否大于子节点的值
if (temp >= arr[leftChild]) {
break;
}
//否则子节点到父节点中去
arr[parent] = arr[leftChild];
// 将选下来的原来父节点的值再次进行筛选
parent = leftChild;
leftChild = 2* leftChild +1;
}
arr[parent] = temp;
}
}
}四、直接插入排序
（平均时间复杂度：O(n2)）
假设待排序记录
R0,R1,R2,...,Rn−1,Rn
1、将第一个元素
R0
视为一个元素为1的有序序列
2、依次将
R1,R2,...,Rn−1,Rn
插入到前面的有序序列中，每插入一次有序序列的元素数个数加1
3、直到
Rn
也插入到序列中的时候，排序完成
代码实现：
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class InsertSort {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int len = sc.nextInt();
List<Integer> array = new ArrayList<Integer>();
for(int i = 0;i < len;i++) {
int element = sc.nextInt();
array.add(element);
}
insertSort(array);
print(array);
sc.close();
}
/**
* @param array 待排序序列
*/
public static void insertSort(List<Integer> array) {
for(int i = 1;i < array.size();i++) {
int j = i;
while(j > 0 && array.get(j) < array.get(j - 1)) {
int temp = array.get(j);
array.set(j, array.get(j-1));
array.set(j - 1, temp);
j--;
}
}
}
public static void print(List<Integer> array) {
for(int item:array) {
System.out.print(item + " ");
}
}
}五、归并排序
（平均时间复杂度：O(nlogn)）
1、先将序列分为两组
2、分别对两组进行排序
3、进行归并
归并过程为：比较a[i]和b[j]的大小，若a[i]≤b[j]，则将第一个有序表中的元素a[i]复制到r[k]中，并令i和k分别加上1；否则将第二个有序表中的元素b[j]复制到r[k]中，并令j和k分别加上1，如此循环下去，直到其中一个有序表取完，然后再将另一个有序表中剩余的元素复制到r中从下标k到下标t的单元。
代码实现：
public class guibing {
public static void main(String[] args) {
//mian方法使用
//一个数组内部排序
int[] arr3={12,4,34,5,6,45,9};
int[] cArr=new int[7];
mergeOne(arr3, 0, 6, cArr);
System.out.println("一个数组内部排序");
for(int i=0;i<cArr.length;i++){
System.out.println(cArr[i]);
}
}
/**
* 一个数组内部进行排序
*
* **/
public static void mergeOne(int arr[],int startInt,int stopInt,int[] cArr){
//如果范围是1则直接返回。
if(stopInt==startInt){
return;
}
else{
int middle=(startInt+stopInt)/2;
//开始把数组分开---二分法
mergeOne(arr, startInt, middle,cArr);
mergeOne(arr, middle+1, stopInt,cArr);
mergeTwoSort(arr,startInt,middle,stopInt,cArr);
}
}
public static void mergeTwoSort(int arr[],int start,int mid,int end,int[] cArr){
int left=start;//左序列开始角标
int right=mid+1;//右序列开始角标
int cIndex=0;//临时数组
//当两边都有值时执行
while(left <= mid&& end>=right){
//比较两个数组的元素大小，如：A：left=0开始到3，长度为4，B：right=4开始，长度为4
if(arr[left]<arr[right])
{
cArr[cIndex++]=arr[left++];
}else{
cArr[cIndex++]=arr[right++];
}
}
//当右边数组无元素时执行
while(left<=mid){
cArr[cIndex++]=arr[left++];
}
//当左边数组无元素时执行
while(right<=end){
cArr[cIndex++]=arr[right++];
}
//将临时数组全部添加进原数组
cIndex=0;//指针修改为0
while(start<=end){
arr[start++]=cArr[cIndex++];
}
}
}六、快速排序
（平均时间复杂度是：O(nlogn)）
设要排序的数组是A[0]……A[N−1]，首先任意选取一个数据（通常选用数组的第一个数）作为关键数据，然后将所有比它小的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一趟快速排序。值得注意的是，快速排序不是一种稳定的排序算法，也就是说，多个相同的值的相对位置也许会在算法结束时产生变动。
一趟快速排序的算法是：
- 1）设置两个变量i、j，排序开始的时候：i=0，j=N-1；
- 2）以第一个数组元素作为关键数据，赋值给key，即key=A[0]；
- 3）从j开始向前搜索，即由后开始向前搜索(j–)，找到第一个小于key的值A[j]，将A[j]和A[i]互换；
- 4）从i开始向后搜索，即由前开始向后搜索(i++)，找到第一个大于key的A[i]，将A[i]和A[j]互换；
- 5）重复第3、4步，直到i=j； (3,4步中，没找到符合条件的值，即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值，使得j=j-1，i=i+1，直至找到为止。找到符合条件的值，进行交换的时候i， j指针位置不变。另外，i==j这一过程一定正好是i+或j-完成的时候，此时令循环结束）。
代码实现：
public class kuaipai {
public static void main(String[] args) {
int[] a =new int[] {1,58,5,6,4,6,1,2,4,9};
qucik(a,0,a.length-1);
System.out.println(Arrays.toString(a));
}
public static void qucik(int a[ ],int left,int right) {
if(left>right) {
return;
}
int base=a[left];
int i =left;
int j=right;
while (i!=j) {
while (a[j]>=base&&i<j) {
j--;
}
while (a[i]<=base&&i<j) {
i++;
}
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
a[left]=a[i];
a[i]=base;
qucik(a, left, i-1);
qucik(a, i+1, right);
}
}七、希尔排序
（平均时间复杂度是：O(nlogn））
1、先取一个增量a1,然后将待排序的序列按照将距离为a1的数放在一组中的原则分成n组，（最后不够a1个的数也为一组）
2、将所有组数分别进行直接插入排序
3、排好序后再将所有组的数拼接在一起
4、重新选择一个增量a2，使得a2<a1，然后重复上诉步骤即可，直到增量为1，排序完成
代码实现：
public class xier {
public static void main(String[] args) {
int[] arr = new int[] {3,5,4,6,8,9,7,1,2,10};
sort(arr);
System.out.println(Arrays.toString(arr));
}
//逐步写出整个希尔排序
public static void sort(int[] arr) {
// 将10个数组划分为5组，定义一个i代指步长
for(int i = 5;i<arr.length;i++) {
// j应该指向数组当中的第一个元素
for(int j = i-5; j>=0;j-=5) {
if(arr[j] >arr[j+5]) {
int temp = arr[j];
arr[j] = arr[j+5];
arr[j+5] = temp;
}
}
}
// 将10个数组划分为2组，定义一个i代指步长
for(int i = 2;i<arr.length;i++) {
// j应该指向数组当中的第一个元素
for(int j = i-2; j>=0;j-=2) {
if(arr[j] >arr[j+2]) {
int temp = arr[j];
arr[j] = arr[j+2];
arr[j+2] = temp;
}
}
}
for(int i = 1; i<arr.length;i++) {
// j应该指向数组当中的第一个元素
for(int j = i-1;j>=0;j-=1) {
if(arr[j] >arr[j+1]) {
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}八、基数排序
（平均时间复杂度：O(n)）
三、例子（借用百度百科的例子）
第一步
以LSD为例，假设原来有一串数值如下所示：
73, 22, 93, 43, 55, 14, 28, 65, 39, 81
首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：
0
1 81
2 22
3 73 93 43
4 14
5 55 65
6
7
8 28
9 39
第二步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
81, 22, 73, 93, 43, 14, 55, 65, 28, 39
接着再进行一次分配，这次是根据十位数来分配：
0
1 14
2 22 28
3 39
4 43
5 55
6 65
7 73
8 81
9 93
第三步
接下来将这些桶子中的数值重新串接起来，成为以下的数列：
14, 22, 28, 39, 43, 55, 65, 73, 81, 93
这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。
LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。
代码实现：
public class 基数排序 {
public static void main(String[] args) {
int[] arr=new int[] {234,546,13,67,654,76867,345,4567,241};
//对象实现
sort(arr);
System.out.println(Arrays.toString(arr));
}
//实现桶排序 （平均时间复杂度为O(n)）
public static void sort(int[] arr) {
// 找到数组当中最大的数
int max = arr[0];
for(int i = 0;i<arr.length;i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//找到最大值得位数
int maxLength = (max + "").length();
//桶
int[][] bucket = new int[10][arr.length];
//记录的一维数组
int[] bucketElementCounts = new int[10];
int n = 1;
for(int h = 0;h<maxLength;h++) {
for(int i = 0;i<arr.length;i++) {
// 取出每一个元素的个位
int element = arr[i] / n % 10;
//放入到桶当中去
int temp = bucketElementCounts[element];
bucket[element][temp] = arr[i];
bucketElementCounts[element] ++;
}
int index = 0;
for(int k=0;k<bucketElementCounts.length;k++) {
//桶当中有数据才将桶内的数据放入到原数组当中 arr[i]
if(bucketElementCounts[k] != 0) {
for(int l= 0;l<bucketElementCounts[k];l++) {
arr[index++] = bucket[k][l];
}
}
bucketElementCounts[k] = 0;
}
n = n*10;
}
}
}
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
