标签：顺序 imp 复杂 独立 ati 适用于 数列 oid gen
package paixu;
import java.util.Random;
public class test {
public static void main(String[] args) {
// TODO Auto-generated method stub
int[] a={34,45,6,3,1,3,534,456,3};
int[] b;
b=maopao(a);
System.out.println("冒泡排序:");
for(int c:b){
System.out.print(c+",");
}
b=xuanze(a);
System.out.println();
System.out.println("选择排序:");
for(int c:b){
System.out.print(c+",");
}
b=charu(a);
System.out.println();
System.out.println("插入排序:");
for(int c:b){
System.out.print(c+",");
}
b = quickSort(a,0,a.length-1);
System.out.println();
System.out.println("快速排序:");
for(int c:b){
System.out.print(c+",");
}
b = quickSort2(a,0,a.length-1);
System.out.println();
System.out.println("快速排序2:");
for(int c:b){
System.out.print(c+",");
}
}
// 冒泡排序
/**
* 依次比较相邻的两个数，将小数放在前面，大数放在后面
* 冒泡排序，具有稳定性
* 时间复杂度为O（n^2）
* 不及堆排序，快速排序O（nlogn，底数为2）
* @author liangge
*
*/
public static int[] maopao(int[] a){
for(int i=0;i<a.length-1;i++){
for(int j=a.length-1;j>i;j--){
if(a[j]<a[j-1]){
int temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
return a;
}
// 选择排序
/**
* 选择排序
* 每一趟从待排序的数据元素中选出最小（或最大）的一个元素，
* 顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。
* 选择排序是不稳定的排序方法。
* @author liangge
*
*/
public static int[] xuanze(int[] a) {
for (int i = 0; i < a.length-1; i++) {
int minindex=i;
for (int j = i+1; j < a.length; j++) {
if(a[j]<a[minindex]){
minindex=j;
}
}
if(minindex!=i){
int temp=a[i];
a[i]=a[minindex];
a[minindex]=temp;
}
}
return a;
}
// 插入排序
/**
* 直接插入排序
* 将一个数据插入到已经排好序的有序数据中,从而得到一个新的、个数加一的有序数据
* 算法适用于少量数据的排序，时间复杂度为O(n^2)。是稳定的排序方法。
*/
public static int[] charu(int[] a) {
for (int i = 0; i < a.length-1; i++) {
for (int j = i+1; j > 0; j--) {
if(a[j]<a[j-1]){
int temp=a[j];
a[j]=a[j-1];
a[j-1]=temp;
}
}
}
return a;
}
// 快速排序
/**
* 快速排序 通过一趟排序将要排序的数据分割成独立的两部分，
* 其中一部分的所有数据都比另外一部分的所有数据都要小，
* 然后再按此方法对这两部分数据分别进行快速排序，
* 整个排序过程可以递归进行，以此达到整个数据变成有序序列。
* @author liangge
*
*/
public static int[] quickSort(int a[],int l,int r){
if(l>=r)
return null;
int i = l; int j = r; int key = a[l];//选择第一个数为key
while(i<j){
while(i<j && a[j]>=key)//从右向左找第一个小于key的值
j--;
if(i<j){
a[i] = a[j];
i++;
}
while(i<j && a[i]<key)//从左向右找第一个大于key的值
i++;
if(i<j){
a[j] = a[i];
j--;
}
}
//i == j
a[i] = key;
quickSort(a, l, i-1);//递归调用
quickSort(a, i+1, r);//递归调用
return a;
}
/**
* 快速排序
* @param sort 要排序的数组
* @param start 排序的开始座标
* @param end 排序的结束座标
*/
public static int[] quickSort2(int[] sort, int start, int end) {
// 设置关键数据key为要排序数组的第一个元素，
// 即第一趟排序后，key右边的数全部比key大，key左边的数全部比key小
int key = sort[start];
// 设置数组左边的索引，往右移动判断比key大的数
int i = start;
// 设置数组右边的索引，往左移动判断比key小的数
int j = end;
// 如果左边索引比右边索引小，则还有数据没有排序
while (i < j) {
while (sort[j] > key && j > start) {
j--;
}
while (sort[i] < key && i < end) {
i++;
}
if (i < j) {
int temp = sort[i];
sort[i] = sort[j];
sort[j] = temp;
}
}
// 如果左边索引比右边索引要大，说明第一次排序完成，将sort[j]与key对换，
// 即保持了key左边的数比key小，key右边的数比key大
if (i > j) {
int temp = sort[j];
sort[j] = sort[start];
sort[start] = temp;
}
//递归调用
if (j > start && j < end) {
quickSort(sort, start, j - 1);
quickSort(sort, j + 1, end);
}
return sort;
}
}
标签：顺序 imp 复杂 独立 ati 适用于 数列 oid gen
原文地址：https://www.cnblogs.com/dutf/p/14090586.html
