Java冒泡排序,插入排序,选择排序
2016-12-12 16:53
495 查看
冒泡排序:
[java]
view plain
copy
print?
package com.zyg.test.sort;
//博客:http://blog.csdn.net/m_changgong
public class BubbleSort {
public static void main(String[] args) {
int[] array = {10,5,7,12};
System.out.print("排序前;");
printArray(array);
bubbleAscSort(array);
bubbleDescSort(array);
}
/**
* 冒泡升序排序
* @param array
*/
public static void bubbleAscSort(int[] array){
int length = array.length;
int temp=0;
for(int i=0;i<length-1;i++){
for(int j=0;j<length-i-1;j++){
if(array[j+1]<array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
/**
* 冒泡降序排序
* @param array
*/
public static void bubbleDescSort(int[] array){
int length = array.length;
int temp=0;
for(int i=0;i<length-1;i++){
for(int j=0;j<length-i-1;j++){
if(array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println();
System.out.print("降序排序后;");
printArray(array);
}
public static void printArray(int[] array){
int length = array.length;
for(int i=0;i<length;i++){
System.out.print(array[i]);
if(i!=length-1){
System.out.print(",");
}
}
}
}
插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间
[java]
view plain
copy
print?
package com.zyg.test.sort;
public class InsertSort {
public static void main(String[] args) {
int[] array = {2,3,1,8,6};
System.out.print("排序前;");
printArray(array);
insertAscSort(array);
insertDescSort(array);
}
/**
* 插入升序排序
* @param array
*/
public static void insertAscSort(int[] array){
int length = array.length;
for(int out = 1;out<length;out++){
int temp = array[out];
int in = out;
while(in>0 && array[in-1]>temp){
array[in] = array[in-1];
--in;
}
array[in]=temp;
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
/**
* 插入降序排序
* @param array
*/
public static void insertDescSort(int[] array){
int length = array.length;
for(int out = 1;out<length;out++){
int temp = array[out];
int in = out;
while(in>0 && array[in-1]<temp){
array[in] = array[in-1];
--in;
}
array[in]=temp;
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
public static void printArray(int[] array){
int length = array.length;
for(int i=0;i<length;i++){
System.out.print(array[i]);
if(i!=length-1){
System.out.print(",");
}
}
}
}
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
[java]
view plain
copy
print?
package com.zyg.test.sort;
public class SelectSort {
public static void main(String[] args) {
int[] array = {23,10,7,12,5,1};
System.out.print("排序前;");
printArray(array);
selectAscSort(array);
selectDescSort(array);
}
/**
* 选择升序排序
* @param array
*/
public static void selectAscSort(int[] array){
int length = array.length;
int min = array[0];
int minIdx = 0;
for(int i=0;i<length-1;i++){
for(int j=i+1;j<length;j++){
if(array[j]<min){//将比较符号改为>即是降序排序算法
min = array[j];
minIdx = j;
}
}
array[minIdx]= array[i];
array[i] = min;
//重置min、minIdx值
min = array[i+1];
minIdx = i+1;
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
/**
* 选择降序排序
* @param array
*/
public static void selectDescSort(int[] array){
int length = array.length;
int max = array[0];
int maxIdx = 0;
for(int i=0;i<length-1;i++){
for(int j=i;j<length;j++){
if(array[j]>max){//将比较符号改为<即是升序排序算法
max = array[j];
maxIdx = j;
}
}
array[maxIdx]= array[i];
array[i] = max;
//重置max、maxIdx值
max = array[i+1];
maxIdx = i+1;
}
System.out.println();
System.out.print("降序排序后;");
printArray(array);
}
public static void printArray(int[] array){
int length = array.length;
for(int i=0;i<length;i++){
System.out.print(array[i]);
if(i!=length-1){
System.out.print(",");
}
}
}
}
[java]
view plain
copy
print?
package com.zyg.test.sort;
//博客:http://blog.csdn.net/m_changgong
public class BubbleSort {
public static void main(String[] args) {
int[] array = {10,5,7,12};
System.out.print("排序前;");
printArray(array);
bubbleAscSort(array);
bubbleDescSort(array);
}
/**
* 冒泡升序排序
* @param array
*/
public static void bubbleAscSort(int[] array){
int length = array.length;
int temp=0;
for(int i=0;i<length-1;i++){
for(int j=0;j<length-i-1;j++){
if(array[j+1]<array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
/**
* 冒泡降序排序
* @param array
*/
public static void bubbleDescSort(int[] array){
int length = array.length;
int temp=0;
for(int i=0;i<length-1;i++){
for(int j=0;j<length-i-1;j++){
if(array[j+1]>array[j]){
temp = array[j];
array[j] = array[j+1];
array[j+1] = temp;
}
}
}
System.out.println();
System.out.print("降序排序后;");
printArray(array);
}
public static void printArray(int[] array){
int length = array.length;
for(int i=0;i<length;i++){
System.out.print(array[i]);
if(i!=length-1){
System.out.print(",");
}
}
}
}
package com.zyg.test.sort; //博客:http://blog.csdn.net/m_changgong public class BubbleSort { public static void main(String[] args) { int[] array = {10,5,7,12}; System.out.print("排序前;"); printArray(array); bubbleAscSort(array); bubbleDescSort(array); } /** * 冒泡升序排序 * @param array */ public static void bubbleAscSort(int[] array){ int length = array.length; int temp=0; for(int i=0;i<length-1;i++){ for(int j=0;j<length-i-1;j++){ if(array[j+1]<array[j]){ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } System.out.println(); System.out.print("升序排序后;"); printArray(array); } /** * 冒泡降序排序 * @param array */ public static void bubbleDescSort(int[] array){ int length = array.length; int temp=0; for(int i=0;i<length-1;i++){ for(int j=0;j<length-i-1;j++){ if(array[j+1]>array[j]){ temp = array[j]; array[j] = array[j+1]; array[j+1] = temp; } } } System.out.println(); System.out.print("降序排序后;"); printArray(array); } public static void printArray(int[] array){ int length = array.length; for(int i=0;i<length;i++){ System.out.print(array[i]); if(i!=length-1){ System.out.print(","); } } } }
插入排序(Insertion Sort)的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。插入排序在实现上,通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间
[java]
view plain
copy
print?
package com.zyg.test.sort;
public class InsertSort {
public static void main(String[] args) {
int[] array = {2,3,1,8,6};
System.out.print("排序前;");
printArray(array);
insertAscSort(array);
insertDescSort(array);
}
/**
* 插入升序排序
* @param array
*/
public static void insertAscSort(int[] array){
int length = array.length;
for(int out = 1;out<length;out++){
int temp = array[out];
int in = out;
while(in>0 && array[in-1]>temp){
array[in] = array[in-1];
--in;
}
array[in]=temp;
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
/**
* 插入降序排序
* @param array
*/
public static void insertDescSort(int[] array){
int length = array.length;
for(int out = 1;out<length;out++){
int temp = array[out];
int in = out;
while(in>0 && array[in-1]<temp){
array[in] = array[in-1];
--in;
}
array[in]=temp;
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
public static void printArray(int[] array){
int length = array.length;
for(int i=0;i<length;i++){
System.out.print(array[i]);
if(i!=length-1){
System.out.print(",");
}
}
}
}
package com.zyg.test.sort; public class InsertSort { public static void main(String[] args) { int[] array = {2,3,1,8,6}; System.out.print("排序前;"); printArray(array); insertAscSort(array); insertDescSort(array); } /** * 插入升序排序 * @param array */ public static void insertAscSort(int[] array){ int length = array.length; for(int out = 1;out<length;out++){ int temp = array[out]; int in = out; while(in>0 && array[in-1]>temp){ array[in] = array[in-1]; --in; } array[in]=temp; } System.out.println(); System.out.print("升序排序后;"); printArray(array); } /** * 插入降序排序 * @param array */ public static void insertDescSort(int[] array){ int length = array.length; for(int out = 1;out<length;out++){ int temp = array[out]; int in = out; while(in>0 && array[in-1]<temp){ array[in] = array[in-1]; --in; } array[in]=temp; } System.out.println(); System.out.print("升序排序后;"); printArray(array); } public static void printArray(int[] array){ int length = array.length; for(int i=0;i<length;i++){ System.out.print(array[i]); if(i!=length-1){ System.out.print(","); } } } }
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。以此类推,直到所有元素均排序完毕。
[java]
view plain
copy
print?
package com.zyg.test.sort;
public class SelectSort {
public static void main(String[] args) {
int[] array = {23,10,7,12,5,1};
System.out.print("排序前;");
printArray(array);
selectAscSort(array);
selectDescSort(array);
}
/**
* 选择升序排序
* @param array
*/
public static void selectAscSort(int[] array){
int length = array.length;
int min = array[0];
int minIdx = 0;
for(int i=0;i<length-1;i++){
for(int j=i+1;j<length;j++){
if(array[j]<min){//将比较符号改为>即是降序排序算法
min = array[j];
minIdx = j;
}
}
array[minIdx]= array[i];
array[i] = min;
//重置min、minIdx值
min = array[i+1];
minIdx = i+1;
}
System.out.println();
System.out.print("升序排序后;");
printArray(array);
}
/**
* 选择降序排序
* @param array
*/
public static void selectDescSort(int[] array){
int length = array.length;
int max = array[0];
int maxIdx = 0;
for(int i=0;i<length-1;i++){
for(int j=i;j<length;j++){
if(array[j]>max){//将比较符号改为<即是升序排序算法
max = array[j];
maxIdx = j;
}
}
array[maxIdx]= array[i];
array[i] = max;
//重置max、maxIdx值
max = array[i+1];
maxIdx = i+1;
}
System.out.println();
System.out.print("降序排序后;");
printArray(array);
}
public static void printArray(int[] array){
int length = array.length;
for(int i=0;i<length;i++){
System.out.print(array[i]);
if(i!=length-1){
System.out.print(",");
}
}
}
}
package com.zyg.test.sort; public class SelectSort { public static void main(String[] args) { int[] array = {23,10,7,12,5,1}; System.out.print("排序前;"); printArray(array); selectAscSort(array); selectDescSort(array); } /** * 选择升序排序 * @param array */ public static void selectAscSort(int[] array){ int length = array.length; int min = array[0]; int minIdx = 0; for(int i=0;i<length-1;i++){ for(int j=i+1;j<length;j++){ if(array[j]<min){//将比较符号改为>即是降序排序算法 min = array[j]; minIdx = j; } } array[minIdx]= array[i]; array[i] = min; //重置min、minIdx值 min = array[i+1]; minIdx = i+1; } System.out.println(); System.out.print("升序排序后;"); printArray(array); } /** * 选择降序排序 * @param array */ public static void selectDescSort(int[] array){ int length = array.length; int max = array[0]; int maxIdx = 0; for(int i=0;i<length-1;i++){ for(int j=i;j<length;j++){ if(array[j]>max){//将比较符号改为<即是升序排序算法 max = array[j]; maxIdx = j; } } array[maxIdx]= array[i]; array[i] = max; //重置max、maxIdx值 max = array[i+1]; maxIdx = i+1; } System.out.println(); System.out.print("降序排序后;"); printArray(array); } public static void printArray(int[] array){ int length = array.length; for(int i=0;i<length;i++){ System.out.print(array[i]); if(i!=length-1){ System.out.print(","); } } } }
相关文章推荐
- Java冒泡排序,选择排序,插入排序,希尔排序
- java冒泡排序,选择排序,插入排序
- Java冒泡排序、插入排序、选择排序、shell排序
- Java冒泡排序,插入排序,选择排序
- 排序的四种写法包括(冒泡排序,选择排序,插入排序,希尔排序)
- 选择排序和插入排序(Java实现)
- 八大排序方法汇总(选择排序,插入排序-简单插入排序、shell排序,交换排序-冒泡排序、快速排序、堆排序,归并排序,计数排序)
- 常见的排序算法示例(2)-选择排序、插入排序、希尔排序
- c 插入排序,选择排序,冒泡排序,归并排序
- python开发之路Day17-算法设计(冒泡排序、选择排序、插入排序、二叉树)
- 直通BAT-排序1(冒泡排序、选择排序、插入排序、归并排序、快速排序、堆排序、希尔排序)
- 排序算法(插入排序、shell排序、冒泡排序、选择排序、合并排序、堆排序、快速排序、计数排序、基数排序、桶排序)
- 第二章 简单排序算法--插入排序,冒泡排序,选择排序
- C#的四种排序算法:冒泡排序、选择排序、插入排序和希尔排序
- 冒泡排序,快速排序,归并排序,选择排序,插入排序,堆排序
- 选择排序、快速排序、希尔排序、堆排序不是稳定的排序算法,而冒泡排序、插入排序、归并排序和基数排序是稳定的排序算法。
- 算法系列(二)冒泡排序、选择排序、插入排序和希尔排序(Java实现)
- C语言常用的几种排序算法代码(选择排序,冒泡排序,插入排序,快速排序)
- PHP四种基础算法详解(冒泡排序、选择排序、插入排序、快速排序)
- 冒泡排序,选择排序,插入排序,快速排序的比较及优化