1.冒泡排序:

(1)比较相邻的元素。如果第一个比第二个大,就交换他们两个。

  (2)外面再套个循环就行。

算法复杂度:O(N2)   不罗嗦,上代码:

	//冒泡排序(两两交换,外加一个外循环)
public static void bubbleSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=0;i<len-1;i++){
for (j=1;j<len-i;j++){
if (sortData[j-1] > sortData[j]){
swap(sortData,j-1,j);
}
}
}
}

  

2. 选择排序

    (1)每次从剩下无序中选择最小的元素,进行交换

        算法复杂度:O(N2)   不罗嗦,上代码:  

    //选择排序(从剩下的选最大的交换)
public static void selectionSort(int sortData[]){
int i,j,min,index,temp;
int len = sortData.length;
for (i=0;i<len;i++){
min = sortData[i];
index = i;
for (j=i+1;j<len;j++){
if (sortData[j] < min){
min = sortData[j];
index = j;
}
}
swap(sortData,i,index);
}
}

3.插入排序:

(1)基本操作就是将一个数据插入到已经排好序的有序数据中:

	//插入排序,把大的往后移动
public static void insertSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=1;i<len;i++){
temp = sortData[i];
for (j = i-1;j>=0 && temp < sortData[j];j--){
sortData[j+1] = sortData[j];
}
sortData[j+1] = temp;
}
}

  

3.希尔排序:

是插入排序的改进版,主要是希尔通过引入增量,加强了插入排序的威力。随着增量的减少,就有序了。

    //希尔排序
public static void shellSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
int gap = len/2;
while(gap>=1){
for (i=gap;i<len;i++){
temp = sortData[i];
for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){
sortData[j+gap] = sortData[j];
}
sortData[j+gap] = temp;
}
gap = gap/2;
}
}

4.堆排序

(1)初始堆  (2)adjust到最小堆或最大堆的格式 (3)排序,根位置和最后一个位置换一下位置,再adjust。

利用最大堆,最小堆这一特性,使得每次从无序的列表中选择最大或者最小的数据。

其基本思想为(大顶堆):

1)将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆,此堆为初始的无序区;

2)将堆顶元素R[1]与最后一个元素R[n]交换,此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n];

3)由于交换后新的堆顶R[1]可能违反堆的性质,因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆,然后再次将R[1]与无序区最后一个元素交换,得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1,则整个排序过程完成。

  1)运行时间消耗:构建初始堆 和 重建堆的反复筛选上。

构建堆:

         每次从最下层的最右边的非终端节点构建,将他和期孩子节点进行比较,每次最多进行两次比较和交互,因此这个构建时间是N

重建堆(排序):

第i次取堆顶需要logi,那么要去n-1次,所以时间复杂度是nlogn

由于堆排序对原始记录的排序状态并不敏感,因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)。

2) 空间复杂度上,它只有一个用来交换的暂存单元,也算是非常的不错。不过由于记录的比较与交换是跳跃式进行,因此堆排序也是一种不稳定的排序方法。
        另外,由于初始构建堆所需的比较次数较多,因此,它并不适合待排序序列个数较少的情况。

public static void heapSort(int sortData []){
buildMaxHeap(sortData);
for(int i=sortData.length-1;i>=1;i--){
swap(sortData,0,i);
maxHeap(sortData,i,0);
}
} public static void buildMaxHeap(int sortData[]){
int half = sortData.length/2;
for(int i=half;i>=0;i--){
maxHeap(sortData,sortData.length,i);
}
} public static void maxHeap(int sortData[],int heapSize,int index){
int left = 2*index+1;
int right = 2*index+2;
int largest = index; if (left < heapSize && sortData[left]>sortData[index]){
largest = left;
}
if(right < heapSize && sortData[right]>sortData[largest]){
largest = right;
}
if (index != largest){
swap(sortData,index,largest);
maxHeap(sortData,heapSize,largest);
} }

  5.  快速排序:

其实是二分法,一般来说以第一个位置做为分界点,把小的放到这个分界点前面,大的放到后面。递归这两部分。

基本思想:选择一个基准元素,通常是选取第一个或者最后一个元素,通过一趟扫描,将待排序的序列分成两部分,一部分比基准元素小,一部分比基准元素大。此时基准元素就在排好序的正确位置。然后采用相同的方法,递归排序划分左右数据。

算法复杂度:平均和最好都是: nlog(n)  最坏情况(逆序): n2         不稳定

	//快速排序
public static void quickSort(int sortData[],int start,int end){
if (start >=end) return;
int i=start,j=end,value = sortData[i];
boolean flag = true;
while(i!=j){
if (flag){
if (value > sortData[j]){
swap(sortData,i,j);
flag=false;
}else{
j--;
}
}else{
if (value<sortData[i]){
swap(sortData,i,j);
flag=true;
}else{
i++;
}
}
}
//printValue(sortData);
quickSort(sortData,start,j-1);
quickSort(sortData,i+1,end);
}

