选择排序,冒泡排序,直接插入排序

protected void SelectSort(int[] array)
          {
              int tmp;//暂存要交换的数据
              int t;//交换数据的位置
              for (int i = 0; i < array.Length; i++)
               {
                     t = i;
                     for (int j = i + 1; j < array.Length; j++)
                     {
                         if (array[j] < array[t])
                         {
                             t = j;
                         }
                     }
                tmp = array[i];
                array[i] = array[t];
                array[t] = tmp;
             }
         }

        /// <summary>
        /// 选择排序
        /// </summary>
        public void SmallToarge()
        {
            int temp = 0;
            int[] iArry = new int[] { 49, 5, 13, 6, 10, 55, 99};
            for (int i = 0; i < iArry.Length; i++)
            {
                for (int j = i+1; j < iArry.Length; j++)
                {
                    if (iArry[i] > iArry[j])
                    {  //A-----B  C---A  B-----C
                        temp = iArry[j]; //这里实现互换如:A B C三个瓶子 B是空瓶 A给B(A空,B满)C 给A(C空A满)B给C(B空C满)实现交换
                        iArry[j] = iArry[i];
                        iArry[i] = temp;
                    }
                }
            }
              //输出
            for (int f = 0; f < iArry.Length; f++)
            {
                Response.Write(iArry[f]+"<br/>");
            }

        }

        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="list"></param>
        public void sort(int[] list)
        {
            int i, j, temp; //定义变量

            j = 1;//赋初始值
            while (j < list.Length)
            {

                for (i = 0; i < list.Length - j; i++) //因为i的比较项是 i 和i+1 一个数组有6项那么i的最大值是5
                {
                   // int[] iArry = new int[] { 49, 5, 13, 6, 10, 55, 99 };
                    //49>5 49>13 49>6 49>10 49<55 55<99
                    //第一个和第二个比较,第二个和第三个比较,3和4,4和5,5和6,6和7
                    //int[] iArry = new int[] {10,9,8,7,6 };
                    //10>9 10>8 10>7 10>6 所以10是最大的
                    if (list[i] > list[i + 1]) //加以加较
                    {

                        temp = list[i];
                        list[i] = list[i + 1];
                        list[i + 1] = temp;
                    }
                }
                j++; //每加一次少比较一项
            }
            //输出
            for (int f = 0; f < list.Length; f++)
            {
                Response.Write(list[f] + "<br/>");
            }
        }
        /// <summary>
        /// 冒泡排序2
        /// </summary>
        public void sortTwo()
        {
           int i,j,t;
           int[]array={4,2,6,9,22,1,100};
           for (i = 0; i < array.Length - 1; i++)
            {
                for (j = 0; j < array.Length - i - 1; j++)
              {
                  if (array[j] > array[j + 1])
                  {
                      t = array[j];
                      array[j] = array[j + 1];
                      array[j + 1] = t;
                   }
                }
            }
            //输出
           for (int f = 0; f < array.Length; f++)
           {
               Response.Write(array[f] + "<br/>");
           }
        }

        /// <summary>
        /// 直接插入排序
        /// </summary>
        /// <param name="array"></param>
         public  void InsertSort(int[] array)
         {
             int i, j;
             int temp;
             for (i =  1; i < array.Length; i++)
             {
                 temp = array[i];
                 j = i - 1;
                 //与已排序的数逐一比较, 大于temp时, 该数移后
                 while ((j >= 0) && (array[j] > temp))
                 {
                     array[j + 1] = array[j];
                     j--;
                 }
                 array[j + 1] = temp;
            }
             for (int f = 0; f < array.Length; f++)
             {
                 Response.Write(array[f] + "<br/>");
             }
        }
时间: 2024-10-18 12:47:33

选择排序,冒泡排序,直接插入排序的相关文章

选择排序 冒泡排序 简单插入排序

