int[] arr = {4, 2, 7, 1, 5, 9, 3, 6, 8};
冒泡排序
for(int i = 0; i < arr.length-1; i++) //外循环是控制排序的次数n-1, 每次循环结束确定一个最大值
{
for(int j = 0; j < arr.length - 1 - i; j++) // 内循环是第i次循环中比较的次数n-i
{
if(arr[j] > arr[j+1]){//前面一个和后面一个相互比较，较大的和较小的交换位置，较小的排前面，本次循环完成之后最大的放最后
int temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
插入排序
for(int i = 1; i < arr.length; i++) //外循环是1到n-1，左边取出数组第0个元素作为已经排序数组，接着i从数组中第1元素个开始循环
{
int k=arr[i];//取出arr[i]保存到k
int j=i-1;//arr[i]前面的那个元素
while(j>=0 && arr[j]>k) {
arr[j+1]=arr[j];//左边的元素向右覆盖后面的元素
j--;//一直向左比较
}
arr[j+1]=k;//找到位置插入
}
选择排序
for(int i = 0; i < arr.length; i++) //外循环是0到n-1，每次挑选出最小的元素，一共需要挑选n-1次
{
int index=i;//保存待排序元素中最小的下标
for(int j=i+1;j<arr.length;j++) {
if(arr[j]<=arr[index]) {//找到待排序中最小的
index=j;
}
}
//arr[index]和待排序中的第一个arr[i]交换
int temp=arr[i];
arr[i]=arr[index];
arr[index]=temp;
}
计数排序
int[] arr = {0,2，5,3，7,9，3,3，3,7}
// 找到待排序数组中的最大值
int max = Arrays.stream(arr).max().getAsInt();
// 创建计数数组，并初始化为 0
int[] countArray = new int[max + 1];
for (int i = 0; i < countArray.length; i++) {
countArray[i] = 0;
}
// 统计数组中每个元素的出现次数
for (int i = 0; i < arr.length; i++) {
countArray[array[i]]++;
}
// 计算每个元素在排序后的序列中的位置
for (int i = 1; i < countArray.length; i++) {
countArray[i] += countArray[i - 1];
}
// 创建一个临时数组存储排序结果
int[] tempArray = new int[arr.length];
for (int i = array.length - 1; i >= 0; i--) {
tempArray[countArray[arr[i]] - 1] = arr[i];
countArray[arr[i]]--;
}
// 将临时数组的内容复制回原始数组
for (int i = 0; i < arr.length; i++) {
arr[i] = tempArray[i];
}
归并排序
使用递归方式，将数组对半分，再对半分（如：8—4—2—1），直到为一个不能再分，再排序合并（如：1–2–4–8）
package gg;
public class Solution {
public static void main(String args[]) {
int[] arr = {1,5,3,4,7,8,9,6,2,0};
System.out.print("排序前的数组为：");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
merge_sort(arr);
System.out.println();
System.out.print("排序后的数组为：");
for(int i = 0; i < arr.length; i++){
System.out.print(arr[i] + " ");
}
}
static void merge_sort_recursive(int[] arr, int[] result, int start, int end) {
// 1、分解到最小需要解决的地步，无法再分解了
if (start >= end){
// 需要开始解决问题
return;
}
// 2、解决
// 计算数组 arr 的中间位置
int mid = (start + end ) / 2;
// start1 为左区间的开始位置
int start1 = start;
// end1 为左区间的结束位置
int end1 = mid;
// start2 为右区间的开始位置
int start2 = mid + 1;
// end2 为右区间的结束位置
int end2 = end;
// 调用 merge_sort_recursive 函数，将 arr 数组中的 start1 到 end1 这一区间的数字排序后，并存放到 result 中
merge_sort_recursive(arr, result, start1, end1);
// 调用 merge_sort_recursive 函数，将 arr 数组中的 start2 到 end2 这一区间的数字排序后，并存放到 result 中
merge_sort_recursive(arr, result, start2, end2);
// 3、合并
// 将左右区间中较小的数字存放到 result 中，从 k 开始
int k = start;
while (start1 <= end1 && start2 <= end2){
// 如果 arr[start1] < arr[start2])
if(arr[start1] < arr[start2]){
// result[k] 存放的是 arr[start1]
result[k] = arr[start1] ;
start1++;
k++;
}else{
// 否则，result[k] 存放的是 arr[start2]
result[k] = arr[start2] ;
start2++;
k++;
}
}
// 如果左区间中还有元素，那么把它都添加到 result 中
while (start1 <= end1){
result[k] = arr[start1];
k++;
start1++;
}
// 如果右区间中还有元素，那么把它都添加到 result 中
while (start2 <= end2){
result[k] = arr[start2];
k++;
start2++;
}
// 最后，把结果赋值到 arr 中
for (k = start; k <= end; k++)
arr[k] = result[k];
}
public static void merge_sort(int[] arr) {
int len = arr.length;
int[] result = new int[len];
merge_sort_recursive(arr, result, 0, len - 1);
}
}
快速排序
package gg;
import java.util.Arrays;
public class Solution {
public static void main(String args[]) {
int[] nums = {1,5,1,8,2,2,4,2,2,3};
// 打印排序前的数组
System.out.println(Arrays.toString(nums));
// 执行快速排序操作
quickSort(nums,0,nums.length - 1);
// 打印排序后的数组
System.out.println(Arrays.toString(nums));
}
// 函数传入待排序数组 nums
// 排序区间的左端点 left
// 排序区间的右端点 right
private static void quickSort(int[] nums,int left, int right){
// 如果 left 大于等于 right，说明该区间只有 1 个或者没有元素
if( left >=right ){
// 无需再递归划分后再排序，直接返回
return;
}
// 调用函数 partition，将 left 和 right 之间的元素划分为左右两部分
int mid = partition(nums,left,right);
// 划分之后，再对 mid 左侧的元素进行快速排序
quickSort(nums,left,mid - 1);
// 划分之后，再对 mid 右侧的元素进行快速排序
quickSort(nums,mid + 1,right);
}
private static int partition(int[] nums, int left ,int right){
// 经典快速排序的写法
// 设置当前区间的第一个元素为基准元素
int pivot = nums[left];
// left 向右移动，right 向左移动，直到 left 和 right 指向同一元素为止
while( left < right ){
// 只有当遇到小于 pivot 的元素时，right 才停止移动
// 此时，right 指向了一个小于 pivot 的元素，这个元素不在它该在的位置上
while( left < right && nums[right] >= pivot ){
// 如果 right 指向的元素是大于 pivot 的，那么
// right 不断的向左移动
right--;
}
// 将此时的 nums[left] 赋值为 nums[right]
// 执行完这个操作，比 pivot 小的这个元素被移动到了左侧
nums[left] = nums[right];
// 只有当遇到大于 pivot left 才停止移动
// 此时，left 指向了一个大于 pivot 的元素，这个元素不在它该在的位置上
while( left < right && nums[left] <= pivot){
// 如果 left 指向的元素是小于 pivot 的，那么
// left 不断的向右移动
left++;
}
// 将此时的 nums[right] 赋值为 nums[left]
// 执行完这个操作，比 pivot 大的这个元素被移动到了右侧
nums[right] = nums[left];
}
// 此时，left 和 right 相遇，那么需要将此时的元素设置为 pivot
// 这个时候，pivot 的左侧元素都小于它，右侧元素都大于它
nums[left] = pivot;
// 返回 left
return left;
}
}
堆排序
package gg;
import java.util.Arrays;
public class Solution {
public static void main(String args[]) {
int[] arr = {1,5,1,8,7,6,4,2,2,3};
// 打印排序前的数组
System.out.println(Arrays.toString(arr));
// 执行堆排序操作
heapSort(arr); // 打印排序后的数组
System.out.println(Arrays.toString(arr));
}
public static void heapSort(int[] arr){
// 1、将无序序列构建成一个堆，根据升序降序需求选择大顶堆或小顶堆
for(int i = arr.length / 2 - 1 ; i >= 0 ; i-- ){
//从第一个非叶子节点从下至上，从后向前调整结构
adjustHeap( arr , i , arr.length );
}
// 2、将堆顶元素与末尾元素交换，将最大元素”沉”到数组末端，此时数组末端存储了当前区间最大的元素
for(int j = arr.length - 1 ; j > 0 ; j-- ){
// 3、每次将堆顶元素与末尾元素进行交换，使末尾元素最大
swap(arr,0,j);
// 4、重新对堆进行调整
adjustHeap(arr,0,j);
// 执行完 4 之后，剩下未排序的那些元素依旧维护着一个最大堆，继续下一轮循环
}
}
// 调整大顶堆
public static void adjustHeap(int []arr,int parent,int length){
// 1、取出当前元素，需要把它挪到正确的位置上，比如此时是 A 元素
// A
// / \
// B C
int temp = arr[parent];
// 2、从 parent 节点的左子节点开始
// 也就是 2 * parent + 1 处开始
int child = 2 * parent + 1 ;
while(child < length){
// A
// / \
// B C
// 获取 A 、B 、C 三者的最大值，把它放到 A 位置
// 于是，第一步先去对比 B 和 C，查看它们的较大值是哪一个
// 3、如果左子节点小于右子节点，child 指向右子节点
if( child + 1 < length && arr[child] < arr[ child + 1 ] ){
child++;
}
// 如果父节点的值已经大于孩子节点的值，说明在正确位置上
// 直接结束
if (temp >= arr[child]){
break;
}
// B 、 C 都是 A 的子节点，如果 B 、 C 的较大值大于 A
// 将最大值赋值给 A
arr[parent] = arr[child];
// 此时，parent 这个节点已经存放了正确的元素
// B
// / \
// B C
// 接下来，需要观察一下，parent 原先的节点值 A 应该放到哪个位置
// 所以，顺着 parent 这个节点来到它的子节点，就是 B 这个节点的位置，也是 child 这个节点的位置
parent = child;
// 那么，子节点也发生了变化，从它的左子节点开始
child = 2 * parent + 1;
}
// 将 temp 值放到最终的位置
arr[parent] = temp;
}
// 交换元素
public static void swap(int []arr,int a ,int b){
int temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
}
}
701
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