c++

//快排
void qsort(int a[],int low,int high){
if (low >= high) return;
int first = low;
int last = high;
int key = a[first]; while(first<last){
while(first<last && a[last]>=key) --last;
a[first] = a[last];
while(first<last && a[first]<=key) ++first;
a[last] = a[first];
}
a[first] = key;
qsort(a,low,first-1);
qsort(a,first+1,high);
}

  

  

6  归并排序  c++

void merge(int array[],int low,int mid,int high){
int i = low;
int j = mid+1;
int k = 0;
int *array2 = new int [high-low+1];
while(i <= mid && j <= high){
if (array[i] < array[j]){
array2[k] = array[i];
i++;
k++;
}else{
array2[k] = array[j];
j++;
k++;
}
} while(i <= mid){
array2[k] = array[i];
k++;
i++;
}
while(j <= high){
array2[k] = array[j];
k++;
j++;
}
for(k=0,i=low;i<=high;i++,k++){
array[i] = array2[k];
} } void mergeSort(int a[],int low,int high){
if (low<high){
int mid = (low+high)/2;
mergeSort(a,low,mid);
mergeSort(a,mid+1,high);
merge(a,low,mid,high);
}
} int main(){ int arr [10] = {3,4,2,4,6,2,5,7,0,2};
int len;
ARR_LEN(arr,len);
mergeSort(arr,0,len-1);
for(auto x: arr){
cout << x << " ";
} }

  

所有可运行代码:

//gjs
public class sort { public static void printValue(int sortData[]){
for (int i = 0;i<sortData.length;i++){
System.out.print(sortData[i]+" ");
}
System.out.println();
} public static void swap(int [] data ,int pos1, int pos2){
int temp = data[pos1];
data[pos1] = data[pos2];
data[pos2] = temp;
}
//冒泡排序(两两交换,外加一个外循环)
public static void bubbleSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=0;i<len-1;i++){
for (j=1;j<len-i;j++){
if (sortData[j-1] > sortData[j]){
swap(sortData,j-1,j);
}
}
}
} //选择排序(从剩下的选最大的交换)
public static void selectionSort(int sortData[]){
int i,j,min,index,temp;
int len = sortData.length;
for (i=0;i<len;i++){
min = sortData[i];
index = i;
for (j=i+1;j<len;j++){
if (sortData[j] < min){
min = sortData[j];
index = j;
}
}
swap(sortData,i,index);
}
} //插入排序,把大的往后移动
public static void insertSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
for (i=1;i<len;i++){
temp = sortData[i];
for (j = i-1;j>=0 && temp < sortData[j];j--){
sortData[j+1] = sortData[j];
}
sortData[j+1] = temp;
}
} //希尔排序
public static void shellSort(int sortData[]){
int i,j,temp;
int len = sortData.length;
int gap = len/2;
while(gap>=1){
for (i=gap;i<len;i++){
temp = sortData[i];
for (j=i-gap;j>=0&&temp<sortData[j];j=j-gap){
sortData[j+gap] = sortData[j];
}
sortData[j+gap] = temp;
}
gap = gap/2;
}
} public static void heapSort(int sortData []){
buildMaxHeap(sortData);
for(int i=sortData.length-1;i>=1;i--){
swap(sortData,0,i);
maxHeap(sortData,i,0);
}
} public static void buildMaxHeap(int sortData[]){
int half = sortData.length/2;
for(int i=half;i>=0;i--){
maxHeap(sortData,sortData.length,i);
}
} public static void maxHeap(int sortData[],int heapSize,int index){
int left = 2*index+1;
int right = 2*index+2;
int largest = index; if (left < heapSize && sortData[left]>sortData[index]){
largest = left;
}
if(right < heapSize && sortData[right]>sortData[index]){
largest = right;
}
if (index != largest){
swap(sortData,index,largest);
maxHeap(sortData,heapSize,largest);
} } //快速排序
public static void quickSort(int sortData[],int start,int end){
if (start >=end) return;
int i=start,j=end,value = sortData[i];
boolean flag = true;
while(i!=j){
if (flag){
if (value > sortData[j]){
swap(sortData,i,j);
flag=false;
}else{
j--;
}
}else{
if (value<sortData[i]){
swap(sortData,i,j);
flag=true;
}else{
i++;
}
}
}
//printValue(sortData);
quickSort(sortData,start,j-1);
quickSort(sortData,i+1,end);
} public static void main(String[] args) {
int [] a={2,4,1,5,8,9,43,3,7,8,9,0,3};
printValue(a);
//bubbleSort(a);
//selectionSort(a);
//insertSort(a);
//heapSort(a);
//shellSort(a);
quickSort(a,0,a.length-1);
printValue(a); } }

