java 基础排序

 在java8的影响下越来越多的人开始不注意数据结构的算法啦，今天我们就用学生的排序举举例子。

@Data
public class Student implements Serializable
{
	private String sex;

	private Integer age;

	private Integer tall;

	public Student (String sex, Integer age, Integer tall)
	{
		this.sex = sex;
		this.age = age;
		this.tall = tall;
	}
}

1. 一般的Java 8 的写法为

 public static void main(String[] args) {
        List<Student> students = new LinkedList<>();
        students.add(new Student("woman",11,12));
        students.add(new Student("man",11,12));
        students.add(new Student("woman",19,12));
        List<Student> coll = students.stream().sorted(Comparator.comparing(Student::getSex,(s1, s2)->{
            if("man".equals(s1)&&"woman".equals(s2)){
                return -1;
            }else if("woman".equals(s1)&&"man".equals(s2)){
                return 1;
            }else {
                return 0;
            }
        }).thenComparing(Student::getAge,Comparator.nullsLast(Integer::compareTo)).thenComparing(Student::getAge,Comparator.reverseOrder())).collect(Collectors.toList());

        System.out.println(coll.toString());
    }

按照年龄排序的冒泡算法

/**
	 * 按照年龄的冒泡排序：从小到大
	 */
	public static void sort (List<Student> studentList)
	{
		// 对 arr 进行拷贝，不改变参数内容

		for (int i = 1; i < studentList.size (); i++)
		{
			// 设定一个标记，若为true，则表示此次循环没有进行交换，也就是待排序列已经有序，排序已经完成。
			boolean flag = true;

			for (int j = 0; j < studentList.size () - i; j++)
			{
				if (studentList.get (j).getAge () > studentList.get (j + 1).getAge ())
				{
					Student student = studentList.get (j);
					studentList.set (j, studentList.get (j + 1));
					studentList.set (j + 1, student);
					flag = false;
				}
			}

			if (flag)
			{
				break;
			}
		}
	}

按照年龄排序的二分排序算法

/**
	 * 按照年龄的二分排序：从小到大
	 */
public static void sort (List<Student> studentList)
	{

		for (int i = 1; i < studentList.size (); i++)
		{
			Student student = studentList.get (i);
			int low = 0;
			int high = i - 1;
			int mid = - 1;
			while (low <= high)
			{
				mid = low + (high - low) / 2;
				if (studentList.get (mid).getAge () > student.getAge ())
				{
					high = mid - 1;
				}
				else
				{ // 元素相同时，也插入在后面的位置
					low = mid + 1;
				}
			}
			for (int j = i - 1; j >= low; j--)
			{
				studentList.set (j+1,studentList.get (j));
			}
			studentList.set (low,student);
		}
	}


	public static void main(String[] args) {
		List<Student> studentList = new LinkedList<>();
		studentList.add(new Student("man",11,11));
		studentList.add(new Student("man",11,11));
		studentList.add(new Student("woman",13,11));
		studentList.add(new Student("man",110,11));
		studentList.add(new Student("man",10,11));
		sort(studentList);
	}

按照年龄排序的插入排序算法

/**
	 * 插入排序
	 */
	public static List<Student> sort (List<Student> studentList)
	{
		// 从下标为1的元素开始选择合适的位置插入，因为下标为0的只有一个元素，默认是有序的
		for (int i = 1; i < studentList.size (); i++)
		{
			// 记录要插入的数据
			Student student = studentList.get (i);

			// 从已经排序的序列最右边的开始比较，找到比其小的数
			int j = i;
			while (j > 0 && student.getAge () < studentList.get (j - 1).getAge ())
			{
				studentList.set (j, studentList.get (j - 1));
				j--;
			}

			// 存在比其小的数，插入
			if (j != i)
			{
				studentList.set (j, student);
			}

		}
		return studentList;
	}

按照年龄排序的归并排序算法

