java基础[数组及对象数组排序（冒泡排序、选择排序、快速排序）]

1、问题描述

        使用冒泡排序、选择排序、快速排序，完成数组及对象数组的排序。

2、代码

        

2.1 数组排序
package com.hzy.javase.array;

import java.util.Arrays;

public class ArrayTest {
	
	public static void quickSort(int[] arr, int begin, int end) {
		
		if(end - begin <= 1) {
			return;
		}
		
		int key = arr[begin];		//总是取第一个元素作为基准
		int keyIndex = begin;		//记录比key小的元素个数
		int temp = 0;				//用于交换元素使用
		
		for(int i = begin + 1; i < end; i++) {
			if(arr[i] < key) {
				keyIndex++;			//找到比key小的元素，keyIndex往后移动，记录比key小的元素个数，否则不变
				//交换keyIndex和i位置的值,比基准元素小的值在基准的右面，但基准值位置不变，全部遍历完成后交换基准值位置与比其小的最后一个元素的位置
				temp = arr[keyIndex];
				arr[keyIndex] = arr[i];
				arr[i] = temp;
			}
		}
		//基准值归位到keyIndex处，一次快速排序完成
		arr[begin] = arr[keyIndex];
		arr[keyIndex] = key;
		
		//左子列递归
		quickSort(arr,begin,keyIndex);
		//右子列递归
		quickSort(arr, keyIndex + 1, end);
	}
	
	public static void main(String[] args) {
		
		int[] arr = new int[8];
		
		for(int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 100);
		}
		
		for(int temp : arr) {
			System.out.print(temp + " ");
		}
		System.out.println();

//		快速排序：选择一个基准值（key），将基准值放在数组中间，左边数都比其小，右边数都比其大
//		一般选择数组的第一个元素作为基准
//		设置keyIndex，默认值为0，每找到一个比key小的元素，将keyIndex++，最后交换数组第一个元素与arr[minIndex]元素的值
//		之后递归操作，递归结束条件：最小索引相同或者相差1
		
		System.out.println("####################4.快速排序测试####################");
		quickSort(arr,0,arr.length);
		for(int temp : arr) {
			System.out.print(temp + " ");
		}
		System.out.println();
		
		System.out.println("####################5.调用封装方法排序测试####################");
		//封装方法sort底层就是快速排序
		Arrays.sort(arr);
		for(int temp : arr) {
			System.out.print(temp + " ");
		}
		System.out.println();
	}

	public static void main2(String[] args) {
		
		int[] arr = new int[8];
		
		for(int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 100);
		}
		
		for(int temp : arr) {
			System.out.print(temp + " ");
		}
		System.out.println();
		
//		数组排序[选择排序]：每次选择一个最大（小）的元素，放在数组的基准位置，基准位置默认为0，以后每进行一趟排序后，+1
//		效率与冒泡排序算法差不多
		for(int i = 0; i < arr.length - 1; i++) {
			//记录基准元素的值
			int minIndex = i;
			for(int j = i + 1; j < arr.length; j++) {
				if(arr[j] > arr[minIndex]) {
					minIndex = j;
				}
			}
			//循环结束后，得到最小数值的数组下标，交换基准与最小下标位置的值
			int temp = arr[i];
			arr[i] = arr[minIndex];
			arr[minIndex] = temp;
		}
		System.out.println("####################3.选择排序测试####################");
		for(int temp1 : arr) {
			System.out.print(temp1 + " ");
		}
		System.out.println();
	}
	
	public static void main1(String[] args) {
		
		int[] arr = new int[8];
		
		for(int i = 0; i < arr.length; i++) {
			arr[i] = (int)(Math.random() * 100);
		}
		
		for(int temp : arr) {
			System.out.print(temp + " ");
		}
		System.out.println();
		
//		取所有奇数
		int[] tempArr = new int[arr.length];
		int count = 0;
		
		for(int i = 0; i < arr.length; i++) {
			if(arr[i] % 2 != 0) {
				tempArr[count++] = arr[i];
			}
		}
		
		int[] newArr = new int[count];
		
		for(int i = 0; i < count; i++) {
			newArr[i] = tempArr[i];
		}
		System.out.println("####################1.取奇数测试####################");
		for(int temp : newArr) {
			System.out.print(temp + " ");
		}
		System.out.println();
		
//		数组排序[冒泡排序]:每相邻两个元素进行比较，双重循环实现，效率较低
		int temp = 0;
		for(int i = 0; i < arr.length - 1; i++) {				//控制交换轮数,arr.length - 1次
			for(int j = 0; j < arr.length - 1 - i; j++) {		//控制一轮交换的次数 ，随着i的增大而减少比较的次数
				if(arr[j] > arr[j + 1]) {
					temp = arr[j];
					arr[j] = arr[j + 1];
					arr[j + 1] = temp;
				}
			}
		}
		System.out.println("####################2.冒泡排序测试####################");
		for(int flag : arr) {
			System.out.print(flag + " ");
		}
		System.out.println();
	}
}

