插入排序和迭代归并排序以及复杂度分析

最新推荐文章于 2024-03-02 18:04:09 发布

bladestone

最新推荐文章于 2024-03-02 18:04:09 发布

阅读量2.9k

点赞数

分类专栏： Java技术文章标签：算法分析复杂度

本文链接：https://blog.csdn.net/blueheart20/article/details/52574284

版权

Java技术专栏收录该内容

139 篇文章 4 订阅

订阅专栏

引言：算法是计算机科学中的基础，程序=算法+数据结构，算法描述了我们将如何来处理数据的过程。本文将介绍两种算法的实现以及其中一种算法的复杂度分析过程。

1. 算法介绍

归并排序是利用归并思想对数列进行排序，核心点是将数组进行分组拆分，拆分到最小单元之时，即为有序；然后进行分组数据的归并排序合并，从而达到排序的目的。

插入排序是将元素插入到某个有序数组之中，并保持原有数据的有序性，以此类推来解决数据排序的问题。

2. 算法实现

插入排序是在这里的实现是从有序数组的最后一个元素来进行比较和插入，当然这里也可以从第一个元素来进行比较和插入操作。

归并元素是基于2分法来进行分拆、排序归并的。

代码如下：

import java.util.Arrays;

public class SortWays {

	/**
	 * direction:  
	 * 
	 * @param data
	 * @param direction 0: ascendent, 1: descendent
	 * @return
	 */
	public static int[] insertSort(int[] data, int direction) {
		if (data == null || data.length == 0) return new int[]{};
		
		for (int j=1; j<data.length; j++) {
			int key = data[j];
			int i = j -1;
			
			while ((i>=0)) {
				if ((data[i] > key) && (direction == 0)) {
					   data[i+1] = data[i];
				     i--;  //auto decrease
				}
				else if ((data[i]<key) &&(direction == 1)) {
					data[i+1] = data[i];
					i--;  //auto decrease
				}
				else {
					break;
				}
			}
			data[i+1] = key;
		}
		
		return data;
	}
	
	public static void mergeSort(int[] data, int startIndex, int endIndex) {
		if (startIndex < endIndex) {
			int splitIndex = (int)Math.floor((startIndex+endIndex)/2);
			mergeSort(data, startIndex, splitIndex);
			mergeSort(data, splitIndex+1, endIndex);
			
			merge(data, startIndex, splitIndex, endIndex);
		}
	}
	
	/**
	 * merge method body.
	 * 
	 * @param data
	 * @param startIndex
	 * @param splitIndex
	 * @param endIndex
	 */
	private static void merge(int[] data, int startIndex, int splitIndex, int endIndex) {
		int[] tmp = new int[endIndex - startIndex+1]; //临时区域
		
		int i = startIndex; // first area index
		int j = splitIndex +1; //second area index
		int k = 0;    // temporary area index
		
		while (i<= splitIndex && j <= endIndex) {
			//System.out.println("splitIndex/i/endIndx/j:" + splitIndex + "/" + i + "/" + endIndex + "/" + j);
			
			if (data[i] > data[j]) 
				tmp[k++] = data[j++];
			else 
				tmp[k++] = data[i++];
		}
		
		while (i<=splitIndex) {
			tmp[k++] = data[i++];
		}
		
		while(j<=endIndex) {
			tmp[k++] = data[j++];
		}
		
		for (int c=0; c<k; c++) 
			data[startIndex+c] = tmp[c];
		
		tmp = null;
	}
	
	public static void main(String[] args) {
		int[] rawdata = new int[]{7,2, 3,  5, 1, 8, 4, 6};
		
		//int[] data = SortWays.insertSort(rawdata, 0);
		
		SortWays.mergeSort(rawdata, 0, rawdata.length-1);
		System.out.println("Array Data:" + Arrays.toString(rawdata));
	}

}

在插入排序中， direction方向表示： 0为顺序排序，1：降序排序。

在归并排序中，注意mergeSort的输入参数中最后一个参数为最后一个元素的位置，而非数组长度；比如这里实际的位置为7，而非长度8.

3. 迭代归并排序的复杂度分析

关于插入排序的复杂度分析，我们基于其伪代码实现来进行分析：