java代码测试---插入排序和选择排序

  1 public class QuickSort {
  2
  3     //插入排序
  4     //插入前的序列是排序好的,将新插入的数值与之前的数值比较
  5     //直到找到合适的位置
  6     public static int[] quickSort(int[] arr){
  7
  8         for(int j=1;j<arr.length;j++){
  9             int key = arr[j];
 10             int i = j-1;
 11
 12             while(i>=0 && arr[i]<key){
 13                 arr[i+1] = arr[i];
 14                 i = i -1;
 15                 arr[i+1] = key;
 16             }
 17         }
 18
 19         return arr;
 20     }
 21
 22     //查询一个值V是否在数组内,如果在数组内输出下标,否则输出‘NIL’
 23     public static String quickSortIn(int[] arr,int V){
 24         List<Integer> list = new ArrayList<Integer>();
 25         for(int i = 0;i<arr.length;i++){
 26             if(V == arr[i]){
 27                 list.add(i);//如果V在数组内,将下标存入list
 28             }
 29         }
 30
 31         if(list != null && !list.isEmpty()){//如果list不为空,循环输出
 32
 33             StringBuilder str = new StringBuilder("");
 34             for(int i = 0; i < list.size(); i++){
 35                 str.append("V = "+"arr["+list.get(i)+"]  ");
 36             }
 37             return str.toString();
 38
 39         }else{//如果list为空,输出‘NIL’
 40             return "NIL";
 41         }
 42     }
 43
 44     //选择排序
 45     public static void selectSort(int[] a) {
 46         int i;        // 有序区的末尾位置
 47         int j;        // 无序区的起始位置
 48         int min;    // 无序区中最小元素位置
 49
 50         for(i=0; i<a.length; i++) {
 51             min=i;
 52
 53             // 找出"a[i+1] ... a[n]"之间的最小元素,并赋值给min。
 54             for(j=i+1; j<a.length; j++) {
 55                 if(a[j] < a[min])
 56                     min=j;
 57             }
 58
 59             // 若min!=i,则交换 a[i] 和 a[min]。
 60             // 交换之后,保证了a[0] ... a[i] 之间的元素是有序的。
 61             if(min != i) {
 62                 int tmp = a[i];
 63                 a[i] = a[min];
 64                 a[min] = tmp;
 65             }
 66         }
 67     }
 68
 69     //查询数组的最大值
 70     public static int selectMax(int[] arr){
 71         int max = arr[0];
 72         for(int i =0;i<arr.length;i++){
 73             if(arr[i]>max){
 74                 max = arr[i];
 75             }
 76         }
 77         return max;
 78     }
 79
 80     //查询数组的最小值
 81     public static int selectMin(int[] arr){
 82         int min = arr[0];
 83         for(int i =0;i<arr.length;i++){
 84             if(arr[i]<min){
 85                 min = arr[i];
 86             }
 87         }
 88         return min;
 89     }
 90
 91
 92     public static void main(String[] args) {
 93         int[] aaa = {1,5,2,3,4,55,11,22,33,4,22,1};
 94         int[] bbb = {31,41,59,26,41,58};
 95         selectSort(bbb);
 96         for(int a : bbb){
 97             System.out.print(a+"  ");
 98         }
 99         System.out.println();
100         System.out.println(quickSortIn(bbb,41));
101         System.out.println(selectMin(bbb));
102     }
103 }
时间: 2024-10-23 10:35:50

java代码测试---插入排序和选择排序的相关文章

C# 插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序

下面列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 快速排序 堆排序 归并排序 基数排序 希尔排序,然后是测试的例子.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

Java再学习-算法之选择排序

 继上篇文章讲到插入排序和冒泡排序算法.这次来看一下选择排序.         和上两个循环一样,还是分成两套循环,外循环起指针作用,用来指定每次循环的元素值和元素序列,而内部循环则起到真正的快速排序逻辑.首先如果我们取到第i值,那么我们要与第i+1,i+2,....等元素进行对比,找到i元素后面最小的元素,与之交换位置即可,只不过这里的交换位置比较新颖,我们看下面的代码: package cn.tgb.sort; import java.util.Arrays; //选择排序 public c

java结构与算法之选择排序

一 .java结构与算法之选择排序 什么事选择排序:从一组无序数据中选择出中小的的值,将该值与无序区的最左边的的值进行交换. 简单的解释:假设有这样一组数据 12,4,23,5,找到最小值 4 放在最右边,然后找到 5 放在  4 的后面,重复该操作. 选择排序参考代码: public class ChooseSort { int[] array = null; @Test public void testPopSort() { array = new int[5]; array[0] = 45

C# 插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序

以下列出了数据结构与算法的八种基本排序:插入排序 冒泡排序 选择排序 高速排序 堆排序 归并排序 基数排序 希尔排序,然后是測试的样例.代码位置:http://download.csdn.net/detail/luozuolincool/8040027 排序类: public class Sortings { //插入排序 public void insertSort(int[] array) { int temp = 0; int index = 0; for (int i = 0; i <

排序(上):冒泡排序、插入排序和选择排序

如何分析一个排序算法? 分析一个排序算法的三要素:排序算法的执行效率.排序算法的内存消耗以及排序算法的稳定性. 排序算法的执行效率 对于排序算法执行效率的分析,一般是从以下三个方面来衡量: 最好情况.最坏情况.平均情况时间复杂度 时间复杂度的系数.常数.低阶 比较次数和交换(或移动)次数 第1.2点在之前的复杂度分析中我们已经讲过了,第3点会在这一节以及接下来的章节中详细讲解. 这一节和下一节讲的都是基于比较的排序算法.基于比较的排序算法的执行过程,会涉及两种操作,一种是元素比较大小,另一种是元

图形化排序算法比较:快速排序、插入排序、选择排序、冒泡排序

图形化排序算法比较:快速排序.插入排序.选择排序.冒泡排序

解决java代码测试http协议505错误

代码功能:通过java代码获取网页源代码: 所用工具:Myclipse8.5+tomcat6.0+浏览器 系统环境:windows xp旗舰版火狐浏览器版本: IE浏览器版本: 测试http协议有错误java代码如下. import java.io.BufferedReader; import java.io.InputStreamReader; import java.io.OutputStreamWriter; import java.io.PrintWriter; import java.

九种经典排序算法详解(冒泡排序,插入排序,选择排序,快速排序,归并排序,堆排序,计数排序,桶排序,基数排序)

综述 最近复习了各种排序算法,记录了一下学习总结和心得,希望对大家能有所帮助.本文介绍了冒泡排序.插入排序.选择排序.快速排序.归并排序.堆排序.计数排序.桶排序.基数排序9种经典的排序算法.针对每种排序算法分析了算法的主要思路,每个算法都附上了伪代码和C++实现. 算法分类 原地排序(in-place):没有使用辅助数据结构来存储中间结果的排序**算法. 非原地排序(not-in-place / out-of-place):使用了辅助数据结构来存储中间结果的排序算法 稳定排序:数列值(key)

java面向对象的冒泡排序,选择排序和插入排序的比较

这三种排序有俩个过程: 1.比较俩个数据. 2.交换俩个数据或复制其中一项. 这三种排序的时间级别 冒泡排序:比较 (N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2 交换  0——N2/2 = N2/4 总时间 3/4*N2 选择排序:比较 (N-1)+(N-2)+...+2+1 = N*(N-1)/2=N2/2 交换  0——3*(N-1)=3*(N-1)/2=3/2*N 总时间 N2/2+3/2*N 插入排序:第一轮最多比较一次,第二轮最多比较俩次,最后一轮比较N-1