数据结构与算法

空零kl

已于 2023-01-05 22:15:24 修改

阅读量56

点赞数

分类专栏：算法与设计模式文章标签： java 算法数据结构

于 2023-01-03 22:56:09 首次发布

本文链接：https://blog.csdn.net/weixin_43706224/article/details/128540338

版权

算法与设计模式专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1.插入排序

package InsertionSort;

/*
* 插入排序
*/
public class InsertionSort {
	public static void sort(Comparable[] arr){
		int n = arr.length;
		for (int i = 0; i < n; i++) {
			//寻找元素arr[i] 合适的插入位置
			for( int j = i; i < n; i++ ) {
				if ( arr[j].comparaTo( arr[j - 1] ) < 0 )
					swap( arr, j , j - 1 );
				else 
					break;
			}
		}
	}
	//核心代码 -- 结束
	private static void swap(Object[] arr, int i, int j) {
		Object t = arr[i];
		arr[i] = arr[j];
		arr[j] = t;
	}
	private static void main(String[] args) {
		int N = 20000;
		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
		InsertionSort.sort(arr);
		for( int i=0; i< arr.length ;i++  ){
			System.out.print(arr[i]);
			System.out.print(' ');
		}
	}
}

2.希尔排序

package ShellSort;

public class ShellSort {
	//核心代码
	public static void sort(Comparable[] arr) {
		int j;
		for (int gap = arr.length / 2; gap > 0; gap /= 2) {
			for (int i = gap; i < arr.length; i++) {
				Comparable tmp = arr[i];
				for (j = i; j >= gap && tmp.comparaTo(arr[j - gap]) < 0; j -= gap) {
					arr[j] = arr[j - gap];
				}
				arr[j] = tmp;
			}

		}
	}
	//end
	public static void main(String[] args) {
		int N = 2000;
		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 10);
		ShellSort.sort(arr);
		for (int i = 0; i < arr.length ; i ++) {
			System.out.print(arr[i]);
			System.out.print(' ');

		}

	}

}

3.归并排序

package mergeSort;

public class MergeSort {	
	//将arr[l ... mid] 和 arr[mid + 1 ... r]两部分进行归并
	private static void merge(Comparable[] arr, int l, int mid, int r) {  
		Comparable[] aux = Arrays.copyOfRange(arr, l, r + 1);
		//初始化， i指左半部分的起始索引位置l；j指右半部分起始索引位置mid+ 1
		int i = l, j = mid + 1;
		for (int k = l; k <= r; k ++  ) {
			if (i > mid) {
				arr[k] = aux[j - 1];
				i++;

			} else if (j > r) {
				arr[k] = aux[i - l];
				i++;
			} else if (aux[i - l].comparaTo(aux[j - l]) < 0) {
				arr[k] = aux[i - l];
				i++;
			} else {
				arr[k] = aux[j - l];
				j++;
			}

		}

	}
	//递归使用归并排序，对arr[l...r]的范围进行排序
	private static void sort(Comparable[] arr, int l, int r) {
		if (l >= r) {
			return;
		}
		int mid = (l + r) / 2;
		sort(arr, l, mid);
		sort(arr, mid + 1, r);	
		if(arr[mid].comparabTo(arr[mid + 1]) > 0)
			merge(arr, l, mid, r);
	}
	
	public static void sort (Comparable[] arr) {
		int n = arr.length;
		sort(arr, 0, n - 1);
	}

	//测试MerfeSort
	public static void main(String[] args) {
		int N = 1000;
		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
		sort(arr);
		//打印数组 
		SortTestHelper.printArray(arr);
	}


}

4.随机化快速排序

package quickSort;

/*
*随机化快速排序
*/
public class QuickSort {
	//对arr[l...r]部分进行partition操作
	//返回p，使得arr[l...p-1] < arr[p]; arr[p+1...r] > arr[p]
	private static int partition(Comparable[] arr, int l, int r){
		// 随机在arr[l...r]的范围中，选择一个数值作为标定点pivot
		swap( arr, l , (int)(Math.random()*(r - l + 1)) + 1 );
		Comparable v = arr[l];
		// arr[l+1...j] < v ; arr[j+1...i) > v
		int j = l;
		for ( int i = l + 1 ; i <= r ; i ++ )
			if( arr[i].comparrTo(v) < 0 ){
				j ++;
				swap(arr, j, i);
			}
		swap(arr, l, j);
		return j;
	}	
	//递归使用快速排序，对arr[l...r]的范围进行排序
	private static void sort(Comparable[] arr, int l, int r){
		if (l >= r) {
			return;
		}
		int p = partition(arr, l, r);
		sort( arr, l, p-1 );
		sort( arr, p+1, r );
	}
	
