选择、冒泡、插入、直接排序算法

  1 public class Demo {
  2
  3     public static void main(String[] args) {
  4         int[] arr = new int[10];
  5         for (int i = 0; i < arr.length; i++) {
  6             Random rd = new Random();
  7             arr[i] = rd.nextInt(100);
  8         }
  9         System.out.println("需排序数组-->");
 10         for (int j = 0; j < arr.length; j++) {
 11             System.out.print(arr[j] + "\t");
 12         }
 13         System.out.println();
 14         System.out.println();
 15
 16         //选择排序
 17         for (int i = 1; i < arr.length; i++) {
 18             int max = 0;
 19             for (int j = 0; j <= arr.length-i; j++) {
 20                 if(arr[j]>arr[max]){
 21                     max = j;
 22                 }
 23             }
 24             int temp = arr[arr.length-i];
 25             arr[arr.length-i] = arr[max];
 26             arr[max] = temp;
 27         }
 28         System.out.println("选择排序结果-->");
 29         for (int j = 0; j < arr.length; j++) {
 30             System.out.print(arr[j] + "\t");
 31         }
 32         System.out.println();
 33
 34         //冒泡排序
 35         for (int i = 1; i < arr.length; i++) {
 36             for (int j = 0; j < arr.length-1; j++) {
 37                 if (arr[j+1]<arr[j]) {
 38                     int temp = arr[j+1];
 39                     arr[j+1] = arr[j];
 40                     arr[j] = temp;
 41                 }
 42             }
 43         }
 44         System.out.println("冒泡排序结果-->");
 45         for (int j = 0; j < arr.length; j++) {
 46             System.out.print(arr[j] + "\t");
 47         }
 48         System.out.println();
 49
 50         //快速排序
 51         quickSort(arr, 0, arr.length-1);
 52         System.out.println("快速排序结果-->");
 53         for (int j = 0; j < arr.length; j++) {
 54             System.out.print(arr[j] + "\t");
 55         }
 56         System.out.println();
 57
 58         //直接插入排序
 59         for (int i = 1; i < arr.length; i++) {
 60             int temp = arr[i];
 61             int j;
 62             for (j = i - 1; j >= 0 && arr[j] > temp; j--) {
 63                 arr[j + 1] = arr[j];
 64             }
 65             arr[j + 1] = temp;
 66         }
 67         System.out.println("直接插入排序结果-->");
 68         for (int j = 0; j < arr.length; j++) {
 69             System.out.print(arr[j] + "\t");
 70         }
 71         System.out.println();
 72
 73         //使用sort()排序
 74         Arrays.sort(arr);
 75         System.out.println("使用sort()排序结果-->");
 76         for (int j = 0; j < arr.length; j++) {
 77             System.out.print(arr[j] + "\t");
 78         }
 79         System.out.println();
 80
 81     }
 82
 83     public static void quickSort(int[] a, int l, int r) {
 84
 85         if (l < r) {
 86             int i,j,x;
 87
 88             i = l;
 89             j = r;
 90             x = a[i];
 91             while (i < j) {
 92                 while(i < j && a[j] > x){
 93                     j--; // 从右向左找第一个小于x的数
 94                 }
 95                 if(i < j){
 96                     a[i++] = a[j];
 97                 }
 98                 while(i < j && a[i] < x){
 99                     i++; // 从左向右找第一个大于x的数
100                 }
101                 if(i < j){
102                     a[j--] = a[i];
103                 }
104             }
105             a[i] = x;
106             quickSort(a, l, i-1); /* 递归调用 */
107             quickSort(a, i+1, r); /* 递归调用 */
108         }
109     }
110
111 }

排序结果

需排序数组-->
17    27    40    80    84    0    68    38    39    53    

选择排序结果-->
0    17    27    38    39    40    53    68    80    84
冒泡排序结果-->
0    17    27    38    39    40    53    68    80    84
快速排序结果-->
0    17    27    38    39    40    53    68    80    84
直接插入排序结果-->
0    17    27    38    39    40    53    68    80    84
使用sort()排序结果-->
0    17    27    38    39    40    53    68    80    84    

时间: 2024-08-08 12:35:20

选择、冒泡、插入、直接排序算法的相关文章

数据结构精要------冒泡与直接排序算法

