java排序

插入排序

public void test3() {
int i,j,temp;
for(i=1;i<array.length;i++) {
temp=array[i];
for(j=i-1;j>=0;j--) {
if(temp>array[j]) {
break;
}else {
array[j+1]=array[j];
}
}
array[j+1]=temp;
}
System.out.println(Arrays.toString(array));
}

快速排序O(n)

public static int[] qsort(int arr[],int start,int end) {
int pivot = arr[start];
int i = start;
int j = end;
while (i<j) {
while ((i<j)&&(arr[j]>pivot)) {
j--;
}
while ((i<j)&&(arr[i]<pivot)) {
i++;
}
if ((arr[i]==arr[j])&&(i<j)) {
i++;
} else {
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
if (i-1>start) arr=qsort(arr,start,i-1);
if (j+1<end) arr=qsort(arr,j+1,end);
return (arr);
}

public static void main(String[] args) {
int arr[] = new int[]{3,3,3,7,9,122344,4656,34,34,4656,5,6,7,8,9,343,57765,23,12321};
int len = arr.length-1;
arr=qsort(arr,0,len);
for (int i:arr) {
System.out.print(i+"\t");
}
}

选择排序
时间复杂度O(n^2)
1. 整个数列分成两部分:前面是有序数列,后面是无序数列
2. 初始状态下,整个数列就是无序的,有序数列是空
3. 一共n个数,需n-1趟循环(一趟都不能少)
4. 每比较完一趟,有序数列数量加1,无序数列减1
5. 每趟先假设无序数列的第一个元素是最小的,让当前的最小数,从第i+1个元素开始比较,一直比较到 最后一个元素,如果发
现更小的数,就假设当前数是最小数
6. 一趟比较完后,如果最小数不是无序数列的第一个数,将最小数和无序数列第一个数交换

public static void selectSort(int[] scoreArr) {
//大循环：n个元素排序，则需要n-1趟循环
for(int i=0;i<scoreArr.length-1;i++){
//第i趟先假设第i个最小
int minIndex = i;
//从第i+1个元素开始，依次使用最小的元素和每个元素比较，一直比较到最后
for (int j = i+1; j <scoreArr.length ; j++) {
if(scoreArr[minIndex] > scoreArr[j]){
minIndex = j;
}
}
//一趟比较完后，或者最小值的索引，如果不是第i个，就交换
if(minIndex !=i){
int temp;
temp = scoreArr[i];
scoreArr[i] = scoreArr[minIndex];
scoreArr[minIndex] = temp;
}
}
}

冒泡排序O(n^2)

public class TestBubbleSort2{
public static void main(String [] args){
//定义一个无序数组
int [] scoreArr = {1,2,3,4,5,6,7};
//排序
//大循环：n个元素排序，则至多需要n-1趟循环
int temp;
int i;
for(i=0;i<scoreArr.length-1;i++){
//1. 假设有序
boolean flag = true;
//2.小循环：每一趟循环都从数列的前两个元素开始进行比较，比较到数组的最后
for(int j=0;j<scoreArr.length-1-i;j++){
//如果前一个大于后一个
if(scoreArr[j] > scoreArr[j+1]){
//交换
temp = scoreArr[j];
scoreArr[j] = scoreArr[j+1];
scoreArr[j+1] = temp;
//发生了交换，数组无序
flag = false;
}
}
//3.判断是否有序，有序，退出
if(flag){
break;
}
}
//排序后输出
System.out.println("排序后");
for(int score :scoreArr){
System.out.print(score+"\t");
}
System.out.println("\n一共进行了"+(i+1)+"趟循环");
}
}

折半查找（递归和非递归）

1.折半查找又称为二分查找，折半查找的前提条件
查找表必须使用顺序存储结构（数组）
查找表必须按关键字大小有序排列
2.非递归方式(循环)
1. 准备一个有序数组array，进行非递归的折半查找
2. 定义low=0指向第一个元素，定义hight=array.length-1指向最后一个元素
3. 进行循环的判断，条件是low<=hight,
4. 计算中间位置的索引mid=(low+hight)/2,根据中间位置的元素是否等于要查询的元素，修改low或者high的值，
if(array[mid]==key)就查找到了位置，返回mid，如果array[mid]>key,中间数大于要查找的数，取数组的前半部分，
high=mid-1,否则取数组的后半部分low=mid+1。

public class TestBinarySearch1 {
public static void main(String[] args) {
//准备一个有序数组
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//进行非递归的折半查找
int index = binarySearch(array,8);
//输出所在位置
System.out.println(index);
}
public static int binarySearch(int[] array, int key) {
//定义low
int low = 0;
//定义high
int high = array.length-1;
//进行循环的判断，条件是low<high
while(low <= high){ //!!!!
//计算中间位置的索引
int mid = (low+high)/2;
//根据中间位置的元素是否等于要查询的元素修改low或者high
if(array[mid] == key ){
return mid;
}else if(array[mid] > key){
high = mid -1;
}else{
low = mid +1;
}
}
return -1;
}
}
3.非递归

1.准备一个有序数组，进行递归的折半查找
2.如果low大于high没有找到，就返回-1退出
3.如果中间元素等于要查找的元素，array[mid]=key，就返回mid，mid为查找元素的位置，
4.如果array[mid]>key,返回调用自己的方法并且将high=mid-1,否则返回调用自己的方法，low=mid+1；

public class TestBinarySearch2 {
public static void main(String[] args) {
//准备一个有序数组
int[] array = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
//进行递归的折半查找
int index = binarySearch(array,4);
//输出所在位置
System.out.println(index);
}
public static int binarySearch(int[] array, int key) {
int low = 0;
int high = array.length -1;
return binarySearch(array,key,low,high);

}
public static int binarySearch(int[] array, int key, int low, int high) {
//找不到就退出
if(low > high){
return -1;
}
//获取mid
int mid = (low +high)/2 ;
//根据mid进行下步操作
if(array[mid] ==key){
return mid;
}else if(array[mid] > key){
return binarySearch(array, key, low, mid-1);
}else{
return binarySearch(array, key, mid+1, high);
}
}