算法
二分查找法
前提：必须有序。折半查找
public static void main(String[] args) {
//表示具有从键盘上接收数据的能力
Scanner input=new Scanner(System.in);
int[] nums= {1,2,3,4,5,6,7,8,9};
System.out.println("请输入你要查找的正整数：");
int find=input.nextInt();
/*初始化条件*/
//定义三个变量，分别存数组最小下标，最大下标，中间下标
int min=0;
int max=nums.length-1;
int mid=(min+max)/2;
//定义一个变量作标记，标记是否找到该数
boolean flag=false;
//声明一个变量存储找到的下标
int index=0;
while (min<=max) {
//find=4,min=2,max=3,mid=1
if (nums[mid]>find) {
max=mid-1;
mid=(min+max)/2;
}else if (nums[mid]<find) {
min=mid+1;
mid=(min+max)/2;
}else {
index=mid;
flag=true;
break;
}
}
if (flag==true) {
System.out.println("在数组中找到了该数,下标位置为："+index);
}else {
System.out.println("在数组中没找到了该数");
}
}
求最大值和最小值(重点)
打擂台的方法
public static void main(String[] args) {
//准备一个数组
int[] nums= {3,7,22,66,44,6,88};
//声明一个变量，存储最大值
int max=nums[0];
//声明一个变量，存储最小值
int min=nums[0];
for(int i=1;i<nums.length;i++) {
//求最大值
if(nums[i]>max) {
max=nums[i];
}
//求最小值
if (nums[i]<min) {
min=nums[i];
}
}
System.out.println("数组中最大值为："+max);
System.out.println("数组中最小值为："+min);
}
冒泡排序(重点)
原理：比较相邻的元素，如果顺序错误就把它们交换过来，重复此步骤直到整个数组有序
复杂度分析：
时间复杂度：
空间复杂度：
O(1)
public static void main(String[] args) {
//声明数组并赋值
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前数组为：");
for (int n : nums) {
System.out.println(n);
}
//外层循环控制比较的轮数
for(int i=0;i<nums.length-1;i++) {
//内层循环控制比较的次数
for (int j = 0; j <nums.length-i-1; j++) {
if(nums[j]>nums[j+1]) {
int temp=nums[j];
nums[j]=nums[j+1];
nums[j+1]=temp;
}
}
}
System.out.println("排序后数组为：");
for (int n : nums) {
System.out.println(n);
}
}
选择排序
第一轮将第一个位置的数依次与后面的每个数比较，把最小的一个数比出来存在第一个位置；后面将剩下的数的第一个位置的数依次与后面的每个数比较，把最小的一个数比出来存在第一个位置
public static void main(String[] args) {
//准备一个数组
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前数组为：");
for (int n : nums) {
System.out.println(n);
}
//外层循环控制比较的轮数
for(int i=0;i<nums.length-1;i++) {
//内层循环控制从剩下数的第一个数比到结尾
for(int j=i+1;j<nums.length;j++) {
if(nums[i]>nums[j]) {
int temp=nums[i];
nums[i]=nums[j];
nums[j]=temp;
}
}
}
System.out.println("\n排序后数组为：");
for (int n : nums) {
System.out.println(n);
}
}
插入排序
从无序数列中取出一个数插入到有序数列，保持有充数列的顺序。
public static void main(String[] args) {
//准备一个数组
int[] nums= {5,8,1,7,6,3};
System.out.println("排序前数组为：");
for (int n : nums) {
System.out.println(n);
}
for(int i=1;i<nums.length;i++) {
for (int j = i; j >0; j--) {
if(nums[j]>=nums[j-1]) {
break;
}else if(nums[j]<nums[j-1]) {
int temp=nums[j];
nums[j]=nums[j-1];
nums[j-1]=temp;
}
}
}
System.out.println("排序后数组为：");
for (int n : nums) {
System.out.println(n);
}
}
快速排序
原理：选择一个基准值，将数组分为两部分，小于基准值的元素放在左边，大于基准值的元素放在右边，然后对左右两部分分别进行快速排序
public class QuickSort {
public static void quickSort(int[] arr, int low, int high) {
if (low < high) {
int pi = partition(arr, low, high);
quickSort(arr, low, pi - 1);
quickSort(arr, pi + 1, high);
}
}
private static int partition(int[] arr, int low, int high) {
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++) {
if (arr[j] < pivot) {
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp;
return i + 1;
}
public static void main(String[] args) {
int[] arr = {10, 7, 8, 9, 1, 5};
int n = arr.length;
quickSort(arr, 0, n - 1);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
归并排序
原理：采用分治法，将数组分成两个子数组，分别对两个子数组进行排序，然后将排好序的子数组合并成一个最终的有序数组
public class MergeSort {
public static void mergeSort(int[] arr, int l, int r) {
if (l < r) {
int m = l + (r - l) / 2;
mergeSort(arr, l, m);
mergeSort(arr, m + 1, r);
merge(arr, l, m, r);
}
}
private static void merge(int[] arr, int l, int m, int r) {
int n1 = m - l + 1;
int n2 = r - m;
int[] L = new int[n1];
int[] R = new int[n2];
for (int i = 0; i < n1; ++i) {
L[i] = arr[l + i];
}
for (int j = 0; j < n2; ++j) {
R[j] = arr[m + 1 + j];
}
int i = 0, j = 0;
int k = l;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k] = L[i];
i++;
} else {
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1) {
arr[k] = L[i];
i++;
k++;
}
while (j < n2) {
arr[k] = R[j];
j++;
k++;
}
}
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6, 7};
mergeSort(arr, 0, arr.length - 1);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
堆排序
原理：利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。它的最坏、最好、平均时间复杂度均为
O(nlogn)
public class HeapSort {
public static void heapSort(int[] arr) {
int n = arr.length;
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(arr, n, i);
}
for (int i = n - 1; i > 0; i--) {
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
heapify(arr, i, 0);
}
}
private static void heapify(int[] arr, int n, int i) {
int largest = i;
int l = 2 * i + 1;
int r = 2 * i + 2;
if (l < n && arr[l] > arr[largest]) {
largest = l;
}
if (r < n && arr[r] > arr[largest]) {
largest = r;
}
if (largest != i) {
int swap = arr[i];
arr[i] = arr[largest];
arr[largest] = swap;
heapify(arr, n, largest);
}
}
public static void main(String[] args) {
int[] arr = {12, 11, 13, 5, 6, 7};
heapSort(arr);
for (int num : arr) {
System.out.print(num + " ");
}
}
}
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
