Java中的常用排序算法和查找算法

Java中的常用排序算法和查找算法

冒泡排序算法

存在10个不同大小的气泡，由底至上地把较少的气泡逐步地向上升，这样经过遍历一次后，最小的气泡就会被上升到顶（下标为0），然后再从底至上地这样升，循环直至十个气泡大小有序。
在 冒泡排序中， 最重要的思想是两两比较，将两者较少的升上去
冒泡排序最坏情况的时间复杂度是O(n²)

public class BubbleSort {
	public static void main(String[] args) {
		
		Scanner sc = new Scanner(System.in);//从键盘输入一串数字，使用“，”隔开
		String s = sc.next();
		System.out.println(s);//在控制台输出这段字符串
		String[] str = s.split(",");//调用split方法对字符串进行拆分，并存入数组str中
		int[] arr = Arrays.stream(str).mapToInt(Integer :: parseInt).toArray();//将string类型的数组转换为int类型
		BubbleSort sorter = new BubbleSort();
		sorter.sort(arr);//调用sort方法对数组排序
		
	}
	//冒泡排序算法
	public void sort(int[] arr) {
		for(int i =1;i < arr.length;i++) {
			for(int j = 0;j < arr.length - 1;j++) {
				if(arr[j] > arr[j + 1]) {
					int tmp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = tmp;
				}
			}
		}
		showArray(arr);
	}

	public void showArray(int[] arr) {
		for(int i : arr) {
			System.out.print(i + " ");
		}
	}
}

快速排序算法

基本思想

选择一个基准数，通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小。然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以达到全部数据变成有序。

具体步骤

1.从数列中挑出一个基准值。
2.将所有比基准值小的摆放在基准前面，所有比基准值大的摆在基准的后面(相同的数可以到任一边)，在这个分区退出之后，该基准就处于数列的中间位置。
3.递归地把基准值前面的子数列和基准值后面的子数列进行排序。

public class QuickSort {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);//从键盘输入一串数字，使用“，”隔开
		String s = sc.next();
		String[] str = s.split(",");//调用split方法对字符串进行拆分，并存入数组str中
		int[] arr = Arrays.stream(str).mapToInt(Integer :: parseInt).toArray();//将string类型的数组转换为int类型
		QuickSort sorter = new QuickSort();
		sorter.sort(arr, 0, arr.length - 1);//调用sort方法，对数组进行排序
		System.out.println(Arrays.toString(arr));//在控制台输出排序后的数组
	}
//快速排序算法
	private void sort(int[] arr,int left,int right) {
		int l = left;
		int r = right;
		int pivot = arr[(left + right) / 2];
		int tmp = 0;
		while(l < r) {
			while(arr[l] < pivot)
				l++;
			while(arr[r] > pivot)
				r--;
			if(l >= r)
				break;
			tmp = arr[l];
			arr[l] = arr[r];
			arr[r] = tmp;
			
			if(arr[l] == pivot)
				r--;
			if(arr[r] == pivot)
				l++;
		}
		if(l == r) {
			l++;
			r--;
		}
		if(left < r)
			sort(arr,left,r);
		if(right > l)
			sort(arr,l,right);
	}
	
	
}

二分查找算法

基本思想

又称为 折半查找，二分查找，适合对已经排序好的数据集合进行查找，时间复杂度O（log2n）,效率高。假设有一升序的数据集合，先找出升序集合中最中间的元素，将数据集合划分为两个子集，将最中间的元素和关键字key进行比较，，如果等于key则返回，如果大于关键字key，则在前一个数据集合中查找，否则在后一个子集中查找，直到找到为止，如果没找到则返回-1；
步骤

(1)首先确定整个查找区间的中间位置mid=(low+high)/2;

(2)用待查关键字值与中间位置关键字值进行比较；

若相等，则查找成功；

若大于，则在后半个区域中继续进行折半查找。

若小于，则在前半个区域中继续进行折半查找。

查找成功，返回关键字所在数组下标，没找到返回-1；

public class HelfSearch {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);//从键盘输入一串数字，使用“，”隔开
		String s = sc.next();
		String[] str = s.split(",");//调用split方法对字符串进行拆分，并存入数组str中
		int[] arr = Arrays.stream(str).mapToInt(Integer :: parseInt).toArray();//将string类型的数组转换为int类型
		
		Scanner sc1 = new Scanner(System.in);
		int key = sc1.nextInt();//输入所要查找的数字 并将值赋给key
		
		HelfSearch sorter = new HelfSearch();
		sorter.sort(arr, 0, arr.length - 1);//调用sort算法对数组进行排序
		System.out.println(Arrays.toString(arr));
		
		HelfSearch searcher = new HelfSearch();
		searcher.search(arr,key);//调用search方法 对排序好的数组进行查找
		
	}
	//二分查找算法
	private void search(int[] arr,int key) {
		int left = 0;
		int right = arr.length - 1;
		int middle = 0;
		
		while(left <= right) {
			middle = (left + right) / 2;
			if(arr[middle] > key) {
				right = middle - 1;
			}else if(arr[middle] < key) {
				left = middle + 1;
			}else {
				System.out.println(middle);
				break;
			}
		}
		
	}
	//快速排序算法
	private void sort(int[] arr,int left,int right) {
		int l = left;
		int r = right;
		int pivot = arr[(left + right) / 2];
		int tmp = 0;
		while(l < r) {
			while(arr[l] < pivot)
				l++;
			while(arr[r] > pivot)
				r--;
			if(l >= r)
				break;
			tmp = arr[l];
			arr[l] = arr[r];
			arr[r] = tmp;
			
			if(arr[l] == pivot)
				r--;
			if(arr[r] == pivot)
				l++;
		}
		if(l == r) {
			l++;
			r--;
		}
		if(left < r)
			sort(arr,left,r);
		if(right > l)
			sort(arr,l,right);
	}
	
}