排序算法

冒泡排序算法



Java代码
/** 
* 冒泡排序是最简单的排序算法之一。此算法具有二次方程增长阶， 
* 因此仅适合排序小列表。 
* 冒泡排序算法是阶O(n^2)的算法 
*/ 
 
package com.szy.structure.sort;  
 
public class BubbleSort  
{  
    public static void main(String[] args)  
    {  
        int[] array=new int[]{10,-2,30,22,1,2,5,4,3,20};  
        System.out.println("排序前：");  
        for (int i : array)  
        {  
            System.out.print(i+"  ");  
        }  
 
        for (int i = 1; i < array.length; i++)  
        {  
            for (int j = 0; j < array.length-i; j++)  
            {  
                if (array[j]>array[j+1])  
                {  
                    int temp=0;  
                    temp=array[j];  
                    array[j]=array[j+1];  
                    array[j+1]=temp;  
                }  
            }  
        }  
          
        System.out.println("\n排序后：");  
        for (int i : array)  
        {  
            System.out.print(i+"  ");  
        }  
    }  
} 

/**
* 冒泡排序是最简单的排序算法之一。此算法具有二次方程增长阶，
* 因此仅适合排序小列表。
* 冒泡排序算法是阶O(n^2)的算法
*/

package com.szy.structure.sort;

public class BubbleSort
{
public static void main(String[] args)
{
int[] array=new int[]{10,-2,30,22,1,2,5,4,3,20};
System.out.println("排序前：");
for (int i : array)
{
System.out.print(i+"  ");
}

for (int i = 1; i < array.length; i++)
{
for (int j = 0; j < array.length-i; j++)
{
if (array[j]>array[j+1])
{
int temp=0;
temp=array[j];
array[j]=array[j+1];
array[j+1]=temp;
}
}
}

System.out.println("\n排序后：");
for (int i : array)
{
System.out.print(i+"  ");
}
}
}


选择排序算法：



Java代码
/** 
* 选择排序是一个简单的排序算法，选择排序具有二次方程增长阶， 
* 因此仅使用与排序小的列表 
* 选择排序算法是阶O(n^2)的算法 
*/ 
package com.szy.structure.sort;  
 
public class SelectionSort  
{  
 
    public static void main(String[] args)  
    {  
        int[] array=new int[]{10,-2,30,22,1,2,5,4,3,20};  
        System.out.println("排序前：");  
        for (int i : array)  
        {  
            System.out.print(i+"  ");  
        }  
          
        for (int i = 0; i < array.length-1; i++)  
        {  
            int min_index=i;  
            for (int j = i+1; j < array.length; j++)  
            {  
                if (array[min_index]>array[j])  
                {  
                    min_index=j;  
                }  
            }  
            int temp=array[i];  
            array[i]=array[min_index];  
            array[min_index]=temp;  
        }  
 
        System.out.println("\n排序后：");  
        for (int i : array)  
        {  
            System.out.print(i+"  ");  
        }  
    }  
 
} 

/**
* 选择排序是一个简单的排序算法，选择排序具有二次方程增长阶，
* 因此仅使用与排序小的列表
* 选择排序算法是阶O(n^2)的算法
*/
package com.szy.structure.sort;

public class SelectionSort
{

public static void main(String[] args)
{
int[] array=new int[]{10,-2,30,22,1,2,5,4,3,20};
System.out.println("排序前：");
for (int i : array)
{
System.out.print(i+"  ");
}

for (int i = 0; i < array.length-1; i++)
{
int min_index=i;
for (int j = i+1; j < array.length; j++)
{
if (array[min_index]>array[j])
{
min_index=j;
}
}
int temp=array[i];
array[i]=array[min_index];
array[min_index]=temp;
}

System.out.println("\n排序后：");
for (int i : array)
{
System.out.print(i+"  ");
}
}

}




插入排序算法：



Java代码
/** 
  * 插入排序具有二次方程增长阶，因此仅用于排序小列表。 
  * 但是如果需要排序的列表几乎已经排序，则插入排序比冒泡排序 
  * 和选择排序更有效率。 
  * 插入排序最佳用例效率是O(n)阶 
* 插入排序最糟用例效率是O(n^2)阶 
*/ 
package com.szy.structure.sort;  
 
public class InsertionSort  
{  
 
    public static void main(String[] args)  
    {  
        int[] array=new int[]{10,-2,30,22,1,2,5,4,3,20};  
        System.out.println("排序前：");  
        for (int i : array)  
        {  
            System.out.print(i+"  ");  
        }  
          
        for (int i = 1; i < array.length; i++)  
        {  
            int number=array[i];  
            for (int j = 0; j <i; j++)  
            {  
                if (number<array[j])  
                {  
                    for (int k = i; k >j; k--)  
                    {  
                        array[k]=array[k-1];  
                    }  
                    array[j]=number;  
                    break;  
                }  
            }  
        }  
          
        System.out.println("\n排序后：");  
        for (int i : array)  
        {  
            System.out.print(i+"  ");  
        }  
 
    }  
 
} 

]
Java代码
/** 
* 线性搜索 
*/ 
package com.szy.structure.search;  
 
import java.util.Scanner;  
 
public class SequentialSearch  
{  
    public static void main(String[] args)  
    {  
        int number[]={10,-2,30,22,1,2,5,4,3,20};  
        Scanner scanner=new Scanner(System.in);  
        System.out.println("Input the number you want to search:");  
        int input=scanner.nextInt();  //不考虑输入的内容是否合法  
        //线性查找  
        for (int i = 0; i < number.length; i++)  
        {  
            if(number[i]==input)  
            {  
                System.out.println(input+" was found at the position of "+(i+1));  
                break;  
            }  
        }  
        System.out.println("The number you input wasn't in the array");  
    }  
} 

/**
* 线性搜索
*/
package com.szy.structure.search;

import java.util.Scanner;

public class SequentialSearch
{
public static void main(String[] args)
{
int number[]={10,-2,30,22,1,2,5,4,3,20};
Scanner scanner=new Scanner(System.in);
System.out.println("Input the number you want to search:");
int input=scanner.nextInt();  //不考虑输入的内容是否合法
//线性查找
for (int i = 0; i < number.length; i++)
{
if(number[i]==input)
{
System.out.println(input+" was found at the position of "+(i+1));
break;
}
}
System.out.println("The number you input wasn't in the array");
}
}