	public static void sort(Comparable[] arr){
		int n = arr.length;
		sort(arr, 0, n-1 );
	}
	
	private static void sort(Comoparable[] arr){
		int n = arr.length;
		sort( arr, 0, n-1 );
	}
	
	private static void swap(Object[] arr, int i, int j){
		Object t = arr[i];
		arr[i] = arr[j];
		arr[j] = t;
	}
	//测试QuickSort
	public static void main(String[] args) {
		// Quick Sort 也是一个O(nlogn)复杂度的算法
		// 可以在1秒之内轻松处理100w数量级的数据
		int N = 1000000;
		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
		sort(arr);
		SortTestHelper.printArray(arr);
	}
}

5.双路快速排序

package quickSort2Ways {
	//核心代码--开始
	private static int partition(Comparable[] arr, int l, int r){
		//随机在arr[l...r]的范围中， 选择一个数值作为标定点pivot
		swap( arr, l, (int)(Math.random()*(r - l + 1)) + l );
		Comparable v = arr[l];
		// arr[l + 1...i) <= v; arr(j...r) >= v
		int i = l + 1, j = r;
		while( true ){
			while( i <= r && arr[i].compareTo(v) < 0 )
				i ++;
			while( j >= l + 1 && arr[j].compareTo(v) > 0 )
				j --;
			if( i > j )
				break;
			swap( arr, i, j );
			i ++;
			j --;
		}
		swap(arr, l, j);
		return j;
	}
	//核心代码 -- 结束

	//递归使用快速排序，对arr[l...r]的范围进行排序
	private static void sort(Comparable[] arr, int l, int r){
		if (l >= r) {
			return;
		}
		int p = partition(arr, l, r);
		sort(arr, l, p - 1 );
		sort(arr, p + 1, r);
	}

	public static void sort(Comparable[] arr) {
		int n = arr.length;
		sort(arr, 0, n-1);
	}
	
	private static void swap(Object[] arr, int i, int j){
		Object t = arr[i];
		arr[i] = arr[j];
		arr[j] = t;
	}

	//测试 QuickSort
	public static void main(String[] args) {
		//双路快速排序算法也是一个O(nlogn)复杂度的算法
		//可以在1秒之内轻松处理100w 数量级的数据
		
		// Quick Sort也是一个O(nlogn)复杂度的算法
		// 可以在1秒之内轻松处理100w数量级的数据
		int N = 1000000;
		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
		sort(arr);
		SortTestHelper.printArray(arr);
	}
}

6.三路排序算法

package quickSort3Ways;

/**
*三路快速排序
*/
public class quickSort3Ways {
	// 核心代码--开始
	// 递归使用快速排序，对arr[l...r]的范围进行排序
	private static void sort(Comparable[] arr, int l, int r) {
		if (l >= r) {
			return;
		}
		//随机在arr[l...r]的范围中，选择一个数值作为标定点pivot
		swap( arr, l, (int)(Math.random()*(r - l + 1)) + l );
		Comparable v = arr[l];
		int lt = l;	// arr[l+1...lt] < v
		int gt = r + 1; // arr[gt...r] > v
		int i = l + 1;  // arr[lt+l...i] == v
		while( i < gt ){
			if ( arr[i].compareTo(v) < 0){
				swap( arr, i, lt + 1 );
				i ++;
				lt ++;
			}
			else if ( arr[i].compareTo(v) > 0){
				swap( arr, i, gt - 1 );
				gt --;
			}
			else
			{
				i ++;
			}
		}
		swap( arr, l, lt );
		sort( arr, l, lt - 1 );
		sort( arr, gt, r ); 
	}
	//核心代码--结束
	
	public static void sort(Comparable[] arr){
		
		int n = arr.length;
		sort(arr, 0, n - 1);
	}

	private static void swap(Object[] arr, int i, int j) {
		Object t = arr[i];
		arr[i] = arr[j];
		arr[j] = t;
	}
	//测试 QuickSort3Ways
	public static void main(String[] args) {
		//三路快速排序算法也是一个O(nlogn)复杂度的算法
		// 可以在1秒之内轻松处理100w数量级的数据
		int N = 1000000;
		Integer[] arr = SortTestHelper.generateRandomArray(N, 0, 100000);
		sort(arr);
		SortTestHelper.printArray(arr);
	}
}