《Java数据结构和算法第二版》学习笔记，算是吧

自己写的工具类，没办法，谁让咱是个懒人呢不过也算是为了练练静态导入吧

 

 

package com.tcgbp.tools;

import java.lang.reflect.Method;
import java.util.Random;


public class ToolMethods {
	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	public static <E> void println(E e) {
		System.out.println(e);
	}

	public static <E> void print(E e) {
		System.out.print(e);
	}
	
	public static <E> void printn(E e,int n){
		for(int i=0;i<n;i++)
			System.out.print(e);
	}

	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	/*
	 * 打印一维int数组，
	 */
	public static void printArray(int[] a) {
		for (int i : a)
			print(i + "\t");
		println("");
	}

	/*
	 * 打印输出二维int数组
	 */
	public static void print2DArray(int[][] da) {
		for (int[] a : da){
			printArray(a);
		}	
	}

	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	/*
	 * 插入排序,T不能为原生态类型
	 */
	public static <T extends Comparable<T>> void insertSort(T[] a) {
		int in, out;
		for (out = 1; out < a.length; out++) {
			T temp = a[out];
			in = out;
			while (in > 0 && a[in - 1].compareTo(temp) >= 0) {
				a[in] = a[in - 1];
				--in;
			}
			a[in] = temp;
		}
	}

	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	
	/*
	 * 生成数组并随机初始化之
	 */
	public static int[] randomArray(int n) {
		Random r = new Random();
		int[] a = new int[n];
		for (int i = 0; i < a.length; i++)
			a[i] = r.nextInt(101);
		return a;
	}

	/*
	 * 生成二维数组并随机初始化之
	 */
	public static int[][] random2DArray(int m, int n) {
		int[][] a = new int[m][n];
		for (int i = 0; i < m; i++) {
			a[i] = randomArray(n);
		}
		return a;
	}
	/*
	 * 二维数组转一维
	 */
	public static int[] to1DArray(int[][] a){
		int[] n = new int[a.length * a[0].length];
		for(int i=0;i<a.length;i++){
			for(int j=0;j<a[0].length;j++){
				n[i * a[0].length +j] = a[i][j];
			}
		}
		return n;
	}
	
	/*
	 * 一维数组转二维
	 * m 行数
	 * n 列数
	 */
	public static int[][] to2DArray(int[] a,int n){
		int m = (a.length % n == 0)?(a.length / n) : (a.length / n + 1);
		int[][] b = new int[m][n];
		for(int i=0;i<m;i++){
			for(int j=0;j<n;j++){
				if(i*n+j < a.length){
					b[i][j] = a[i*n+j];
				}
			}
		}
		return b;
	}
	
	/*
	 * 使用另一个二维数组为二维数组赋值
	 * 要求两个数组有同样的维度
	 */
	public static void apply2DArray(int[][] t, int[][] f){
		for(int i=0;i<f.length;i++){
			for(int j=0;j<f[0].length;j++){
				t[i][j] = f[i][j];
			}
		}
	}
	
	/*
	 * 使用另一个数组为数组赋值
	 */
	public static int[] applyArray(int[] t, int[] f, int...se) {
		int[] mr = new int[2];
		int j = 0;
		for(int r:se){
			mr[j] = r;
			j++;
		}
		if(mr[1]==0)
			mr[1] = Math.min(f.length-mr[0], t.length);   //mr[1]为将复制元素的个数
		int start = (se == null) ? 1 : mr[0];
		int end = (se == null) ? f.length : mr[1] + start;
		for (int i = 0; start < end; start++) {
			t[i] = f[start];
			i++;
		}
		return t;
	}
	

	////////////////////////////////////////////////////////////////////////////
	////////////////////////////////////////////////////////////////////////////
	public static void swap(int[] array, int index1, int index2) {   
	    int temp = array[index1];   
	    array[index1] = array[index2];   
	    array[index2] = temp;   
	} 
}

 

 

 

 

简单排序算法，其中insertNoDupsSort较复杂吧算是，是凌晨2点躺在床上了才想出来的

package com.tcgbp.Sort;

import static com.tcgbp.tools.ToolMethods.*;

import java.util.Arrays;
import java.util.Random;