2.2 对象数组排序
package com.hzy.javase.array;

public class StudentTest {
	
	public static void main2(String[] args) {
		Student[] stuArr = new Student[20];
		
		String[] name1 = {"赵","钱","孙","李","周","吴","郑","王"};
		String[] name2 = {"明","阳","微","男","楠","博","三","歌"};
//		遍历才可以用增强for
		for(int i = 0; i < stuArr.length; i++) {
			int id = i + 1;
			int index1 = (int)(Math.random() * 100) % name1.length;
			int index2 = (int)(Math.random() * 100) % name2.length;
			String name = name1[index1] + name2[index2];
			int grade = (int)(Math.random() * 100) % 6 + 1;
			double score = (int)(Math.random() * 101);
			stuArr[i] = new Student(id,name,grade,score);
		}
//		增强for 数据类型 变量名 ： 数组名
		for(Student temp : stuArr) {
			System.out.println(temp.say());
		}
		System.out.println("##############2.选择排序测试####################");
		
//		选择排序
		for(int i = 0; i < stuArr.length - 1; i++) {
			int minIndex = i;
			for(int j = i + 1; j < stuArr.length; j++) {
				if(stuArr[j].getScore() < stuArr[minIndex].getScore()) {
					minIndex = j;		//更新最小值元素下标
				}
			}
			Student tempStudent;
			tempStudent = stuArr[i];
			stuArr[i] = stuArr[minIndex];
			stuArr[minIndex] = tempStudent;
		}
		for(Student temp : stuArr) {
			System.out.println(temp.say());
		}
	}
	
	public static void main1(String[] args) {
		Student[] stuArr = new Student[20];
		
		String[] name1 = {"赵","钱","孙","李","周","吴","郑","王"};
		String[] name2 = {"明","阳","微","男","楠","博","三","歌"};
//		遍历才可以用增强for
		for(int i = 0; i < stuArr.length; i++) {
			int id = i + 1;
			int index1 = (int)(Math.random() * 100) % name1.length;
			int index2 = (int)(Math.random() * 100) % name2.length;
			String name = name1[index1] + name2[index2];
			int grade = (int)(Math.random() * 100) % 6 + 1;
			double score = (int)(Math.random() * 101);
			stuArr[i] = new Student(id,name,grade,score);
		}
//		增强for 数据类型 变量名 ： 数组名
		for(Student temp : stuArr) {
			System.out.println(temp.say());
		}
		System.out.println("##############1.冒泡排序测试####################");
		
//		对象数组排序[冒泡排序]
		Student tempScore;
		for(int i = 0; i < stuArr.length - 1; i++) {
			for(int j = 0; j < stuArr.length - 1 - i; j++) {
				if(stuArr[j + 1].getScore() > stuArr[j].getScore()) {
					tempScore = stuArr[j];
					stuArr[j] = stuArr[j + 1];
					stuArr[j + 1] = tempScore;
				}
			}
		}
		
		for(Student temp : stuArr) {
			System.out.println(temp.say());
		}
	}
}