排序: public class SortDemo { public static void main(String[] args) { int[] arr = { 5, 8, 9, 12, 55, 565, 421, 12, 2512, -5, -56 }; // int[] arr = { 6, 9, 4589, 442, 458, 5232, -788, 7, 545, -44, 55, -11 // }; // selectionSort(arr); // bubbleSort(arr)

排序(二)__冒泡排序、简单选择排序和直接插入排序

前面<排序(一)__综述>提到按照算法的复杂度分为简单算法和改进算法两大类,本文主要就简单算法中的冒泡排序.简单选择排序和直接插入排序进行通俗详细的解析. 一.冒泡排序 1.基本概念 冒泡排序是一种交换排序,它的基本思想是:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.(动态图来自维基百科) 2.关键代码(优化之后) void BubbleSort(SqList *L) { int i,j; Status flag=TRUE;            //flag用作标记,避

排序算法学习之简单排序(冒泡排序,简单选择排序,直接插入排序)

一.冒泡排序 冒泡排序算是最基础的一种算法了,复杂度为O(N^2),其基本思想是:从最低端数据开始,两两相邻比较,如果反序则交换.代码如下: /*最基本的冒泡排序*/ void BubbleSort1 (int n, int *array) /*little > big*/ { int i, j; for (i=0; i<n-1; i++) { for (j=n-1; j>i; j--) { if (array[j] < array[j-1]) { int temp = array

冒泡排序、简单选择排序、直接插入排序

冒泡排序(Bubble Sort)的基本思想:两两比较相邻记录的关键字,如果反序则交换,直到没有反序的记录为止.时间复杂度为O(n2). 简单选择排序(Simple Selection Sort)的基本思想:通过n-i次关键字之间的比较,从n-i+1个记录中选出关键字最小的记录,并和第i个记录交换.应该说,尽管与冒泡排序同为O(n2), 但简单选择排序的性能上还是要略优于冒泡排序. 直接插入排序(Straight Insertion Sort)的基本思想:将一个记录插入到前面已经排序好的有序表中

C语言-简单选择排序与直接插入排序的实现

/* Name: selectSort and insertSort Copyright: nyist Author: 润青 Date: 01/10/18 19:30 Description: 实现了简单选择排序与直接插入排序 */ #include<stdio.h> int a[100]; int n; void selectSort(); void insertSort(); int main(){ scanf("%d",&n); for(int i=0;i&l

01. Java的经典排序--选择排序--冒泡排序--折半查找(二分查找)

Java的经典排序--选择排序--冒泡排序--折半查找 选择排序 选择排序 3 2 1 5 8 0 1 3 2 5 8 1 1 2 3 5 8 2 1 2 3 5 8 3 1 2 3 5 8 public static void main(String[] args) { int[] arr={3,2,1,5,8}; selectSort(arr); for(int i = 0 ; i < arr.length ; i ++){ System.out.println(arr[i]) ; } }

常见排序集合(冒泡排序,选择排序,直接插入排序,二分插入排序,快速排序,希尔排序,归并排序)

一下是一些常见的排序算法: 交换元素(后面算法都有用到): // 交换元素 private static void swap(int[] a, int i, int j) { int temp; temp = a[i]; a[i] = a[j]; a[j] = temp; } 冒泡排序(有优化): // 冒泡排序(优化①,②,③,④) private static void bubbleSort(int[] a) { boolean flag = false;// ①表示整个序列是无序的 for

php排序介绍_冒泡排序_选择排序法_插入排序法_快速排序法

这里我们介绍一些常用的排序方法,排序是一个程序员的基本功,所谓排序就是对一组数据,按照某个顺序排列的过程. 充效率看 冒泡排序法<选择排序法<插入排序法 排序分两大类: 内部排序法 交换式排序法 冒泡法 基本思想: 冒泡排序法 案例: 1234567891011121314151617181920212223242526 //简单的$arr=array(0,5,-1); //现在我们把函数毛片封装成函数,利用以后使用//数组默认传递的是值,不是地址,&是地址符function bubb

选择排序 冒泡排序 插入排序

1.选择排序 每一次找出最小的值,放在最前面的位置,一个一个安置 //选择排序 #include<iostream> #include<climits> using namespace std; template<class T> void gcd(T a[],int n){ int mix,temp; for(int i=0;i<n-1;i++){ mix=i; for(int j=i+1;j<n;j++) if(a[j]<a[mix]) mix=j

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

冒泡排序 比较相邻的元素,如果第一个比第二个大,就交换他们.第一步所有相邻的排序做完后,最大的数字会在最右边,接着重复步骤. public class Main { public static void main(String[] args) { int[] array={9,5,2,6,1,3,8,4,10,7}; for (int i=0;i<array.length;i++){ for (int j=0;j<array.length-i-1;j++){ if (array[j]>a