public class ArraySort {
	public static void main(String[] args) {
		int arrayNum = 10;
		 println("冒泡排序");
		 int[] a = randomArray(arrayNum);
		 printArray(a);
		 println("");
		 bilateralBubbleSort(a);
		 printArray(a);
		// println("转成二维数组");
		// int[][] a2 = to2DArray(a,4);
		// print2DArray(a2);
		// println("");
		//
		 println("选择排序");
		 int[] b = randomArray(arrayNum);
		 printArray(b);
		 println("");
		 selectSort(b);
		 printArray(b);
		 println("");

//		println("插入排序");
//		int[] c = randomArray(arrayNum);
//		printArray(c);
//		println("");
//		// insertSort(c);
//		println(Arrays.toString(c));
//		println(Arrays.toString(insertNoDupsSort(c)));
//		println("");

		// println("二维数组");
		// int[][] d = random2DArray(3,4);
		// print2DArray(d);
		// println("用newBubble2DArray()排序");
		// print2DArray(newBubble2DArray(d));//it works
		// println("用bubble2DArray()排序");
		// bubble2DArray(d);
		// print2DArray(d);
		// to1DArray(d);
		// println("");
		// printArray(to1DArray(d));
	}


	/*
	 * 插入排序
	 */
	public static void insertSort(int[] a) {
		int in, out;
		for (out = 1; out < a.length; out++) {
			int temp = a[out];
			in = out;
			while (in > 0 && a[in - 1] >= temp) {
				a[in] = a[in - 1];
				--in;
			}
			a[in] = temp;
		}
	}

	/*
	 * 插入排序,并除去重复项
	 */
	static int[] insertNoDupsSort(int[] a) {
		int in, out,rn= -1;
		for (out = 1; out < a.length; out++) {
			int temp = a[out];
			int p = 0;
			for (in = out; in > 0; in--) {

				if (a[in - 1] == -1) {
					break;
				} else if (a[in - 1] == temp) {
					a[in - 1] = -1;
					rn++;
					for (int i = in - 1; i > rn; i--) {
						a[i] = a[i - 1];
					}
					a[rn] = -1;
					break;
				} else if (a[in - 1] > temp) {
					a[in] = a[in - 1];
					++p;
				}
			}
			if (p > 0)
				a[out - p] = temp;
		}
		int[] b = new int[a.length - rn -1];
		return applyArray(b,a,rn+1);
	}
	/*
	 * 选择排序
	 */
	public static void selectSort(int[] a) {
		int out, in, min;
		for (out = 0; out < a.length - 1; out++) { // outer loop (forward)
			min = out;
			for (in = out + 1; in < a.length; in++) { // inner loop (forward)
				if (a[in] < a[min]) {
					min = in;
				}
			}
			swap(a,min,out);
		}
	}

	public static int[] newSelectSortArray(int[] a) {
		int out, in, min;
		int[] b = a;
		for (out = 0; out < a.length - 1; out++) { // outer loop (forward)
			min = out;
			for (in = out + 1; in < a.length; in++) { // inner loop (forward)
				if (b[in] < b[min]) {
					min = in;
				}
			}
			swap(a,min,out);
		}
		return b;
	}

	/*
	 * 冒泡排序
	 */
	public static void bubbleSort(int[] a) {
		int out, in;
		// outer loop (backward)
		for (out = a.length - 1; out > 0; out--)
			// inner loop (forward)
			for (in = 0; in < out; in++)
				if (a[in] > a[in + 1]) {
					swap(a,in,in+1);
				}
	}

	public static int[] newBubbleSortArray(int[] a) {
		int out, in;
		int[] b = a;
		// outer loop (backward)
		for (out = a.length - 1; out > 0; out--)
			// inner loop (forward)
			for (in = 0; in < out; in++)
				if (b[in] > b[in + 1]) {
					swap(b,in,in+1);
				}
		return b;
	}
	
	/*
	 * 双向冒泡排序
	 */
	public static void  bilateralBubbleSort(int[] a){
		int out, in, f=0;
		for(out = a.length - 1;out>0 && f<out;out--){
			for(in=f;in<out;in++){
				if (a[in] > a[in + 1]) {
					swap(a,in,in+1);
				}
			}
			for(;in>f;in--){
				if(a[in]<a[in-1]){
					swap(a,in,in-1);
				}
			}
			f++;
		}
	}
	
	/*
	 * 二维数组排序
	 */
	static void bubble2DArray(int[][] a) {
		apply2DArray(a,to2DArray(newBubbleSortArray(to1DArray(a)), a[0].length));
	}

	static int[][] newBubble2DArray(int[][] a) {
		int[][] b = to2DArray(newBubbleSortArray(to1DArray(a)), a[0].length);
		return b;
	}
}