自定义排序法第二版本

这是我自己想的排序方法的第二个版本

里面的原理就是数组中的每一个数，放到另一个数组中，并且是以要排序的数组的数字作为索引，再将第二个数组中的数字按照第二个数组的顺序依次放到第一个数组中。

代码

class Rule {

	class Node {// 节点
		Node head = null;//头结点

		Node next = null;//头节点的下一个节点

		public int value;//被存入的值

		public Node(int value) {
			this.value = value;
		}

		public Node() {
		}
	}

	public void sort(int[] arr) {
		int max = 0;//定义的数组最大值
		int min = 0;//定义的数组最小值
		int temp = 0;//替换值
		int j = arr.length - 1;
		for (int i = 0; i < arr.length - 1; i++) {//通过循环选出最大值最小值
			if (arr[i] > arr[i + 1]) {
				temp = arr[i + 1];
				arr[i + 1] = arr[i];
				arr[i] = temp;
			}
			max = arr[i + 1];
			if (arr[j] < arr[j - 1]) {
				temp = arr[j];
				arr[j] = arr[j - 1];
				arr[j - 1] = temp;
			}
			j--;
			min = arr[0];
		}

		Node[] node = new Node[max + 1];//创建第二个排序数组
		for (int i = 0; i < node.length; i++) {
			node[i] = new Node(-1);//给每一个数组里面的对象赋值
		}
		add(node, arr);//将第一个数组放到第二个数组中
		int y = 0;
		for (int i = 0; i < node.length; i++) {//将第二个数组的值放到第一个数组中
			if (node[i].head != null) {
				arr[y] = node[i].head.value;
				Node n = node[i].head.next;
				while (n != null) {//里面有相同的数会再次进行
					arr[++y] = n.value;
					n = n.next;
				}
				y++;
			}
		}
		System.out.println(Arrays.toString(arr));
	}

	public void add(Node[] node, int[] arr) {// 将数组的值转移至数组node里面，并且通过arr的值来排序
		for (int i = 0; i < arr.length; i++) {
			addNode(arr[i], node);
		}
	}

	public void addNode(int d, Node[] node) {
		Node newNode = new Node(d);// 实例化一个节点
		if (node[d].head == null) {
			node[d].head = newNode;//第一个数组中的值是存在数组的第一个节点中，不是存在数组的对象中
			return;
		}
		Node tmp = node[d].head;
		while (tmp.next != null) {//有相同的数字，会存在头节点的下一个节点
			tmp = tmp.next;
		}
		tmp.next = newNode;
	}

}

public class Demo03 {
	public static void main(String[] args) {
		int[] a = { 1, 2, 6, 15, 8, 6, 7, 1, 2, 1,1,15};
		Rule r = new Rule();
		r.sort(a);
		// System.out.println(r.head.next.next + "1234567");
	}

}

这个排序有很大的局限性，只能排数字，由于是由索引排序，所以只能排非负数，排负数会报错