基础排序算法,java实现(快速,冒泡,选择,堆排序,插入)的更多相关文章

  1. 6种基础排序算法java源码+图文解析[面试宝典]

    一.概述 作为一个合格的程序员,算法是必备技能,特此总结6大基础算法.java版强烈推荐<算法第四版>非常适合入手,所有算法网上可以找到源码下载. PS:本文讲解算法分三步:1.思想2.图 ...

  2. 十大基础排序算法[java源码+动静双图解析+性能分析]

    一.概述 作为一个合格的程序员,算法是必备技能,特此总结十大基础排序算法.java版源码实现,强烈推荐<算法第四版>非常适合入手,所有算法网上可以找到源码下载. PS:本文讲解算法分三步: ...

  3. Java基础系列--基础排序算法

    原创作品,可以转载,但是请标注出处地址:https://www.cnblogs.com/V1haoge/p/9082138.html 一.概述 基础排序算法包括:桶排序.冒泡排序.选择排序.插入排序等 ...

  4. Java面试宝典系列之基础排序算法

    本文就是介绍一些常见的排序算法.排序是一个非常常见的应用场景,很多时候,我们需要根据自己需要排序的数据类型,来自定义排序算法,但是,在这里,我们只介绍这些基础排序算法,包括:插入排序.选择排序.冒泡排 ...

  5. php四种基础排序算法的运行时间比较

    /** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排序法 ...

  6. php四种基础排序算法的运行时间比较!

    /** * php四种基础排序算法的运行时间比较 * @authors Jesse (jesse152@163.com) * @date 2016-08-11 07:12:14 */ //冒泡排序法 ...

  7. 038 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 05 案例演示switch结构-星期的表示案例以及总结

    038 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 05 案例演示switch结构-星期的表示案例以及总结 本文知识点:案例演示switch结构并对sw ...

  8. 037 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 04 switch结构

    037 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 04 switch结构 本文知识点:Java中的switch结构 选择结构分类 选择结构只有如下2种 ...

  9. 036 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 03 嵌套if结构

    036 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 03 嵌套if结构 本文知识点:Java中的嵌套if结构 什么是嵌套if结构? 概念: 嵌套if结构 ...

  10. 035 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 02 多重if结构

    035 01 Android 零基础入门 01 Java基础语法 04 Java流程控制之选择结构 02 多重if结构 本文知识点:Java中的多重if结构 选择结构回顾 if选择结构 注意: 1.条 ...

随机推荐

  1. Generic repository pattern and Unit of work with Entity framework

    原文 Generic repository pattern and Unit of work with Entity framework Repository pattern is an abstra ...

  2. pinyin4j

    最近在倒腾与搜索相关的拼音检查技术,顺便看了一下中文转拼音开源插件pinyin4j的源码,参考资料:http://blog.csdn.net/hfhwfw/archive/2010/11/23/603 ...

  3. The type sun.management.ManagementFactory is not visible

    Eclipse默认将这些受访问限制的API设成了Error.解决方法:只要将Windows---Preferences---Java--Complicer---Errors/Warings里面的Dep ...

  4. eclipse jetty插件安装(离线版)

    按照网上的说法安装jetty插件,run-jetty-run,google那个网址根本链接不上.所以插件装不上,网上搜索本地版,试了几个都不好使,功能不全,这是因为下载的本地资源jar包不全导致,好坑 ...

  5. Java泛型 通配符? extends与super

    Java 泛型 关键字说明 ? 通配符类型 <? extends T> 表示类型的上界,表示参数化类型的可能是T 或是 T的子类 <? super T> 表示类型下界(Java ...

  6. CY7C68013A的一点总结

    一. 值得参考的资料:FX2 TechRefManual.USB应用开发宝典. LabVIEW-USB通信简单教程(用于参考生成labview驱动程序).USB设备请求和描述符整理(仅用于理解描述符的 ...

  7. java6 新特新

    JAVA6新特性介绍   1. 使用JAXB来实现对象与XML之间的映射 JAXB是Java Architecture for XML Binding的缩写,可以将一个Java对象转变成为XML格式, ...

  8. HDU 1754 I Hate It (线段树 单点更新)

    题目链接 中文题意,与上题类似. #include <iostream> #include <cstdio> #include <cstring> #include ...

  9. jvm内部现成运行

    hi,all 最近抽时间把JVM运行过程中产生的一些线程进行了整理,主要是围绕着我们系统jstack生成的文件为参照依据.  前段时间因为系统代码问题,造成性能瓶颈,于是就dump了一份stack出来 ...

  10. Mybatis学习——一对多关联表查询

    1.实体类 public class Student { private int id; private String name; } public class Classes { private i ...