精华内容
下载资源
问答
  • 冒泡排序 public class BubbleSort { /** * N个数字要排序完成,总共进行N-1趟排序,每i趟的排序次数为(N-i)次,所以可以用双重循环语句,外层控制循环多少趟,内层控制每一趟的循环次数。 * @param ...

    本节重点思维导图

     

     

     

     

     

    数组

    public static void main(String[] args) {
            int a ;
            a=3;
            
            int[] b;
            b = new int[3];//强制开辟内存空间
            
            int c[] = new int [8];
            
            int[] d = {3,4,5,67};
            int[] e = new int[] {3,4,5};
            
            System.out.println(d[2]);
        }

    例题:产生1到100之间所有奇数组成的数组并输出。要求每10个一行输出

    public class Demo {
            public static void main(String[] args) {
                int[] array = new int[50];
    
                for (int i = 0; i < 50; i++) {
                    array[i] = 2 * i + 1;
                }
    
                for (int i = 0; i < 50; i++) {
                    if (i  % 10 == 0)
                        System.out.println();
                    System.out.print(array[i] + "\t");
                }
            }
        
    }
        

     

     

     

     多维数组

     

     

     

     

     Arrays 类

     java.util.Arrays 类能方便地操作数组,它提供的所有方法都是静态的

    • 给数组赋值:通过 fill 方法。
    • 对数组排序:通过 sort 方法,按升序。
    • 比较数组:通过 equals 方法比较数组中元素值是否相等。
    • 查找数组元素:通过 binarySearch 方法能对排序好的数组进行二分查找法操作。

     

     

     

     

    额外补充:

    存储在数组当中的数据都属于同一数据类型

    比如说一个 int 类型的数组:

    int[] arr = { 'a', 25, 45, 78, 'z' };
    System.out.println(Arrays.toString(arr));

    输出结果是:[97, 25, 45, 78, 122]

    存放进去的 char 类型的字符会自动转为 int 类型的 ASCII 码

    上面的代码中就将 a 转成了 97,z 转成了 122。

     

     实现数组和字符串的转换处理

    public class Test {
        public static void main(String args[]) {
            String str = "helloworld";
            char[] data = str.toCharArray();// 将字符串转为数组
            for (int x = 0; x < data.length; x++) {
                System.out.print(data[x] + "  ");
                data[x] -= 32;
                System.out.print(data[x] + "  ");
            }
            System.out.println(new String(data));
        }
    }

     

     

     

    冒泡排序

    public class BubbleSort {
    /**
     * N个数字要排序完成,总共进行N-1趟排序,每i趟的排序次数为(N-i)次,所以可以用双重循环语句,外层控制循环多少趟,内层控制每一趟的循环次数。
     * @param args
     */
        public static void main(String[] args) {
            int arr[] = {26,15,29,66,99,88,36,77,111,1,6,8,8};
            for(int i=0;i < arr.length-1;i++) {//外层循环控制排序趟数
                for(int j=0; j< arr.length-i-1;j++) {
                            //内层循环控制每一趟排序多少次
                    // 把小的值交换到前面
                    if (arr[j]>arr[j+1]) {
                        int temp = arr[j];
                        arr[j] = arr[j+1];
                        arr[j+1] = temp;
                    }
                }
                System.out.print("第"+(i+1)+"次排序结果:");
                                    //列举每次排序的数据
                for(int a=0;a<arr.length;a++) {
                    System.out.print(arr[a] + "\t");
                }
                System.out.println("");
            }
            System.out.println("最终排序结果:");
            for(int a = 0; a < arr.length;a++) {
                System.out.println(arr[a] + "\t");
            }
        }
    }

    选择排序

     

    public class Start
    {
        public static void main(String[] args)
        {
            int[] arr={20,60,51,81,285,12,165,51,81,318,186,9,70};
            for(int a:arr)
            {
                System.out.print(a+" ");
            }
            
            System.out.println("\n"+"---------------从小到大---------------");
            
            arr=toSmall(arr);
            for(int a:arr)
            {
                System.out.print(a+" ");
            }
            
            System.out.println("\n"+"---------------从大到小---------------");
            
            arr=toBig(arr);
            for(int a:arr)
            {
                System.out.print(a+" ");
            }
        }
    //    从大到小
        public static int[] toSmall(int[] arr)
        {
    //遍历数组里除最后一个的其他所有数,因为最后的对象没有与之可以相比较的数
            for(int i=0;i<arr.length-1;i++)
            {
    /*遍历数组里没有排序的所有数,并与上一个数进行比较
     *“k=i+1”因为自身一定等于自身,所以相比没有意义
     *而前面已经排好序的数,在比较也没有意义
     */
                for(int k=i+1;k<arr.length;k++)
                {
                    if(arr[k]<arr[i])//交换条件(排序条件)
                    {
                        int number=arr[i];
                        arr[i]=arr[k];
                        arr[k]=number;
                    }//交换
                }
            }
            return arr;
        }
    //    从小到大
    //和前面一样
        public static int[] toBig(int[] arr)
        {
            for(int i=0;i<arr.length-1;i++)
            {
                for(int k=i+1;k<arr.length;k++)
                {
                    if(arr[k]>arr[i])
                    {
                        int number=arr[i];
                        arr[i]=arr[k];
                        arr[k]=number;
                    }
                }
            }
            return arr;
        }
    }

     

    转载于:https://www.cnblogs.com/expedition/p/10849460.html

    展开全文
  • 本资源主要列举了几种常见的排序算法,包含:冒泡排序,插入排序,选择排序,快速排序,希尔排序和堆排序
  • ====================================================|| 欢迎讨论技术的可以相互加微信:windgs (请备注csdn+xx职业) =========================================...冒泡排序  代码实现 直接插入排序 总结 ...

    ====================================================||

    欢迎讨论技术的可以相互加微信:windgs (请备注csdn+xx职业)

    ====================================================||  

    目录

    简单选择排序

      代码实现

    冒泡排序 

      代码实现

    直接插入排序

    总结


     

    排序是数据处理中十分常见且核心的操作,虽说实际项目开发中很小几率会需要我们手动实现,毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些精妙的思想对我们还是大有裨益的。本文简单温习下最基础的三类算法:选择,冒泡,插入。

      先定义个交换数组元素的函数,供排序时调用

    /**
         * 交换数组元素
         * @param arr
         * @param a
         * @param b
         */
        public static void swap(int []arr,int a,int b){
            arr[a] = arr[a]+arr[b];
            arr[b] = arr[a]-arr[b];
            arr[a] = arr[a]-arr[b];
        }

    简单选择排序

      简单选择排序是最简单直观的一种算法,基本思想为每一趟从待排序的数据元素中选择最小(或最大)的一个元素作为首元素,直到所有元素排完为止,简单选择排序是不稳定排序。

      在算法实现时,每一趟确定最小元素的时候会通过不断地比较交换来使得首位置为当前最小,交换是个比较耗时的操作。其实我们很容易发现,在还未完全确定当前最小元素之前,这些交换都是无意义的。我们可以通过设置一个变量min,每一次比较仅存储较小元素的数组下标,当轮循环结束之后,那这个变量存储的就是当前最小元素的下标,此时再执行交换操作即可。代码实现很简单,一起来看下。

      代码实现

    /**
         * 简单选择排序
         *
         * @param arr
         */
        public static void selectSort(int[] arr) {
            for (int i = 0; i < arr.length - 1; i++) {
                int min = i;//每一趟循环比较时,min用于存放较小元素的数组下标,这样当前批次比较完毕最终存放的就是此趟内最小的元素的下标,避免每次遇到较小元素都要进行交换。
                for (int j = i + 1; j < arr.length; j++) {
                    if (arr[j] < arr[min]) {
                        min = j;
                    }
                }
                //进行交换,如果min发生变化,则进行交换
                if (min != i) {
                    swap(arr,min,i);
                }
            }
        } 

      简单选择排序通过上面优化之后,无论数组原始排列如何,比较次数是不变的;对于交换操作,在最好情况下也就是数组完全有序的时候,无需任何交换移动,在最差情况下,也就是数组倒序的时候,交换次数为n-1次。综合下来,时间复杂度为O(n2)

    冒泡排序 

      冒泡排序的基本思想是,对相邻的元素进行两两比较,顺序相反则进行交换,这样,每一趟会将最小或最大的元素“浮”到顶端,最终达到完全有序

      

      代码实现

        在冒泡排序的过程中,如果某一趟执行完毕,没有做任何一次交换操作,比如数组[5,4,1,2,3],执行了两次冒泡,也就是两次外循环之后,分别将5和4调整到最终位置[1,2,3,4,5]。此时,再执行第三次循环后,一次交换都没有做,这就说明剩下的序列已经是有序的,排序操作也就可以完成了,来看下代码 

    /**
         * 冒泡排序
         *
         * @param arr
         */
        public static void bubbleSort(int[] arr) {
            for (int i = 0; i < arr.length - 1; i++) {
                boolean flag = true;//设定一个标记,若为true,则表示此次循环没有进行交换,也就是待排序列已经有序,排序已然完成。
                for (int j = 0; j < arr.length - 1 - i; j++) {
                    if (arr[j] > arr[j + 1]) {
                        swap(arr,j,j+1);
                        flag = false;
                    }
                }
                if (flag) {
                    break;
                }
            }
        }

      根据上面这种冒泡实现,若原数组本身就是有序的(这是最好情况),仅需n-1次比较就可完成;若是倒序,比较次数为 n-1+n-2+...+1=n(n-1)/2,交换次数和比较次数等值。所以,其时间复杂度依然为O(n2)。综合来看,冒泡排序性能还还是稍差于上面那种选择排序的。

    直接插入排序

      直接插入排序基本思想是每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。

       

    代码实现 

     

     /**
         * 插入排序
         *
         * @param arr
         */
        public static void insertionSort(int[] arr) {
            for (int i = 1; i < arr.length; i++) {
                int j = i;
                while (j > 0 && arr[j] < arr[j - 1]) {
                    swap(arr,j,j-1);
                    j--;
                }
            }
        }

     

      简单插入排序在最好情况下,需要比较n-1次,无需交换元素,时间复杂度为O(n);在最坏情况下,时间复杂度依然为O(n2)。但是在数组元素随机排列的情况下,插入排序还是要优于上面两种排序的。

    总结

      本文列举了排序算法中最基本的三种算法(简单选择,冒泡,插入),这三种排序算法的时间复杂度均为O(n2),后续会陆续更新其他更高阶一些的排序算法,时间复杂度也会逐步突破O(n2),谢谢支持。

    展开全文
  • * 简单排序的几种方式:冒泡排序选择排序和插入排序,时间复杂度基本都为O(n*n) * 冒泡排序效率最低,选择排序则减少了元素交换的次数,而插入排序是3种方式中效率最高的 * 特别是当元素基本有序的情况下, 插入排序...
    package structure;
    
    /**
     * 简单排序的几种方式:冒泡排序、选择排序和插入排序,时间复杂度基本都为O(n*n)<br>
     * 冒泡排序效率最低,选择排序则减少了元素交换的次数,而插入排序是3种方式中效率最高的<br>
     * 特别是当元素基本有序的情况下, 插入排序其平均时间复杂度接近O(n) <br />
     * 
     * 除此之外复杂但更高效的排序方式还有:希尔排序和快速排序
     * 
     * @author yli
     * 
     */
    public class SortDemo {
    
    	public static void main(String[] args) {
    		// 冒泡排序:升序
    		popSortAsc();
    		// 冒泡排序:降序
    		popSortDesc();
    
    		// 选择排序:升序
    		selectedSortAsc();
    		// 选择排序:降序
    		selectedSortDesc();
    
    		// 插入排序:升序
    		insertSortAsc();
    		// 插入排序:降序
    		insertSortDesc();
    	}
    
    	/**
    	 * 冒泡排序:升序方式排序<br>
    	 * 冒泡排序特点:n个元素需要执行(n-1)次冒泡排序,第i轮冒泡有 (n-1-i)个元素需要两两比较<br>
    	 * 并且两两比较,只要满足比较条件,则相邻元素就交换,这其实就是和选择排序最大的区别
    	 */
    	public static void popSortAsc() {
    		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
    		int temp;
    		// n 个元素,需要执行 n-1 轮冒泡排序
    		int popCount = a.length - 1;
    		for (int i = 0; i < popCount; i++) {
    			// 第i轮冒泡就还有 (n-1-i)个元素需要两两比较
    			for (int j = 0; j < popCount - i; j++) {
    				if (a[j] > a[j + 1]) {
    					// 相邻两个元素比较只要符合条件,那么两个元素就进行交换
    					// 并且发现外层循环和内部循环中的元素没有关系
    					// 因此外层循环是计算:总共需要执行多少轮冒泡排序
    					// 而内部循环是:对剩余还未排序的元素进行一轮冒泡排序
    					temp = a[j];
    					a[j] = a[j + 1];
    					a[j + 1] = temp;
    				}
    			}
    		}
    
    		print(a);
    	}
    
    	/**
    	 * 冒泡排序:降序方式排序
    	 */
    	public static void popSortDesc() {
    		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
    		int temp;
    		int popCount = a.length - 1;
    		for (int i = 0; i < popCount; i++) {
    			for (int j = 0; j < popCount - i; j++) {
    				// 升序和降序,只要改变比较方式即可
    				if (a[j] < a[j + 1]) {
    					temp = a[j];
    					a[j] = a[j + 1];
    					a[j + 1] = temp;
    				}
    			}
    		}
    
    		print(a);
    	}
    
    	/**
    	 * 比较排序:升序方式排序<br>
    	 * 比较排序特点:和冒泡排序类似,n个元素,需要执行(n-1)轮选择排序<br>
    	 * 执行第i轮排序,假设a[i]为最小元素,从剩余的a[i+1]到a[len-1]中记录比a[i]还小的元素的位置<br>
    	 * 最后再拿a[i]和a[minIndex]进行交换,和冒泡排序相比,速度更快,因为节省了多次交换的时间<br>
    	 * 对于那些交换需要花费更多时间的编程语言来说,选择排序无疑比冒泡排序更优<br>
    	 */
    	public static void selectedSortAsc() {
    		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
    		int minIndex;
    		int temp;
    		for (int i = 0; i < a.length - 1; i++) {
    			// 假设a[i]是当前最小元素
    			minIndex = i;
    
    			// 从a[i+1]到a[len-1]中选出比a[i]还小的元素
    			for (int j = i + 1; j < a.length; j++) {
    
    				// 和冒泡排序相比,只从待排序元素中选出最小元素,并记录其位置
    				if (a[minIndex] > a[j]) {
    					minIndex = j;
    				}
    			}
    			// 等一轮选择排序执行完之后再交换
    			if (i != minIndex) {
    				temp = a[i];
    				a[i] = a[minIndex];
    				a[minIndex] = temp;
    			}
    		}
    
    		print(a);
    	}
    
    	/**
    	 * 比较排序:降序方式排序
    	 */
    	public static void selectedSortDesc() {
    		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
    		int minIndex;
    		int temp;
    		for (int i = 0; i < a.length - 1; i++) {
    			minIndex = i;
    			for (int j = i + 1; j < a.length; j++) {
    				if (a[minIndex] < a[j]) {
    					minIndex = j;
    				}
    			}
    			if (i != minIndex) {
    				temp = a[i];
    				a[i] = a[minIndex];
    				a[minIndex] = temp;
    			}
    		}
    
    		print(a);
    	}
    
    	/**
    	 * 插入排序:升序方式排序<br>
    	 * 插入排序的特点:局部有序,待排序的元素在有序的元素中找到一个合适的位置插入<br>
    	 * 大约比冒泡排序快1倍,比选择排序略快<br>
    	 * 这种排序方式特别适合基本有序的元素排序,其排序速度接近 O(n)<br>
    	 * 不过正常情况下,其排序速度也要计算为 O(n*n)
    	 * 
    	 */
    	public static void insertSortAsc() {
    		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
    		int j;
    		int temp;
    		// 假设a[0]为局部有序的元素(因为只有一个,所以肯定是有序)
    		// 然后从a[1]开始往局部有序的元素中插入新元素
    		for (int i = 1; i < a.length; i++) {
    			j = i;
    			// 第[i]轮排序,要插入的新元素就是 a[i]
    			temp = a[i];
    			// 然后找到新元素在局部有序元素中的位置
    			while (j > 0 && a[j - 1] > temp) {
    				a[j] = a[j - 1];
    				j--;
    			}
    			a[j] = temp;
    		}
    
    		print(a);
    	}
    
    	/**
    	 * 插入排序:降序方式排序
    	 */
    	public static void insertSortDesc() {
    		int[] a = { 10, 4, 3, 6, 5, 7, 2, 1, 9, 8 };
    		int j;
    		int temp;
    		for (int i = 1; i < a.length; i++) {
    			j = i;
    			temp = a[i];
    			// 升序和降序,只要改变比较方式即可
    			while (j > 0 && a[j - 1] < temp) {
    				a[j] = a[j - 1];
    				j--;
    			}
    			a[j] = temp;
    		}
    
    		print(a);
    	}
    
    	private static void print(int[] arr) {
    		for (int temp : arr) {
    			System.out.print(temp + "\t");
    		}
    		System.out.println();
    	}
    
    }

    展开全文
  • 冒泡排序: 我们在初学Java数组的时候,排序就是数组必不可少的一项,排序分为很多种,这里我就先介绍我们经常遇到的冒泡排序: 何为冒泡排序: 顾名思义,将一组无规则的数,打乱顺序存放到一个数组当中,(现在...

    冒泡排序:

    我们在初学Java数组的时候,排序就是数组必不可少的一项,排序分为很多种,这里我就先介绍我们经常遇到的冒泡排序:
    何为冒泡排序: 顾名思义,将一组无规则的数,打乱顺序存放到一个数组当中,(现在需求是将一组数从小到大排序)例如:

    int []arr = {1,5,2,9,4,3};
    把这组数的第一个数拿出来和紧跟着它后面的那个数作比较,如果第一个数比第二个数大的话,就将第一个数和第二个数交换位置,然后再将此时的第二个数和第三个数作比较,如果第二个数还是比第三个数大的话,则第二个数就再和第三个数交换位置,反之则位置顺序不变,简而言之就是谁大就排在后面。
    我们上面数组列举了6个数,所以他们第一轮之间会比较五次,也就是arr.length-1,所以我们得出第一轮比较的代码是:

    for(i=1;i<=arr.length-1;i++){
              }
    

    外层循环里面的i是指的比较的轮数,每一轮循环的实质是数组里面的数在进行比较,每一轮比完的最大值会存放到数组的最后面,不再进行比较,所以我们可以得出内层循环的次数代码
    for(j=0;j<=arr.length-1-i;j++){
    }

    这里的j=0是指下标从0开始 下标为{0,1,2,3,4,5}所以可以得出为什么是arr.length-1。至于-i,则是每一轮比过的最大的数是不会再进行比较了,放到最后面。
    因此我们可以轻而易举的写出整段代码了:

     public static void main(String[] args) {
            int []arr = {1,3,2,9,8,7,5};
            for (int i = 1; i <= arr.length - 1; i++) {
                for (int j = 0; j <=  arr.length - 1 - i; j++) {
                    if(arr[j]>arr[j+1]){
                        int t =arr[j];
                        arr[j] = arr[j + 1];
                        arr[j+1]=t;
                    }
                }
            }
            for (int newArr:arr
                 ) {
                System.out.print(newArr);
            }
        }
    

    选择排序

    **何为选择排序:**刚才我们说了冒泡排序是前一个值和后一个值比较,大的然后交换顺序到后面。而选择排序是从第一个数开始和后面每一个数进行比较,数值最小的记录其索引值,第二轮就比较剩下的数,数值最小的就放到第一个记录索引值,第三轮就比较剩下的数,以此类推。
    外层循环代码还是一样,都是记录比较的轮数:

    for(i=0;i<arr.length-1;i++){
    int index=i;
    }
    

    这里的内层循环有点不一样了,因为此时记录的是索引值,我们内层循环要拿第二个数和第一个数比较,所以j=j+1;

    for(j=i+1;i<=arr.length-1;j++){
       if(arr[j]<arr[index]){
         index=j;
       }
     }
    

    这是第一次比较得出最小值的索引,然后将它带入整个循环当中,代码如下:

       public static void main(String[] args) {
            int[] arr = {1, 3, 6, 0,9, 5};
            for (int i = 0; i < arr.length-1; i++) {
                int index = i;
                for (int j = i+1; j <=arr.length-1 ; j++) {
                    if(arr[j]<arr[index]){
                        index = j;
                    }
                }
                int t = arr[i];
                arr[i]=arr[index];
                arr[index]=t;
            }
            for (int newArr:arr
                 ) {
                System.out.print(newArr);
            }
        }
    

    以上属于个人理解,如有不足之处欢迎批评指正!

    展开全文
  • 文章目录1、选择排序2、冒泡排序3、插入排序 1、选择排序 排序:需要两个数比较,直至最后一位数时,已经没有多余的数进行比较了,所以比较的轮数-1; 开始比较的是下标arr[0]跟下标arr[1]开始比较; /** * ...
  • 选择、冒泡、插入排序法一、选择排序算法的原理二、冒泡排序算法的原理三、插入排序算法的原理四、简单总结选择、冒泡、插入排序算法 算法原理及代码实现 一、选择排序算法的原理 选择排序简单的来说就是拿第一个数...
  • 辞职后今天第一次参加前端开发工程师的面试,本来自己主要是搞后台开发的,不准备去,奈何对方的诚意,还是抱着试试看去的状态去了,后果...冒泡排序已知一组无序数据a[1]、a[2]、……a[n],需将其按升序排列。首...
  • 冒泡排序

    2020-02-18 16:48:02
    排序算法有很多,包括插入排序,冒泡排序,堆排序,归并排序,选择排序,计数排序,基数排序,桶排序,快速排序等。插入排序,堆排序,选择排序,归并排序和快速排序,冒泡排序都是比较排序,它们通过对数组中的元素...
  • 排序是数据处理中十分常见且核心的操作,虽说实际项目...本文简单温习下最基础的三类算法:选择冒泡,插入。  先定义个交换数组元素的函数,供排序时调用 /** * 交换数组元素 * @param arr * @param a ...
  • 冒泡排序选择排序相比,一个从局部入手减少逆序元素,一个放眼大局逐个选择最小值,二者思路大不相同。但是,它们又都有着“通过i次外层循环,从数据中顺次求出i个最小值”的相同特征。相对的,插入排序法是通过i...
  • 排序是算法研究中比较重要的一个部分,这里列举比较简单的三种排序算法的c++实现 1.交换函数 交换函数可以让代码看上去更加简洁 tip:在面试的时候,要求手写代码时,将一些重复的代码写成函数,还...2.冒泡排序 ...
  • 选择排序: #include<stdio.h> #include<time.h> #include<stdlib.h> int main() { int a[7]={3,7,5,2,4,6,8}; int i; int j; int temp; for(i=0;i<7;i++) ...
  • 综合来看,冒泡排序性能还还是稍差于上面那种选择排序的。 直接插入排序 直接插入排序基本思想是 每一步将一个待排序的记录,插入到前面已经排好序的有序序列中去,直到插完所有元素为止。 /** * ...
  • 冒泡排序和插入排序区别(小明版)有一天小明上体育课,排的是3号位置,老师说:同学们请用冒泡排序的方法排好队。小明觉得自己比2号的小红高,所以互换位置,成为了2号。然后他觉得比1号小刚高,所以又互换位置排到...
  • 1.冒泡排序法 基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序...
  • 1、简单排序  排序是数据处理中十分常见且核心的操作,虽说...本文简单温习下最基础的三类算法:选择冒泡,插入。  先定义个交换数组元素的函数,供排序时调用 /** * 交换数组元素 * @param arr * @...
  • 本文简单温习下最基础的三类算法:选择冒泡,插入。 先定义个交换数组元素的函数,供排序时调用 简单选择排序  简单选择排序是最简单直观的一种算法,基本思想为将序列分为有序序列和待排的无序序列,每一趟从...
  • 图解排序算法(一)之3种简单排序(选择冒泡,直接插入) 排序是数据处理中十分常见且核心的操作,虽说实际项目开发中很小几率会需要我们手动实现,毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些...
  • 排序是数据处理中十分常见且核心的操作,虽说实际项目...本文简单温习下最基础的三类算法:选择冒泡,插入。 先定义个交换数组元素的函数,供排序时调用 /** * 交换数组元素 * @param arr * @param a * @...
  • 冒泡排序 前言 如果说各种各样的编程语言是五花八门的招式,那么数据结构和算法就是程序员的内功了,这也是为什么各种招聘面试永远不会冷落这些的原因。 而排序作为数据结构一个重要组成是非常重要的。 排序 ...
  • 个人说明:排序的算法有许多种,该博客只是列举了部分常用的排序方式,以供参考。程序使用语言为C语言。 2.选择排序法 基本思想: 1.在要排序的一组数中,选出最小的一个数与第一个位置的数交换; 2.然后在...
  • 图解排序算法(一)之3种简单排序(选择冒泡,直接插入) 排序是数据处理中十分常见且核心的操作,虽说实际项目开发中很小几率会需要我们手动实现,毕竟每种语言的类库中都有n多种关于排序算法的实现。但是了解这些...
  • 冒泡排序是一种稳定的排序(相同元素之间两个位置并没有改变) public void maoPao(){ int [] num = {55,33,67,2,9,90,9,43}; for (int i=0;i;i++){ for (int j = 0;j;j++){ //从小到大排序 if(num[j]>num[j+1])...
  • 一 、冒泡排序:冒泡排序:属于交换排序;两两比较大小,交换位置,如同水泡大的往上(右)跑;n个数从左至右编号从0到n-1,索引0和1比较,如果索引0大,则交换两者位置;如果索引1大则不用交换继续比较索引1和2的值,将大值放在...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,648
精华内容 3,859
关键字:

列举选择排序,冒泡排序