Shell、归并排序、递归的java实现

Shell、归并排序、递归的java实现

 

        摘要：上篇笔记记述了四个排序：插入排序、快速排序、冒泡排序、选择排序、本篇主要记录两个：shell排序——对插入排序的改进、归并排序。同样是从思想、算法实现和java代码的实现来研究、顺道补充了点递归的东西。

一：Shell排序

        1、基本思想：

 

              Shell排序（希尔排序）是对插入排序的一种改进、也称“缩小增量排序”。他是按照一个选取的缩小增量值n将要排序的数组中元素下标相差n和n的倍数的所有元素分成n组、分别对n组元素进行插入排序、完成后按上述规则再细分n1组、n1<n、再排序、直到nx = 1、直接对这一组进行插入排序、实现Shell排序、从上边的步骤也可以看出Shell排序是对插入排序的一种改进。

       

         2、算法原理：

              a） 取数组长度的一半step=a.length/2 作为缩小增量、

              b） 将数组分成 step组、

              c）分别对每组进行插入排序。

              d） 将step组中每组再以缩小增量step = step/2分组、重复步骤c。

              e） 重复步骤c、d直到step=1、对这一组元素进行插入排序。over！

        3、java实现：

 

package com.chy.arithmetic;

import java.util.Arrays;

public class ShellSort {
	private static int ia[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 3 };

	private static int[] shellSort(int[] a) {
		//the increment;
		int step = a.length / 2;
		
		// The result has mostly sorted at the previous step of step=1;
		//Just change the condition step> = 1 to step > 1 if you want to observe it ;
		while (step >= 1) {
			
			for (int i = step; i < a.length; i++) {
				int temp = a[i];
				int j;
				
				// use insert sort to sort the part of a;
				for (j = i - step; j >= 0 && a[j] > temp; j -= step) {
					a[j + step] = a[j];
				}
				a[j + step] = temp;
			}
			//narrow the increment.
			step = step / 2;
		}
		return a;
	}


	public static void main(String[] args) {
		System.out.println(Arrays.toString(shellSort(ia)));
	}
}

 

二：归并排序

 

        1、基本思想：

 

                归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个有序的子序列（一般分解到原子级），再把有序的子序列合并为整体有序序列。

 

       2、算法原理：

 

            分解操作：

 

                a）  申请两个空间、分别存放原来序列的一半（不是严格意义上的一半、如果元素个数是奇数、则有一方会多一个元素）。

                b）  使用中间变量 center= a.length/2划分序列

                c）  分别填充第一步申请的两个空间

                d）  递归的形式细分填充上一步划分的两个空间、直到所有空间只放一个元素。

                e）  进行归并操作

                f）  重复上述步骤、直到所有空间合并成一个有序序列。

 

              归并操作：

 

                a）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列

                b）设定两个指针，最初位置分别为两个已经排序序列的起始位置

                c）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指

                d）针到下一位置

                e）重复步骤3直到某一指针达到序列尾

                f）将另一序列剩下的所有元素直接复制到合并序列尾

 

3、java实现：

 

package com.chy.arithmetic;

import java.util.Arrays;

public class MergeSort {

	public static void main(String[] args) {
		int[] array = { 3, 2, 1, 8, 5, 7, 9, 4, 6 };
		System.out.println(Arrays.toString(mergeSort(array)));
	}

	private static int[] mergeSort(int[] a) {
		if (a.length == 1) {
			return a;
		}

		int[] aL = new int[a.length / 2];
		int[] aR = new int[a.length - a.length / 2];
		int center = a.length / 2;
		for (int i = 0; i < center; i++) {
			aL[i] = a[i];
		}
		for (int i = center, j = 0; i < a.length; i++, j++) {
			aR[j] = a[i];
		}
		int[] sortedAL = mergeSort(aL);
		int[] sortedAR = mergeSort(aR);
		int[] as = mergeTwoArray(sortedAL, sortedAR);
		return as;
	}

	private static int[] mergeTwoArray(int[] aL, int[] aR) {
		int i = 0;
		int j = 0;
		int[] a = new int[aL.length + aR.length];
		int foot = 0;
		while (i < aL.length && j < aR.length) {
			if (aL[i] < aR[j]) {
				a[foot++] = aL[i++];
			} else {
				a[foot++] = aR[j++];
			}
		}

		if (i == aL.length) {
			while (j < aR.length) {
				a[foot++] = aR[j++];
			}
		} else {
			while (i < aL.length) {
				a[foot++] = aL[i++];
			}
		}
		return a;
	}
}

三：递归

 

      1、基本思想：

              递归在开发中是非常常见的一种算法、比如罗列某个指定文件夹下所有的文件名、因为有可能有层层文件、所以我们可以使用递归来实现。

思想：对于一个复杂的问题，把原问题分解为若干个相对简单类同的子问题，继续下去直到子问题简单到能够直接求解，也就是说到了递推的出口，这样原问题就有递推得解。 

              最能说明递归思想的是：Febonacci数列——看代码。

              递归最重要的是1、范围要越来越小。2、是要找到出口、也就是结束条件。

 

      2、java实现：

package com.chy.arithmetic;

import java.io.File;

public class RecursiveAlgorithm {
	
	public static void main(String[] args) {
		System.out.println(getFibonacciValue(10));
		getAllFiles("D:\\upload");
	}

	/**
	 * to obtain the specified index of a Fibonacci's value
	 */
	private static long getFibonacciValue(int index) {
		if (index == 1 || index == 2) {
			return 1;
		} else {
			return getFibonacciValue(index - 1) + getFibonacciValue(index - 2);
		}

	}
	
	/**
	 * to obtain all files in a specified directory
	 */
	private static void getAllFiles(String filePath){
		File file = new File(filePath);
		if(!file.isDirectory()){
			System.out.println(file.getAbsolutePath());
		}else{
			File[] fileList = file.listFiles();
			for(File fileDetail : fileList){
				if(!fileDetail.isDirectory()){
					System.out.println(fileDetail.getAbsolutePath());
				}else{
					getAllFiles(fileDetail.getAbsolutePath());
				}
			}
		}
	}
}