/**
	 * 按照年龄的归并排序
	 */
	public List<Student> sort (List<Student> studentList)
	{
		int size = studentList.size ();
		if (size < 2)
		{
			return studentList;
		}

		//用于分割左右两边的数据中间标识位
		int middle = (int) Math.floor (size / 2);

		List<Student> leftStudent = new ArrayList<> ();
		List<Student> rightStudent = new ArrayList<> ();
		//组装左边的学生数据
		for (int i = 0; i < middle; i++)
		{
			leftStudent.add (studentList.get (i));
		}
		//组装右边的学生数据
		for (int j = middle; j < studentList.size (); j++)
		{
			rightStudent.add (studentList.get (j));
		}
		return merge (sort (leftStudent), sort (rightStudent),studentList);
	}

	protected List<Student> merge (List<Student> leftStudentList, List<Student> rightStudentList,List<Student> studentList)
	{
		int i = 0;
		while (leftStudentList.size () > 0 && rightStudentList.size () > 0)
		{
			if (leftStudentList.get (0).getAge () <= rightStudentList.get (0).getAge ())
			{
				studentList.set (i++, leftStudentList.get (0));
				this.copy (leftStudentList);
			}
			else
			{
				studentList.set (i++, rightStudentList.get (0));
				this.copy (rightStudentList);
			}
		}

		while (leftStudentList.size () > 0)
		{
			studentList.set (i++, leftStudentList.get (0));
			this.copy (leftStudentList);
		}

		while (rightStudentList.size () > 0)
		{
			studentList.set (i++, rightStudentList.get (0));
			this.copy (rightStudentList);
		}

		return studentList;
	}

	/**
	 * 获取指定开始下标之后的数据
	 */
	public void copy (List<Student> leftOrRightStudentList)
	{
		List<Student> copyStudent = new ArrayList<> ();
		for (int j = 1; j < leftOrRightStudentList.size (); j++)
		{
			copyStudent.add (leftOrRightStudentList.get (j));
		}
		//先清空所有数据
		leftOrRightStudentList.clear ();
		//添加数据
		leftOrRightStudentList.addAll (copyStudent);
	}

按照年龄排序的快速排序算法

	private static void quickSort (List<Student> studentList, int left, int right)
	{
		if (left < right)
		{
			int partitionIndex = partition (studentList, left, right);
			quickSort (studentList, left, partitionIndex - 1);
			quickSort (studentList, partitionIndex + 1, right);
		}
	}

	private static int partition (List<Student> studentList, int left, int right)
	{
		// 设定基准值（pivot）
		int pivot = left;
		int index = pivot + 1;
		for (int i = index; i <= right; i++)
		{
			if (studentList.get (i).getAge () < studentList.get (pivot).getAge ())
			{
				swap (studentList, i, index);
				index++;
			}
		}
		swap (studentList, pivot, index - 1);
		return index - 1;
	}

	/**
	 * 值交换
	 * @param studentList
	 * @param i
	 * @param j
	 */
	private static void swap (List<Student> studentList, int i, int j)
	{
		//取出要交换位置的值放到临时对象Student中
		Student student = studentList.get (i);
		//值开始交换
		studentList.set (i,studentList.get (j));
		studentList.set (j,student);
	}

按照年龄排序的选择排序算法

/**
	 * 按照学生的年龄选择排序
	 */
	public static void sort (List<Student> studentList)
	{
		// 总共要经过 N-1 轮比较
		for (int i = 0; i < studentList.size () - 1; i++)
		{
			int min = i;
			// 每轮需要比较的次数 N-i
			for (int j = i + 1; j < studentList.size (); j++)
			{
				if (studentList.get (j).getAge () < studentList.get (min).getAge ())
				{
					// 记录目前能找到的最小值元素的下标
					min = j;
				}
			}

			// 将找到的最小值和i位置所在的值进行交换
			if (i != min)
			{
				Student student = studentList.get (i);
				studentList.set (i, studentList.get (min));
				studentList.set (min, student);
			}
		}
	}

按照年龄排序的希尔排序算法

/**
	 * 希尔排序
	 */
	public static void sort(List<Student> studentList) {
		int length = studentList.size ();
		Student student;
		for (int step = length / 2; step >= 1; step /= 2) {
			for (int i = step; i < length; i++) {
				student = studentList.get (i);
				int j = i - step;
				while (j >= 0 && studentList.get (j).getAge () > student.getAge ()) {
					studentList.set (j+step,studentList.get (j));
					j -= step;
				}
				studentList.set (j+step,student);
			}
		}
	}