目录
高级排序：斐波那切数列，归并算法，希尔排序，二叉树的前中后序遍历
基本排序：主要分为冒泡排序，选择排序，插入排序和快速排序
1.冒泡排序
冒泡排序就是每次排序都是用后一个与前一个进行比较，如果后一个小于前一个，就交换位置，最后把最大值移动到最后面一个
/**
* Created by asus on 2019/11/1.
*/
//冒泡排序就是每次排序都是用后一个与前一个进行比较，如果后一个小于前一个，就交换位置，最后把最大值移动到最后面一个
public class MaoPao {
public static void main(String []args)
{
int [] a = {2,4,6,8,1,3,99,44,66};
int []b = maopao(a);
for(int c:b)
{
System.out.print(c+" ");
}
}
static int[] maopao(int []a)
{
for(int i=0;i<a.length-1;i++)
{
for(int j=0;j<a.length-i-1;j++)
{
if(a[j]>a[j+1])
{
int tem = a[j];
a[j] = a[j+1];
a[j+1]=tem;
}
}
}
return a;
}
}
2.选择排序
选择排序就是一开始将第一个值与后面的数值比较，将最小值放在第一位，依次第二个值放第二小的值
/**
* Created by asus on 2019/11/1.
*/
//选择排序就是一开始将第一个值与后面的数值比较，将最小值放在第一位，依次第二个值放第二小的值
// 比较n-1次，第一次就是将最小值比较后放在第一位，第二次就是最小值放在第二位
public class Xuanzepaixu {
public static void main(String []args)
{
int [] a = {2,4,6,8,1,3,99,44,66};
int []b = xuanze(a);
for(int c:b)
{
System.out.print(c+" ");
}
}
static int[] xuanze(int []a)
{
for(int i = 0;i<a.length-1;i++)
{
for(int j=i;j<a.length;j++)
{
if(a[i]>a[j])
{
int tem = a[i];
a[i] = a[j];
a[j] = tem;
}
}
}
return a;
}
}
3.插入排序
插入排序，就是先提取第一个元素，相当于分成两个部分，左边为第一个元素，右边为没有顺序的元素集合
然后将右边的元素依次提取与左边的元素进行比较，如果是大于就不用交换位置，如果是小于就交换位置
可以理解为，就是左边是排好序的，然后依次拿出右边的元素跟左边的进行冒泡排序
/**
* Created by asus on 2019/11/1.
*/
//插入排序，就是先提取第一个元素，相当于分成两个部分，左边为第一个元素，右边为没有顺序的元素集合
//然后将右边的元素依次提取与左边的元素进行比较，如果是大于就不用交换位置，如果是小于就交换位置
//可以理解为，就是左边是排好序的，然后依次拿出右边的元素跟左边的进行冒泡排序
public class Charu {
public static void main(String []args)
{
int [] a = {4,2,6,8,1,3,99,44,66};
int []b = charu(a);
for(int c:b)
{
System.out.print(c+" ");
}
}
static int[] charu(int []a)
{
for(int i = 0;i<a.length-1;i++)
{
for(int j=i+1;j>0;j--)
{
if(a[j-1]>a[j])
{
int tem = a[j];
a[j] = a[j-1];
a[j-1] = tem;
}
}
}
return a;
}
}
4.快速排序
快速排序也就是不断的确定中轴的位置例如我们将第一个数作为中轴，判断有多少个数比他小
小的数在左边，比他大的数在右边，这样子就能知道中轴所在数组的位置
不断确定每个数组中轴的位置，就能将整个数组给排好序
/**
* Created by asus on 2019/11/2.
*/
//快速排序也就是不断的确定中轴的位置例如我们将第一个数作为中轴，判断有多少个数比他小
//小的数在左边，比他大的数在右边，这样子就能知道中轴所在数组的位置
//不断确定每个数组中轴的位置，就能将整个数组给排好序
public class Kuaisupaixu {
public static void main(String[] args) {
int [] a = {4,2,6,8,1,3,99,44,66};
sort(a,0,a.length-1);
for(int b:a)
{
System.out.println(b);
}
}
static void sort(int []a,int left,int right)
{
//因为等于的话相当于只有一个数，没必要进行排序
if(left>=right)
{
return;
}
//确定中轴的位置
int mid = partition(a, left, right);
//从中轴分成左右两个数组在进行排序
sort(a,left,mid-1);
sort(a,mid+1,right);
}
static int partition(int []a,int left,int right)
{
//先选取第一个数作为中轴
int pivot = a[left];
int i = left+1;
int j = right;
while(right>left)
{
//我们要将小于的数放在左边，大于的数放在右边
//从左向右找到第一个数大于中轴值
while(i<=j&&a[i]<pivot)
{
i++;//这样我们就得到了第一个数值大于中轴值的数
}
//从右往左找，第一个数值小于中轴值的数
while(i<=j&&a[j]>pivot)
{
j--;
}
//注意这里要判断一下i与j的大小关系，如果i是大于j的了，就直接返回
if(i>=j)
{
break;
}
//如果不是的话就直接将大于中轴的值和小于中轴的值进行位置调换
int tem = a[i];
a[i] = a[j];
a[j] =tem;
}
//跳出循环后，将第一个从右往左找到的第一个小于中轴值的数与中轴进行位置调换，就可以了
a[left] = a[j];
a[j] = pivot;
return j;//这样j就是中轴位置的索引
}
}
高级排序：斐波那切数列，归并算法，希尔排序，二叉树的前中后序遍历
1.菲波那切数列
package com.test;
/**
* 斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144,
* 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368。
这个数列从第3项开始，每一项都等于前两项之和。
* @author asus
*
*/
public class Feibonaqieshulie {
public static void main(String[] args) {
//feibo(30);
for(int i = 1;i<=10;i++)
{
System.out.println(digui(i));
}
}
//递推方式
static void feibo(int n)
{
int a = 0; int b = 1; int c =0;
for(int i = 0;i<n;i++)
{
if(i == 0)
{
System.out.println("0");
}
else if(i==1)
{
System.out.println("1");
}
else
{
c = a+b;
a = b;
b = c;
System.out.println(c);
}
}
}
//使用递归的方式
static int digui(int a)
{
if(a==1)
{
return 0;
}
if(a==2)
{
return 1;
}
else
{
return digui(a-1)+digui(a-2);
}
}
}
2.归并算法
归并排序，依次分成两个部分，直到最后只剩下单个，再反过来进行排序，依次排序
/**
* Created by asus on 2019/11/11.
*/
//归并排序，先分后合并
public class GuibingSort {
public static void main(String[] args) {
int [] a = {4,2,6,8,1,3,99,44,66};
sort(a, 0, 8);
for(int b:a){
System.out.print(b+"\t");
}
}
public static void sort(int[]a,int left,int right)
{
//这就说明只剩下一个元素了，那么就不需要再进行分离了
if(left>=right)
{
return ;
}
//这里确定中间的位置，然后分成左右两边继续在划分
int mid = (left+right)/2;
//左边划分
sort(a, left, mid);
//右边划分
sort(a,mid+1,right);
//最后合并
meger(a,left,mid,right);
}
public static void meger(int[]a ,int left,int mid,int right)
{
int [] copy = a.clone();
int i=left,j=mid+1;
int m=mid,n=right;
//这里的意思就是合并的时候mid的左右两边还有数据
while(i<=m&&j<=n)
{
//当左边的数小于右边的时候
if(copy[i]<copy[j])
{
a[left] = copy[i];
left++;
i++;
}
else
{
a[left] = copy[j];
left++;
j++;
}
}
//这里的意思就是mid右边的数已经全部没有了，只剩下左边的
while(i<=m)
{
a[left] = copy[i];
left++;
i++;
}
while(j<=n)
{
a[left] = copy[j];
left++;
j++;
}
}
}
3.希尔排序
希尔排序就是插入排序的进阶
希尔排序思路，判断数组之间的合适间隔，取值，不断缩小间隔
数组a的元素8,9,1，7，2,3,5,4,6,0
通过计算间隔a.length/2得到是5,
分成不同的小组8,3 9,5 1,4 7,6 2，0，虽然进行了分组，但是在原数组的位置是不变的
通过对小组进行插入排序3,5,1,6,0,8,9,4,7,2
再将间隔数/2 = 2，重复上面操作，直到间隔为1时，对整个数组进行插入操作，就排好序了
/**
* Created by asus on 2019/11/11.
*/
//希尔排序就是插入排序的进阶
//希尔排序思路，判断数组之间的合适间隔，取值，不断缩小间隔
//数组a的元素8,9,1，7，2,3,5,4,6,0
//通过计算间隔a.length/2得到是5,
//分成不同的小组8,3 9,5 1,4 7,6 2，0，虽然进行了分组，但是在原数组的位置是不变的
//通过对小组进行插入排序3,5,1,6,0,8,9,4,7,2
//再将间隔数/2 = 2，重复上面操作，直到间隔为1时，对整个数组进行插入操作，就排好序了
public class Xierpaixu {
public static void main(String[] args) {
int[] a = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0,34,11,56,224,15};
a = sort(a);
for (int b : a) {
System.out.print(b + "\t");
}
}
public static int[] sort(int[] a) {
//计算间隔量，也就是增量
int b = a.length / 2;
//将每次的间隔量缩短到原来的一半
for (int i = b; i > 0; i /= 2) {
for (int j = 0; j < i; j++) {
//这里就将得到的数组进行插入排序
//a为原数组，j为每个数组的第一个元素，i为间隔
insert(a, j, i);
}
}
return a;
}
//进行插入排序
public static void insert(int[] a, int j, int i) {
//a为原数组，j为每个数组的第一个元素，i为间隔
//获取第一个元素，都是从第二个元素开始
for (int b = j + i; b < a.length; b += i) {
for (int c = b; c > j; c -= i) {
if (a[c] < a[c - i]) {
int tem = a[c];
a[c] = a[c - i];
a[c - i] = tem;
}
}
}
}
}
4.二叉树的前中后序遍历
也就是一开始就被遍历就是前序，左，根，右就是中序，左，右，根就是后序
/**
* Created by asus on 2019/11/7.
*/
public class Erchashuentity {
//传入的数据
int data;
//左节点
Erchashuentity left;
Erchashuentity right;
public Erchashuentity(int d) {
this.data = d;
}
public Erchashuentity(int d, Erchashuentity left, Erchashuentity right) {
this.data = d;
this.left = left;
this.right = right;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public Erchashuentity getLeft() {
return left;
}
public void setLeft(Erchashuentity left) {
this.left = left;
}
public Erchashuentity getRight() {
return right;
}
public void setRight(Erchashuentity right) {
this.right = right;
}
}
import java.util.LinkedList;
import java.util.Queue;
/**
* Created by asus on 2019/11/7.
*/
//二叉树的广度优先遍历和深度优先遍历，所谓的广度优先遍历也就是横向遍历，从1 ,2,3,4,5,6,7
//广度优先遍历使用队列，先进先出的方式进行
//深度优先遍历：主要就是二叉树的先序，中序和后序遍历，先，中，后是根据根节点来算的
//第一个遍历根节点就是先序，第二个就是中序，第三个就是后序
/** 1
* 树： 2 3
* 4 5 6 7
*/
public class Erchashuimpl {
public static void main(String[] args) {
//设置树的数据
Erchashuentity root = new Erchashuentity(1);
Erchashuentity second = new Erchashuentity(2);
Erchashuentity three = new Erchashuentity(3);
Erchashuentity four = new Erchashuentity(4);
Erchashuentity five = new Erchashuentity(5);
Erchashuentity six = new Erchashuentity(6);
Erchashuentity seven = new Erchashuentity(7);
root.setLeft(second);
root.setRight(three);
second.setLeft(four);
second.setRight(five);
three.setLeft(six);
three.setRight(seven);
//广度优先遍历
System.out.println("======广度优先遍历=======");
new Erchashuimpl().width(root);
System.out.println();
System.out.println("======前序遍历=======");
new Erchashuimpl().pre(root);
System.out.println();
System.out.println("======中序遍历=======");
new Erchashuimpl().mid(root);
System.out.println();
System.out.println("======后序遍历=======");
new Erchashuimpl().after(root);
}
public void width(Erchashuentity root)
{
//这里传入了树，我们需要先对树做判断
if(root==null)
{
return;
}
//使用队列进行储存
Queue<Erchashuentity> queue = new LinkedList<Erchashuentity>();
queue.add(root);
//对队列进行判断,如果队列不为空就进行循环
while(!queue.isEmpty())
{
//返回并移除第一个元素
Erchashuentity node = queue.poll();
System.out.print(node.getData()+"\t");
if(node.getLeft()!=null)
{
queue.add(node.getLeft());
}
if(node.getRight()!=null)
{
queue.add(node.getRight());
}
}
}
//先序遍历
public void pre(Erchashuentity root)
{
if(root!=null) {
System.out.print(root.getData()+"\t");
}
if(root.getLeft()!=null)
{
pre(root.getLeft());
}
if(root.getRight()!=null)
{
pre(root.getRight());
}
}
//中序遍历
public void mid(Erchashuentity root){
if(root==null)
{
return;
}
if(root.getLeft()!=null)
{
mid(root.getLeft());
}
System.out.print(root.getData()+"\t");
if(root.getRight()!=null){
mid(root.getRight());
}
}
//后序遍历
public void after(Erchashuentity root){
if(root==null)
{
return;
}
if(root.getLeft()!=null)
{
after(root.getLeft());
}
if(root.getRight()!=null){
after(root.getRight());
}
System.out.print(root.getData()+"\t");
}
}
640
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
