目录
前言：
复习中，总结 一下所有常用的排序算法，有冒泡排序，选择排序，插入排序，快速排序等，最后还总结了一个斐波那契数列前n项的输出算法。
冒泡排序：
package paixu;
/**
* 相邻的两个数字比较排序，先将最大的交换到最后面，然后重复。
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {12,34,643,33,63,235,67};
int temp;
for(int i = 0;i<arr.length-1;i++) {
for(int j=0;j<arr.length-1-i;j++) {
if(arr[j]>arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
for(int k : arr) System.out.println(k);
}
}选择排序：
package paixu;
/**
* 从第一个位置开始，用某个位置依次与后边所有元素比较一遍，如果后面的某个位置的数比该位置的数小，就换一换位置。
*/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {12,34,643,33,63,235,67};
int temp;
for(int i = 0;i<arr.length-1;i++) { //位置
for(int j = i+1;j<arr.length;j++) { //后面所有的元素
if(arr[j]<arr[i]) {
temp = arr[j];
arr[j] = arr[i];
arr[i] = temp;
}
}
}
for(int k : arr) System.out.println(k);
}
}
插入排序：
package paixu;
/**
* 某个位置 与前边 所有元素比较，
* 这个位置的元素 比 前边 元素 小，
* 那么把 这个位置的元素 插入到 比
* 它大 的那个元素的位置。
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {12,34,643,33,63,235,67};
int temp = 0;
for(int i = 1;i<arr.length;i++) {
for(int j = 0;j<i;j++) {
if(arr[i]<arr[j]) {
temp = arr[i];
for(int k = i;k>j;k--) {
arr[k] = arr[k-1];
}
arr[j] = temp;
}
}
}
for(int k : arr) System.out.println(k);
}
}
计数排序
package paixu;
/**
* 利用数值的下标进行排序
* 数组的下标是从0开始逐渐递增的，并且有序。
* 数组的下标存储的是元素的真实值
* 数组的元素存储的是需要排序的元素出现的次数
*
* 优点：效率高
*
* 缺点：使用范围有限，数组长度不确定
* 造成空间 浪费 1 3 2 6 9 1000000000
* 数组的类型不好确定
*/
public class CountSort {
public static void main(String[] args) {
int[] arr = {2,1,4,7,2,8,1,5,1};
int max = arr[0];
//先得到数组的最大值，作为新的数组的长度
for(int i =1;i<arr.length;i++) {
if(arr[i]>max) {
max=arr[i];
}
}
//定义一个新数组，数组的长度就是旧数组的最大值+1
int[] newArr = new int[max+1];
for(int i = 0;i<arr.length;i++) {
newArr[arr[i]]++;
}
//打印输出，新数组存的值是多少，就将该位置的数值打印几次。
for(int i = 0;i<newArr.length;i++){
for(int j=0;j<newArr[i];j++){
System.out.print(i+" ");
}
}
}
}
快速排序
package paixu;
import java.util.Arrays;
/**
* 对数组排序
先选取一个基准点，作用：基准点左侧小于基准点的数据，基准点右侧大于基准点的数据
基准点：最常用的基准点选第一个
一个大数组不停的进行拆分 拆分的最终结果每个数组只有一个元素
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr={1,34,2,5,6,7,8,9,0,10,2,3,4,5};
sort(arr,0,arr.length-1);
System.out.println(Arrays.toString(arr));
}
//参数
//出口
/**
* @param arr
* @param left 左侧的元素下标位置
* @param right 右侧元素的下标
* 运行的条件 left<right
*/
public static void sort(int[] arr,int left,int right){
if(left>right){
return;
}
//符合递归的逻辑的
//拆分 大数组 按照我们的规则拆分
//关键找基准点
int point=getIndexPoint(arr,left,right);
//进行递归回调
//先对左侧数组进行回调
sort(arr,left,point-1);
//对右侧的数组进行回调
sort(arr,point+1,right);
}
//为每一个数组找基准点
private static int getIndexPoint(int[] arr, int left, int right) {
//指定初始的基准点
int key=arr[left];
while(left<right){
//从右向左循环
while(arr[right]>=key&&left<right){
right--;
}
//右侧的数据小于基准点
arr[left]=arr[right];
//从左向右进行遍历
while(arr[left]<=key&&left<right){
left++;
}
arr[right]=arr[left];
}
arr[left]=key;
return left;
}
}归并排序
package paixu;
import java.util.Arrays;
/**
* 2路归并排序
做的是两个有序集合的排序
便于理解 拿两个有序的数组进行排序
前提：两个数据集都是已经排好序的。只有一个数据集。这个数据集是排好序的
对一个大的数据集进行排序 将大的数据集分成多个小的数据集 这里的多个小的数据集是排好序的
归并排序进行拆分的时候 拆分的小数据集每个数据集中只有一个元素
归：拆分的过程
并：将两两个数据集进行汇笼排序。Merge（文件归并）
*/
public class MergeSortFinal {
public static void main(String[] args) {
int[] arr={3,1,2,5,7,5,3,8,7,6,4,8,9,34,56,78,23,12,11};
int[] newarr=new int[arr.length];
chai(arr,0,arr.length-1,newarr);
System.out.println(Arrays.toString(arr));
}
//拆分 递归
public static void chai(int[] arr,int left,int right,int[] newarr){
if(left>=right){
return;
}else{
int mid=(left+right)/2; //计算中间值
//递归调用
//左半部分
chai(arr, left, mid,newarr);//边界
chai(arr,mid+1,right,newarr);//这句代码执行完,整个拆的过程完成
//并
mergeResult(arr, left, right, mid, newarr);
}
}
//并 merge文件归并
public static void mergeResult(int[] arr,int left,int right,int mid,int[] newarr){
//定义；两个变量 记录数据集的左侧的边界
int m=left;
int n=mid+1;
//定义两个变量 记录每个数据集的右侧的边界
int x=mid;
int y=right;
//定义一个变量 记录新数组的下标的
int index=0;
while(m<=x&&n<=y){
if(arr[m]<arr[n]){
newarr[index++]=arr[m++];
}else{//arr[left]>=arr[mid+1]
newarr[index++]=arr[n++];;
}
}
while(m<=x){
newarr[index++]=arr[m++];
}
while(n<=y){
newarr[index++]=arr[n++];
}
for(int i=0;i<index;i++){
arr[i+left]=newarr[i];
}
}
}
斐波那契数列：
package paixu;
import java.util.*;
/**
* 实现斐波那契数列前n项的输出。
*/
public class Fibonacci{
static int input;
public static void main(String[] args){
Scanner scan = new Scanner(System.in);
System.out.println("输入要输出菲波那契数列的项数：");
input = scan.nextInt(); //输入要输出的项数
for(int i=0;i<input;i++){ //循环输出菲波那契数列
System.out.print(getfnum(i)+" ");
}
}
//获得菲波那契数列各项的值
public static long getfnum(int a){
if(a<2){ //满足这个条件停止递归 递归出口
return 1;
}else{
//在这里我们用到了递归，也就是让getfnum(int a)方法自己再调用自己，直到条件不满足，开始传递数据一层一层归来
return (getfnum(a-2)+getfnum(a-1));
}
}
}
扫一扫
202
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
