1.快速排序
package com.zyh.sort;
/**
- 应用的分治思想，空间复杂度为O(log2n)，随机找出一个数，可以随机取，也可以取固定位置，
- 一般是取第一个或最后一个称为基准，然后就是比基准小的在左边，比基准大的放到右边，如何放做，
- 就是和基准进行交换，这样交换完左边都是比基准小的，右边都是比较基准大的，这样就将一个数组分成了两个子数组，
- 然后再按照同样的方法把子数组再分成更小的子数组，直到不能分解为止。
- @author 实现
*/
public class QuickSort {
public static void main(String[] args) {
int a [] = {6,1,2,7,9,3,4,5,10,8};
quickSort(a, 0, 9);
for(int i = 0;i<a.length;i++){
System.out.println(a[i]);
}
}
public static void quickSort(int a[],int left,int right){
int i,j,temp,t;
if(left>right)
return;
temp = a[left];
i=left;
j=right;
while(i!=j){
while(temp<=a[j]&&i<j)
{
j--;
}
while(temp>=a[i]&&i<j)
{
i++;
}
if(i<j)
{ t=a[j];
a[j]=a[i];
a[i]=t;
}
}
a[left]=a[i];
a[i]=temp;
quickSort(a,left,i-1);
quickSort(a,i+1,right);
}
}
2.直接插入排序
package com.zyh.sort;
import java.util.Arrays;
/**
- 直接插入排序
- 直接插入排序的时间复杂度为 o(n^2)
- 直接插入排序是一种稳定的排序方法
- 直接插入排序就可以看作在一个只有一个元素的数组中插入数据，
- 每一次插入都插入到合适位置。插入时前面的序列已经有序，让
- 我们来模拟一下直接插入排序的方法
- @author 实现
*/
public class InsertSort {
public static void main(String[] args) {
int a [] = {3,2,4,7,5,8,6,9};
insertSort(a);
System.out.println(Arrays.toString(a));
}
public static void insertSort(int a[]){
for(int i=1;i<a.length;i++){
if(a[i]<a[i-1]){
int p = i; // 用于记录比较过程中那个空缺出来的位置
int t = a[i]; // 设置哨兵，将当前下标对应的值赋给哨兵
for(int j = i-1;j>=0&&a[j]>t;j--){
p = j;
a[j+1]=a[j];
}
a[p] = t; // 将哨兵，也就是当前下标对应的值置入空缺出来的位置
}
}
}
}
3.冒泡排序
package com.zyh.sort;
import java.util.Arrays;
/**
*冒泡排序
*冒泡排序是稳定的,时间复杂度为o(n^2)
*
- @author 实现
*/
public class MaoSort {
public static void main(String[] args) {
int a [] = {3,2,4,7,5,8,6,9};
maoSort(a);
System.out.println(Arrays.toString(a));
}
public static void maoSort(int a[]){
int t = 0;
for(int i = 0;i<a.length;i++){
for(int j=i;j<a.length-1;j++){
if(a[j+1]<a[j]){
t = a[j+1];
a[j+1] = a[j];
a[j] = t;
}
}
}
}
}
4.直接选择排序
package com.zyh.sort;
import java.util.Arrays;
/**
- 直接选择排序
- 不稳定，时间复杂度o(n^2)
- @author 实现
*/
public class SelectSort {
public static void main(String[] args) {
int a [] ={3,2,4,7,5,8,6,9};
selectSort(a);
System.out.println(Arrays.toString(a));
}
public static void selectSort(int a[]){
int t;
for(int i = 0;i<a.length-1;i++){
for(int j=i+1;j<a.length;j++){
if(a[i]>a[j]){
t = a[j];
a[j] = a[i];
a[i] = t;
}
}
}
}
}
5.堆排序
package com.zyh.sort;
import java.util.Arrays;
/**
- 堆排序
- 时间复杂度O(nlogn),且不稳定
- 首先将数组元素建成大小为n的大顶堆，堆顶（数组第一个元素）是所有元素中的最大值，
- 将堆顶元素和数组最后一个元素进行交换，再将除了最后一个数的n-1个元素 建立成大
- 顶堆，再将最大元素和数组倒数第二个元素进行交换，重复直至堆大小减为1。
- @author 实现
*/
public class DuiSort {
public static void main(String[] args) {
int a[]={3,2,5,6,8,4,7,9,1,0};
int len = a.length;
duiSort(a, len);
System.out.println(Arrays.toString(a));
}
public static void tiaoZheng(int a[],int i,int len){
int j = i*2+1;
int t = 0;
while(j < len)
{
if(j+1<len && a[j] < a[j+1]) //建立大堆,若左孩子小于右孩子,将j取值为右孩子的下标,右孩子再与父结点比较
{
j++;
}
//将左右孩子中，数值最大的与父结点进行比较,若孩子结点比父结点小,说明父结点的数值比左右孩子都大,不需要交换
if(a[i] > a[j])
{
break;//说明该父结点和其孩子结点调整结束，退出循环，从下一个父结点调整
}
t = a[i];
a[i] = a[j];
a[j] = t;
//交换之后还要考虑该目前j结点与自己的孩子结点的数值比较，还要进行调整,将i当前结点换成j结点所在位置，向下跑
i = j;
j = 2*i+1;
}
}
public static void duiSort(int a[],int len){
int i = 0;
int t =0;
int j = 0;
for(i=len/2-1; i>=0; i--)//要从最后一个父节点开始调整堆
{
tiaoZheng(a, i, len);
}
//初次堆调整完成
//每次排出最大的一个元素之后，将该元素排除在堆外,调整堆后交换堆顶元素和堆的最后一个元素
for(j=len-1; j>=0; j--)//所以要从元素最后一个开始
{
t = a[j];
a[j] = a[0];
a[0] = t;
/*交换好堆后,重新调整堆*/
tiaoZheng(a, 0, j);
}
}
}
6.希尔排序
package com.zyh.sort;
import java.util.Arrays;
/**
- 希尔排序
- 先将整个待排序记录分割为若干个子序列分别插入排序，待整个序列中的记录基本有序时，
- 再对全体记录进行一次插入排序。
- 不稳定的
- @author 实现
*/
public class ShellSort {
public static void main(String[] args) {
int a [] ={3,2,4,7,5,8,6,9};
shellSort(a);
System.out.println(Arrays.toString(a));
}
public static void shellSort(int a[]){
int h = 1;
//计算最大间隔
while(h<a.length/3){
h=h*3+1;
}
//进行希尔排序
while(h>0){
int tem = 0;
for(int i =h;i<a.length;i++){
tem = a[i];
int j = i;
while(j>h-1&&a[j-h]>=tem){
a[j] = a[j-h];
j-=h;
}
a[j] = tem;
}
//减小间隔
h = (h-1)/3;
}
}
}
7.归并排序
package com.zyh.sort;
/**
- 归并排序
- 应用的是分治思想，时间复杂度是O(N*lgN)，归并排序的形式就是一棵二叉树，它需要遍历的次数就是二叉树的深度
- 算法稳定性 – 假设在数列中存在a[i]=a[j]，若在排序之前，a[i]在a[j]前面；并且排序之后，a[i]仍然在a[j]前面。则这个排序算法是稳定的！
- @author 实现
*/
public class MergeSort {
public static void main(String[] args) {
int a[]={3,2,5,8,6,7,4};
int x=7;
int temp []={0,0,0,0,0,0,0};
mergeSort(a,0,6,temp);
//printf("1");
for(int i=0;i<x;i++)
System.out.println(a[i]);
//printf("7");
}
public static void mergeSort(int a[],int first, int last,int temp[])
{
if(first<last)
{
int mid = (first+last)/2;
mergeSort(a,first,mid,temp);
mergeSort(a,mid+1,last,temp);
mergeArray(a, first, mid, last, temp);
}
}
public static void mergeArray(int a[], int first, int mid, int last, int temp[])
{
int i=first,j=mid;
int m=mid+1,n=last;
int k=0;
// printf("5");
while(i<=j&&m<=n)
{
if(a[i]<a[m])
temp[k++] = a[i++];
else
temp[k++] = a[m++];
}
//printf("6");
while(i<=j)
temp[k++] = a[i++];
while(m<=n)
temp[k++] = a[m++];
//整合到a数组
for (i = 0; i < k; i++)
a[first + i] = temp[i];
}
}
扫一扫
283
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
