基础算法——排序与查找（复杂度）

1. 数字排序
1.1 算法——冒泡算法

//相邻
public class Suan{
	public static void main(String []args){
		int[] ary={1,2,3,4,5,9,6,7,8};
		//遍历，依次相邻比较大小
		for(int i=0;i<ary.length-1;i++){
			for(int j=0;j<ary.length-i-1;i++){
				if(ary[j]>ary[j+1]){
				int y=ary[j];ary[j]=ary[j+i];ary[j+1]=t;
				}
			}
		}
		//打印排序后的数组内容
		System.out.println("排序后的数组："+Arrays.toString(ary));
	}
}

C:\Users\o2o\aa>javac Suan.java

C:\Users\o2o\aa>java Suan
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8, 9]

1.2 算法——选择排序

//跟第一个比
import java.util.Arrays;
public class Suan{
		public static void mian(String[] args){
			int[] ary = {1,2,3,4,5,9,6,7,8};
			for(int i=0;i<ary.length-1;i++){
				for(int j=i+1;j<ary.length;j++){
					if(ary[i]>ary[j]){
						int t=ary[i];ary[i]=ary[j];ary[j]=t;
					}
				}
			}
			//打印排序后的数组内容
			System.out.println("排序后的数组："+Arrays.toString(ary));
		}
}

C:\Users\o2o\aa>javac Suan.java

C:\Users\o2o\aa>java Suan
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8, 9]

1.3 算法——插入排序

import java.util.Arrays;
public class Suan {
	//前后部分
	public static void main (String[] args){
		int[] ary={1,2,3,4,5,9,6,7,8};
		int i,j,k;
		for(i=1;i<ary.length;i++){
			k=ary[i];//取出待插入元素
			//找到插入位置
			for(j=i-1;j>=0&&k<ary[j];j--){
			ary[j+1]=ary[j];//移动元素
			}
			//插入元素
			ary[j+1]=k;
		}
		//打印排序后的数组内容
		System.out.println("排序后的数组："+Arrays.toString(ary));
		
	}
}

C:\Users\o2o\aa>javac Suan.java

C:\Users\o2o\aa>java Suan
排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8, 9]

1.4 算法——快速排序

import java.util.Arrays;
public class Suan {
	//基准值递归调用
	public static void main(String[] args){
		int vec[]={77,88,66,100,10,55,55,99,9};
		Suan q = new Suan();
		q.quicksort(vec,0,vec.length-1);
		System.out.println("排序后的数组："+Arrays.toString(vec));
	}
	public void quicksort(int a[],int low,int high){//假设传入low=0;high=a.l;
		
		if(low<high){
			int pivot,p_pos,i;//申明变量
			p_pos = low;//p_pos指向low，即位索引为0位置
			pivot = a[p_pos];//将0位置上的数值赋给pivot
			for(i=low+1;i<=high;i++){//循环次数，i=1
				if(a[i]>pivot){
				//1位置的数与0位置数作比较：a[1]>a[0]
					p_pos++;//2位与1位比较，3位与2位比较
					int tmp = a[p_pos];
					a[p_pos] = a[i];
					a[i] = tmp;					
				}				
			}
			int tmp = a[low];
			a[low] = a[p_pos];
			a[p_pos] = tmp;
			quicksort(a,low,p_pos-1);//递归调用，排序左半区
			quicksort(a,p_pos+1,high);//递归调用，排序右半区
		}
	}
}

C:\Users\o2o\aa>javac Suan.java

C:\Users\o2o\aa>java Suan
排序后的数组：[100, 99, 88, 77, 66, 55, 55, 10, 9]

1.5 算法——希尔排序

import java.util.Arrays;
public class Suan {
     public static void main(String args[]){
         int []ary ={1,4,2,7,9,8,3,6};
         shellSort(ary);
         System.out.println("排序后的数组："+Arrays.toString(ary));
         int []ary1 ={10,3,4,7,9,80,3,60};
         shellSort(ary1);
         System.out.println("排序后的数组："+Arrays.toString(ary1));
     }
    //函数功能，希尔排序算法对数字递增排序
    //函数参数，数列起点，数列终点
     public static void shellSort(int ary[]){
		int index = ary.length/2;
		int temp=0;
		while(index>=1){
			for(int i=index;i<ary.length;i++){
				for(int j=i-index;j>=0;j-=index){
					if(ary[j]>ary[j+index]){
						temp = ary[j];
						ary[j] = ary[j+index];
						ary[j+index]=temp;
					}
				}
			}			
			index = index/2;
		}
	}
}

 排序后的数组：

C:\Users\o2o\aa>java Suan
排序后的数组：[1, 2, 3, 4, 6, 7, 8, 9]
排序后的数组：[3, 3, 4, 7, 9, 10, 60, 80]

2. 查找

2.1 算法——顺序查找

//跟第一个比
import java.util.Arrays;
public class OrderFind{
	public static void main(String[] args){
		//定义一段数组
		int[] ary = {1,2,3,4,5,6,9,7,8};
		//定义要查找的数据
		int find = 5;
		//定义标识（示）符，即找到的位置
		int count=-1;
		for(int i=0;i<ary.length;i++){
			if(find == ary[i]){
				count = i;
			}
		}
		if(count != 1){
			System.out.println("下标在："+count+"的位置");
		}else{
			System,out.println("对不起，没有找到！");
		}
	}
}

下标在：3的位置 

2.2 算法——二分查找

//mid=(low+high)/2
import java.util.Arrays;
public class BinarySearchDemo{
	public static void main(String[] args){
		//定义一堆数据
		int[] a={1,2,3,4,5,6,9,7,8};
		//定义要查找的数据
		int value = 5;
		//定义标识（示）符，即找到的位置
		int count = -1;
		int low = 0;
		int high = a.length-1;
		while(low<=high){
			int mid = (low+high)/2;
			if(a[mid] == value){
				count = mid;
				break;
			}else if(a[mid]>value){
			high = mid-1;
			
			}else{
			low = mid+1;
			
			}
		}if(count != -1){
			System,out.println("下标在："+count+"位置");
		}else{
			System.out.println("没有找到！");
		}
	}	
}

下标在：3的位置 

3. 复杂度

（1）

名称	稳定性	初始状态	复杂度	理想情况	最差情况	基本思想	内存
简单选择	否		O(n2)			依次选择最小的数
冒泡排序 （flag=1）	是		O(n2)	大体符合排序要求	与排序要求完全相反	从后往前多次扫描
直接插入	是		O(n2)	初始有序	初始倒序	依次取出插入
堆排序	否		O(nlog2n)	带排序的数据较多			最少
快速排序	否		O(nlog2n)		n很小时	从两头向中间扫描
希尔（Shell）排序	否		n1.3
二路归并	是		O(nlog2n)				最多
基数排序	是		O(d(n+rd))				较多

（2） 

选堆快希----不稳定 

选堆归基----无关