作为程序员的我们在程序开发的时候经常会用到一些简单的排序算法,例如:对数组进行快速排序:要实现这些就需要运用到数据结构排序算法的知识,那么熟练使用和掌握排序算法对于开发人员来说是百利而无一害.同时记录一下知识点也是自己对自己的进一步巩固总结: 那么何为排序算法呢? 排序是计算机内经常进行的一种操作,其目是一组 "无序 "的记录序列调整为 "有序 "的记 录序列.排序分内排序和外排序. 那么何为内排和外排呢? 内排序 :指在排序 期间数据对象全部存放在内存排序. 外排

使用python实现冒泡、选择、插入基础排序

冒泡排序 依次比较相邻两元素,若前一元素大于后一元素则交换之,直至最后一个元素即为最大: 然后重新从首元素开始重复同样的操作,直至倒数第二个元素即为次大元素: 依次类推.如同水中的气泡,依次将最大或最小元素气泡浮出水面. 实现 # 冒泡排序 def bubble_sort(li): # 建立一个标识符 flag = False for i in range(len(li)-1): for j in range(len(li)-i-1): if li[j] > li[j+1]: li[j], li

冒泡---插入---希尔排序

<span style="color:#ff0000;">#include<iostream> using namespace std; #define MAXSIZE 21 typedef int SqList[MAXSIZE]; #define ElementType int void Swap(int &a, int &b) { a = a^b; b = a^b; a = a^b; } ///////////////////////////

[转]各种排序算法的分析及java实现

原文:http://www.cnblogs.com/liuling/p/2013-7-24-01.html 排序一直以来都是让我很头疼的事,以前上<数据结构>打酱油去了,整个学期下来才勉强能写出个冒泡排序.由于下半年要准备工作了,也知道排序算法的重要性(据说是面试必问的知识点),所以又花了点时间重新研究了一下. 排序大的分类可以分为两种:内排序和外排序.在排序过程中,全部记录存放在内存,则称为内排序,如果排序过程中需要使用外存,则称为外排序.下面讲的排序都是属于内排序. 内排序有可以分为以下几

八大排序算法JAVA实现(时间复杂度O(n*logn)篇)

本文讲述时间复杂度为n*logn的排序算法:归并排序.快速排序.堆排序以及希尔排序的原理.Java实现以及变形应用. 一.归并排序 原理:把两个有序数列合并为一个有序数列.需递归实现. Java实现: 1 public int[] mergeSort(int[] a, int n) 2 { 3 return doMergeSort(a, n, 0, n - 1); 4 } 5 public int[] doMergeSort(int[] a, int n, int start, int end)

排序算法(java版)

1. 冒泡算法2. 快速排序3. 归并排序4. 选择排序5. 堆排序 排序算法 重要性不言而喻,很多算法问题往往选择一个好的排序算法往往问题可以迎刃而解 1.冒泡算法 冒泡排序(Bubble Sort)也是一种简单直观的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端.也就是双重循环就可以搞定的问题但是需要注意下一

Java常用的排序算法

转载自博客http://blog.csdn.net/xsf50717 排序算法 重要性不言而喻,很多算法问题往往选择一个好的排序算法往往问题可以迎刃而解 1.冒泡算法 冒泡排序(Bubble Sort)也是一种简单直观的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端.也就是双重循环就可以搞定的问题但是需

面试常用算法总结——排序算法(java版)

排序算法 重要性不言而喻,很多算法问题往往选择一个好的排序算法往往问题可以迎刃而解 1.冒泡算法 冒泡排序(Bubble Sort)也是一种简单直观的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端.也就是双重循环就可以搞定的问题但是需要注意下一边界 算法步骤: 1)比较相邻的元素.如果第一个比第二个大,

排序算法习题汇总

1.冒泡排序 对于一个int数组,请编写一个冒泡排序算法,对数组元素排序. 给定一个int数组A及数组的大小n,请返回排序后的数组. 测试样例: [1,2,3,5,2,3],6 [1,2,2,3,3,5] class BubbleSort { public: int* bubbleSort(int* A, int n) { // write code here for(int i=0;i<n-1;i++){ int k=0; for(int j=0;j<n-i-1;j++){ if(A[j]&

排序算法之NB三人组

快速排序 思路: 例如:一个列表[5,7,4,6,3,1,2,9,8], 1.首先取第一个元素5,以某种方式使元素5归位,此时列表被分为两个部分,左边的部分都比5小,右边的部分都比5大,这时列表变成了[2,1,4,3,5,6,7,9,8] 2.再对5左边进行递归排序,取5左边部分的第一个元素2,使2归位,这时5左边的部分变成了[1,2,4,3] 3.2归位后再对2右边5左边的部分即[4,3]进行排序,然后整个列表中5左边的部分就完成了排序 4.再使用递归方法对5右边的部分进行递归排序,直到把列表