java常用排序算法

}
}
/**
* 插入排序，速度比冒泡排序和直接选择排序都要快
* 直接插入排序，外层循环控制轮数，内层循环与外层循环进行比较判断交换
* 第n轮结束后前面n个数是有序的
*/
public static void sort3(int[] data) {
int len = data.length;
data[j] = data[i];
}
}
data[i] = temp;
qsort(data,start,i-1);
qsort(data,i+1,end);
}
}
/**
* 非递归二分查找法查找特定整型数据在数组中的位置
* 要查找的数组必须是有序的,假定为正序
}
/**
* 交换排序的一种，效率较差
* 冒泡排序，外层循环控制轮数，内层循环中临近两个进行比较判断交换
* 第n轮结束后后面n个数是有序的
*/
public static void sort1(int[] data) {
int len = data.length;
return -1;
}
int mid = (start+end) >> 1;
if(dataset[mid]>data) {
return binarySearch(dataset,data,start,mid-1);
} else if(dataset[mid]<data) {
*/
public static int binarySearch(int[] dataset,int data,int start,int end) {
if(start<0 || end>=dataset.length || start>end || dataset[start]>data || dataset[end]<data) {
* @return 目标数字在数组中的位置，如果不存在返回-1，如果要查找的数字有多个，返回哪一个的位置不确定
*/
public static int binarySearch(int[] dataset,int data) {
int len = dataset.length;
if(dataset[0]>data || dataset[len-1]<data) {
// printArray(data);
// sort2(data);
// System.out.println("直接选择排序后：");
// printArray(data);
// sort3(data);
// System.out.println("插入排序后：");
for(int i=1;i<len;i++) {
for(int j=0;j<len-i;j++) {
if(data[j]>data[j+1]) {
swap(data,j,j+1);
}
}
}
}
/**
* 选择排序的一种，交换次数比交换排序要少很多,速度比冒泡排序要快
}
}
int[] data = new int[10];
Random r = new Random();
for(int i=0;i<data.length;i++) {
data[i] = r.nextInt(100)-r.nextInt(100);
}
return data;
// printArray(data);
sort4(data);
System.out.println("快速排序后：");
printArray(data);
System.out.println(binarySearch(data,3,0,data.length-1));
while(i<j&&data[j]>=temp) {
j--;
}
if(i<j) {
data[i] = data[j];
}
while(i<j&&data[i]<=temp) {
i++;
}
if(i<j) {
}
//打印数组
public static void printArray(int[] data) {
for(int i : data) {
System.out.print(i+" ");
}
System.out.println();
}
//交换数组的两个元素
public static void swap(int[] data,int x,int y) {
if(x>=0 && y>=0 && x != y) {
int temp = data[x];
data[x] = data[y];
data[y] = temp;
}
return binarySearch(dataset,data,mid+1,end);
} else {
return mid;
}
}
/**
* 测试
*/
public static void main(String[] args) {
int[] data = createArray();
return -1;
}
int start=0,end=len,mid=0;
while(start<=end) {
mid = (start+end) >> 1;
if(dataset[mid]>data) {
end = mid-1;
} else if(dataset[mid]<data) {
for(int i=0;i<len-1;i++) {
index = 0;
for(int j=0;j<len-i;j++) {
if(data[j]>data[index]) {
index = j;
}
}
swap(data,len-i-1,index);
import java.util.Random;
/**
* 所有示例均为正序排序
* @author 张子枭
* @since 2011-7-5
*/
public class Main {
//随机创建用于测试的整型数组
public static int[] createArray() {
for(int i=1;i<len;i++) {
for(int j=0;j<i;j++) {
if(data[j]>data[i]) {
swap(data,i,j);
}
}
}
}
/**
* 交换排序之快速排序，当数据较大时可以使用此排序
private static void qsort(int[] data,int start,int end) {
if(start<end) {
int i = start;
int j = end;
int temp = data[i];
while(i<j) {
* 直接选择排序法,外层循环控制轮数，内层循环中临近两个进行比较做出选择判断交换
* 第n轮结束后后面n个数是有序的
*/
public static void sort2(int[] data) { Βιβλιοθήκη int index = 0;
int len = data.length;
* 每一次递归，都对数据的全部（第一次递归）或一部分按照其第一个数据划分为左右两块，
* 然后分别对左右两块执行递归
*/
public static void sort4(int[] data) {
qsort(data,0,data.length-1);
}
//需要特殊考虑数据全部相同的情况
//data = new int[]{-25,-3,-91,-58,-2,53,32,-53,-29,32};
data = new int[]{1,2,3,4};
printArray(data);
// sort1(data);
// System.out.println("冒泡排序后：");
start = mid+1;
} else {
return mid;
}
}
return -1;
}
/**
* 递归二分查找法查找特定整型数据在数组中的位置
* 要查找的数组必须是有序的,假定为正序
* @return 目标数字在数组中的位置，如果不存在返回-1，如果要查找的数字有多个，返回哪一个的位置不确定