排序和查找算法

一、排序算法

1.快速排序

不稳定，时间复杂度最理想 O(nlogn) 最差时间O(n^2)

package com.test;

public class fasf{
	/**
	 * 快速排序
	 * @param args
	 */
	public static void main(String[]args){
		//不用设置大小
		int [] num={3,6,5,4,7,2,9};
		fasf f=new fasf();
		f.quicksort(num, 0, num.length-1);
		for (int i = 0; i < num.length; i++) {
			System.out.println(num[i]);
		}
		
	}
	public void quicksort(int[] a,int left,int right){
		int i=left;
		int j=right;
		//参照数
		int temp=a[left];
		if(i>=j){
			return;
		}
		while(i<j){
			//从右向左寻找小于temp的数
			while(i<j&&a[j]>=temp){
				j--;
			}
			//若已找到
			if(i<j){
				a[i]=a[j];
				i++;
			}
			//从左向右寻找大于temp的数
			while(i<j&&a[i]<=temp){
				i++;
			}
			//若已找到
			if(i<j){
				a[j]=a[i];
				j--;
			}
		}
		//将参照数赋给已排序好的右边
		a[i]=temp;
		//左边递归
		quicksort(a, left, i-1);
		//右边递归
		quicksort(a, i+1, right);
	}
	
	
}

2.选择排序：不稳定，时间复杂度 O(n^2)

3.插入排序：稳定，时间复杂度 O(n^2)
4。冒泡排序：稳定，时间复杂度 O(n^2)
5。堆排序：不稳定，时间复杂度 O(nlog n)

6.归并排序

1.性能

稳定，时间复杂度 O(nlog n)

2.算法思路

分治法的步骤主要包括以下四步：

1. 分割子问题：将原问题分割成若干个子问题，这些子问题与原问题在结构上相同或相似，通常每个子问题的规模都比较小。
2. 解决子问题：对每个子问题进行递归解决，即对每个子问题重复执行分割和解决的过程，直到子问题的规模足够小可以直接解决。
3. 合并子问题解：将所有子问题的解合并为一个解，这个解就是原问题的解。
4. 返回结果：返回合并后的解。

如下图，显示了详细的计算过程

7。希尔排序：不稳定，时间复杂度平均时间 O(nlogn)

二、查找算法

1.二分查找

算法思想：又叫折半查找，要求待查找的序列有序。每次取中间位置的值与待查关键字比较，如果中间位置的值比待查关键字大，则在前半部分循环这个查找的过程，如果中间位置的值比待查关键字小，则在后半部分循环这个查找的过程。直到查找到了为止，否则序列中没有待查的关键字。