精华内容
下载资源
问答
  • end){//条件不满足,即快排完毕,结束递归 int index=getIndex(start,end,array);//先获取基准数坑位 doQuickSort(start,index-1,array);//递归调用 比基准数小的 doQuickSort(index+1,end,array);//递归调用 比...
  • Java数组快速排序,插入排序,冒泡排序,选择排序代码实现 快速排序递归拆分 插入排序:从左往右一个一个插入左边已排好的数组中 冒泡排序:选定一个节点循环相邻的比较,每次循环排出一个最大的值 选择排序:只要...

    Java数组快速排序,插入排序,冒泡排序,选择排序代码实现

    快速排序:递归拆分
    插入排序:从左往右一个一个插入左边已排好的数组中
    冒泡排序:选定一个节点循环相邻的比较,每次循环排出一个最大的值
    冒泡排序优化:看完血赚https://www.cnblogs.com/kilig/p/10423845.html
    选择排序:只要发现小的就交换到前面

    二分查找:前后端点和中间点循环比较

    package test;
    
    import java.util.Arrays;
    
    public class ArraySort {
    	public static void main(String args[]) {
    
    		int[] a = { 2, 4, 64, 3, 63, 6 };
    		// quickSort(a, 0, a.length - 1);
    		// insertSort(a);
    		// bubleSort(a);
    		selsctSort(a);
    		for (int i : a) {
    			System.out.print(i + ",");
    		}
    		binarySearch(a, 6);
    		System.out.println();
    		System.out.print("二分查找:" + binarySearch(a, 63));
    	}
    
    	// 快速排序
    	//https://mp.weixin.qq.com/s?__biz=MzIxMjE5MTE1Nw==&mid=2653195042&idx=1&sn=2b0915cd2298be9f2163cc90a3d464da&chksm=8c99f9f8bbee70eef627d0f5e5b80a604221abb3a1b5617b397fa178582dcb063c9fb6f904b3&scene=21#wechat_redirect
    	public static int[] quickSort(int[] A, int begin, int end) {
    	 int i = begin;
            int j = end;
            if (i >= j) {
                return A;
            }
            int temp = A[i];
            while (i < j) {
                while (i < j && A[j] >= temp) {
                    j--;
                }
                while (i < j && A[i] <= temp) {
                    i++;
                }
                if (i < j) {
                    int k = A[i];
                    A[i] = A[j];
                    A[j] = k;
                }
            }
            A[begin] = A[i];
            A[i] = temp;
            // 递归调用左半数组
            quickSort(A, begin, i - 1);
            // 递归调用右半数组
            quickSort(A, i + 1, end);
    
            return A;
    	}
    
    	// 插入排序
    	public static int[] insertSort(int[] A) {
    		for (int i = 1; i < A.length; i++) {
    			int temp = A[i];
    			int j;
    			for (j = i - 1; j >= 0; j--) {
    				if (temp < A[j]) {
    					A[j + 1] = A[j];
    
    				} else {
    					break;
    				}
    			}
    			A[j + 1] = temp;
    		}
    
    		return A;
    	}
    
    	// 冒泡排序
    	public static int[] bubleSort(int[] nums) {
    		// 1.从前往后
    		for (int i = 0; i < nums.length - 1; i++) {// 外层循环控制排序趟数
    			for (int j = 0; j < nums.length - i - 1; j++) {// 内层循环控制每一趟排序多少次
    				if (nums[j] > nums[j + 1]) {
    					int temp = nums[j];
    					nums[j] = nums[j + 1];
    					nums[j + 1] = temp;
    				}
    			}
    		}
    
    		// 2.从后往前
    		/*for (int i = nums.length - 1; i > 0; i--) {
    			for (int j = 0; j < i; j++) {
    				if (nums[j + 1] < nums[j]) {
    					int temp = nums[j];
    					nums[j] = nums[j + 1];
    					nums[j + 1] = temp;
    				}
    			}
    		
    		}
    		*/
    		return nums;
    	}
    
    	// 选择排序
    	public static int[] selsctSort(int[] nums) {
    		// 普通选择排序
    		/*	for (int i = 0; i < nums.length; i++) {
    				for (int j = i + 1; j < nums.length; j++) {
    					if (nums[i] > nums[j]) {
    						int temp = nums[i];
    						nums[i] = nums[j];
    						nums[j] = temp;
    					}
    				}
    			}*/
    		// 提高效率排序
    		int k = 0;
    		for (int i = 0; i < nums.length - 1; i++) {
    			k = i;
    			for (int j = i + 1; j < nums.length; j++) {
    				if (nums[j] < nums[k]) {
    					k = j;
    				}
    			}
    			if (k != i) {
    				nums[k] = nums[k] ^ nums[i];
    				nums[i] = nums[k] ^ nums[i];
    				nums[k] = nums[k] ^ nums[i];
    			}
    		}
    
    		return nums;
    	}
    
    	// 二分查找
    	public static int binarySearch(int[] nums, int num) {
    		int begin = 0;
    		int end = nums.length - 1;
    		int mid;
    		while (begin < end) {
    			mid = begin + (end - begin)  /  2;
    			//(begin +end)  /  2有溢出风险
    			if (nums[mid] == num) {
    				return mid;
    			} else if (nums[mid] < num) {
    				begin = mid;
    			} else if (nums[mid] > num) {
    				end = mid;
    			} else {
    				return 0;
    			}
    		}
    		return 0;
    	}
    // 递归二分查找
    	public static int binarySearch(int[] nums, int bg, int end, int num) {
    		 if(bg<=end){
    			int mid = begin + (begin - end)  /  2;
    			if (nums[mid] == num) {
    				return mid;
    			} else if (nums[mid] < num) {
    				//bg = mid + 1;
    				return binarySearch(nums, mid+1, end, num);
    			} else {
    				//end = mid - 1;
    				return binarySearch(nums, bg, mid-1, num);
    			}
    
    		 }
    		return -1;
    	}
    }
    
    
    展开全文
  • JAVA数组快速排序

    2014-08-03 00:35:14
    //递归的对左侧序列进行快序排序 quicksort(arr,pt + 1,end);//递归的对右侧序列进行排序 }} public int ptr(int arr[],int first,int end){ int i = first;  int j = end; while( i ){ while...
    package com.array.sort;


    public class QuickSort {


    /**
    * @param args
    */
    public static void main(String[] args) {
    // TODO Auto-generated method stub
    int arr [] = {12,43,11,5,23,76,99,56,22};
    QuickSort a = new QuickSort();
    a.printss(arr);
    a.quicksort(arr, 0, arr.length-1);
    System.out.println("\n after:");
    a.printss(arr);
    }
    public void printss(int arr[]){
    for(int i = 0;i< arr.length;i++){
    System.out.print(arr[i] + ",");
    }
    }
    public void quicksort(int arr[],int first,int end){
    if(first < end){
    int pt = ptr(arr, first, end);//问题分解,pt是轴值在序列中的位置
    quicksort(arr,first,pt - 1);//递归的对左侧序列进行快序排序
    quicksort(arr,pt + 1,end);//递归的对右侧序列进行排序
    }}
    public int ptr(int arr[],int first,int end){
    int i = first; 
    int j = end;
    while( i < j ){
    while(i < j && arr[i] <= arr[j])
    j--;
    if(i < j)
    {
    int temp = arr[j];
    arr[j] = arr[i];
    arr[i] = temp;
    i++;
    }
    while(i < j && arr[i] <= arr[j])
    i++;
    if(i < j)
    {
    int temp = arr[j];
    arr[j]= arr[i];
    arr[i] = temp;
    j--;
    }
    }
    return i;
    }
    }
    展开全文
  • 我们对数组进行排序首先要了解一个类。Java.util.Arrays。  此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。 除非特别注明,否则如果指定数组引用为 ...

           我们对数组进行排序首先要了解一个类。Java.util.Arrays。

           此类包含用来操作数组(比如排序和搜索)的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。

    除非特别注明,否则如果指定数组引用为 null,则此类中的方法都会抛出 NullPointerException。 我们使用Arrays对数组进行排序。

    Arrays.sort(数组);

    1、若数组是数字类型数组按升序排列;

    2、若数组是char类型按自然顺序排列;

    3、若数组是Object[]类型,根据元素的自然顺序对指定对象数组按升序进行排序。

    例:


    输出结果:


    当然我们也可以指定数组的某一段进行排序比如我们要对数组下表0-2的部分(假设数组长度大于3)进行排序,其他部分保持不变,我们可以使用:

    Arrays.sort(arrInt,0,3);

    这样只对下标索引0-3排序,不会对后面的元素产生影响。

    接下来,一一讲解数组中个排序算法的原理:冒泡排序、插入排序、选择排序、快速排序。

    (1),冒泡排序

    基本思想:在要排序的一组数中,对当前还未排好序的范围内的全部数,自上而下对相邻的两个数依次进行比较和调整,让较大的数往下沉,较小的往上冒。即:每当两相邻的数比较后发现它们的排序与排序要求相反时,就将它们互换。

    public void upSort(int[] arrInt){

    for(int i=0;i<arrInt.length-1;i++){   //冒泡排序
    for(int j=0;j<arr
    Int
    .length-1;j++){
    if(arr[j]>arr[j+1]){
    int temp=arr[j];
    arr[j]=arr[j+1];
    arr[j+1]=temp;
    }
    }

    }

    }

    (2)插入排序

    public void insortSort(int[] arr){

    for(int i=1;i<arr.length;i++){
    int k=a[i];
    int j;
    for(j=i-1;j>=0&&k<arr[j];j--){
    a[j+1]=a[j];
    }
    a[j+1]=k;
    }
    }
    (3)选择排序

    基本思想:在要排序的一组数中,选出最小的一个数与第一个位置的数交换;

    然后在剩下的数当中再找最小的与第二个位置的数交换,如此循环到倒数第二个数和最后一个数比较为止


    public void choiseSort(int[] arr)
    for(int i=0;i<arr.length-1;i++){
    for(int j=i+1;j<arr.length;j++){
    if(arr[i]>arr[j]){
    int t=arr[i];
    arr[i]=arr[j];
    arr[j]=t;
    }

    }
    }
    }
    (4)快速排序
    本思想:选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描,将待排序列分成两部分,
    一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法
    递归地排序划分的两部分。
    public class QuickSort {

    public static int sort(int arr[],int left,int right){

    int key = arr[left];

    while(left<right){


    // 左比较
    while(left < right && arr[right] >= key){
    right--;
    }

    if(left<right && arr[right] < key){
    arr[left] = arr[right];
    }

    // 右比较
    while(left<right && arr[left] <= key){
    left++;
    }


    if(left<right && arr[left] > key){
    arr[right] = arr[left];
    }

    }
    arr[right] = key;
    return left;

    }

    public static void getSort(int arr[],int left,int right){

    if(left<right){
    int index = sort(arr, left, right);
    getSort(arr,left,index-1);
    getSort(arr,index+1,right);
    }
    }



    展开全文
  • Java数组排序

    2019-04-15 20:45:37
    Java数组排序:Java sort()方法 Arrays.sort(scores); Java数组排序:Java冒泡排序(Bubble Sort)法 System.out.println("通过冒泡排序方法对数组进行排序:"); for(int i=0;i<score.length-1;i++) { //...

    Java数组排序:Java sort()方法

    Arrays.sort(scores);

    Java数组排序:Java冒泡排序(Bubble Sort)法

    System.out.println("通过冒泡排序方法对数组进行排序:");
    for(int i=0;i<score.length-1;i++)
    {
        //比较相邻两个元素,较大的数往后冒泡
        for (int j=0;j<score.length-1-i;j++)
        {
            if(score[j]>score[j+1])
            {
                double temp=score[j+1];    //把第一个元素值保存到临时变量中
                score[j+1]=score[j];    //把第二个元素值转移到第一个元素变量中
                score[j]=temp;    //把临时变量(第一个元素的原值)保存到第二个元素中
            }
            System.out.print(score[j]+ " ");    //对排序后的数组元素进行输出
        }
    }

    Java数组排序:Java快速排序(Quicksort)法

    (1) 声明静态的 getMiddle() 方法,该方法需要返回一个 int 类型的参数值,在该方法中传入 3 个参数。代码如下:

    public static int getMiddle(int[] list,int low,int high)
    {
        int tmp=list[low];    //数组的第一个值作为中轴(分界点或关键数据)
        while(low<high)
        {
            while(low<high&&list[high]>tmp)
            {
                high--;
            }
            list[low]=list[high];    //比中轴小的记录移到低端
            while(low<high&&list[low]<tmp)
            {
                low++;
            }
            list[high]=list[low];    //比中轴大的记录移到高端
        }
        list[low]=tmp;    //中轴记录到尾
        return low;    //返回中轴的位置
    }

    (2) 创建静态的 unckSort() 方法,在该方法中判断 low 参数是否小于 high 参数,如果是则调用 getMiddle() 方法,将数组一分为二,并且调用自身的方法进行递归排序。代码如下:

    public static void unckSort(int[] list,int low,int high)
    {
        if(low<high)
        {
            int middle=getMiddle(list,low,high);    //将list数组一分为二
            unckSort(list,low,middle-1);    //对低字表进行递归排序
            unckSort(list,middle+1,high);    //对高字表进行递归排序
        }
    }

    (3) 声明静态的 quick() 方法,在该方法中判断传入的数组是否为空,如果不为空,则调用 unckSort() 方法进行排序。代码如下:

    public static void quick(int[] str)
    {
        if(str.length>0)
        {
            //查看数组是否为空
            unckSort(str,0,str.length-1);
        }
    }

    Java数组排序:Java选择排序法

    for(int i=1;i<number.length;i++)
    {
        index=0;
        for(int j=1;j<=number.length-i;j++)
        {
            if(number[j]>number[index])
            {
                index=j;    //查找最大值
            }
        }
        end=number[index]+" "+end;    //定位已排好的数组元素
        int temp=number[number.length-i];
        number[number.length-1]=number[index];
        number[index]=temp;
        System.out.print("【");
        for(int j=0;j<number.length-i;j++)
        {
            System.out.print(number[j]+" ");
        }
        System.out.print("】"+end);
    }

    Java数组排序:Java直接插入法

     

    public static void main(String[] args)
    {
        int[] number={13,15,24,99,4,1};
        System.out.println("排序前:");
        for(int val:number)
        {    //遍历数组元素
            System.out.print(val+" ");    //输出数组元素
        }
        int temp,j;
        for(int i=1;i<number.length;i++)
        {
            temp=number[i];
            for(j=i-1;j>=0&&number[j]>temp;j--)
            {
                number[j+1]=number[j];
            }
            number[j+1]=temp;
        }
        System.out.println("\n排序后:");
        for(int val:number)
        {    //遍历数组元素
            System.out.print(val+" ");    //输出数组元素
        }
    }

     

    展开全文
  • 当你拿到一个无序的数组时,经过一次排序,将一个数组分成了两个数组,在经过递归 排序,就会得到一个排序数组。 **想法:**基本上会选择数组中的第一个元素作为一个比较的基准点,将所有的比基准点小的值放在它的...
  • java数组排序

    2011-11-23 21:20:13
    冒泡排序,插入排序、递归排序等 实例代码……
  • Java实现数组排序递归

    千次阅读 2016-01-25 23:33:38
    排序思路:假设有n个数需要进行全排列,我们可以把每个数都放到第一个位置,然后剩下的n-1个数进行全排列。 * 即有n*(n-1)!种可能性,与n个数进行全排列的n!次可能性一致 利用递归的方式,依此类推当剩下的数个数为1...
  • Java数组排序总结(冒泡_选择_插入_希尔)__递归算法的复杂度,实用
  • Java数组:快速排序

    2019-11-04 12:42:47
    Java 数组的快速排序 快速排序思想 快速排序的思想通过先选择一个基准点,然后通过左右两个指针先后遍历,并且依次比较数值与基准点的大小,比基准点大的数据放到右边,比基本点小的数据放到左右。在循环遍历左右...
  • 将已知数组进行排序 代码如下: public class MethodDemo15 { public static void main(String[] args) { //创建数组 int[] arr = {9, 8, 7, 6, 5, 4, 3, 2, 1}; //排序 quickSort(arr, 0, arr.length - 1); ...
  • 快速排序的基本思想是:通过一趟排序,将要排序的数据分隔成独立的两部分,其中一部分的所有数据比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此使...
  • 如果空间已没有,便需要扩容.Java数组扩容采用建立一个新的数组,然后将原数据的数据拷贝过来。这里需要用到函数System.arraycopy。 public static void arraycopy(Object src, int srcPos, Object dest, int ...
  • Java递归数组排序

    千次阅读 2018-04-18 13:32:28
    3.合并数组 4.填充 5.删除数 6.字符串的输出 public class TestDemo1 { //插入元素 public static int[] Insert(int[] array,int val,int index) { int[] array2 = new int[array.leng...
  • 提到数组,大家都不陌生,通常遇到数组会涉及到一些算法,像数组排序,找唯一,反转等,算法层出不穷。今天介绍一个使用递归算法进行对一个整型数组,判断数组中是否有副本。 public static boolean unique(int[] ...
  • 数组快速排序递归实现 import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; public class testDemo { private static int[] arrs; /** * 快速排序 * @param args */ ...
  • JAVA数组、算法、递归

    2021-01-27 03:20:21
    排序 数→和→平均值 循环比较查找最大值最小值 二维数组模拟数据管理系统 收藏算法博客 获取运算前后时间比较长短 long t1 = System.currentTimeMillis(); 递归 不尚贤,使民不争;不贵难得之
  •  * 利用递归实现数组排序  * @param arr 一个数组  * @param stop 这是一个参数,调用此方法时,默认写0  * @return 返回一个从小到大排列的数组  * 这个方法其内部实现原理:每个数都与第一个数比较,...
  • 通过递归的方法实现java数组全排列 通过递归的方法实现实现数组的全排列. public static double[][] Func(double[] array,int q) { if(q==array.length-1) {return null;} double[] m=array.clone();//一定要...
  • java 实现数组排序

    2018-10-14 23:08:00
    数组排序的实现方式很多,在这里我采用的是递归的方式,还是上面的例子:abcd (1) 首先将首字母分别与后面的n(n>=1)个字母交换 abcd bacd cbad dbca (1)将交换后的字符数组第n位和n+1位进行交换并...
  • java数组排序,查找与置换

    千次阅读 2013-09-19 18:32:02
    一、排序 排序:将杂乱无章的数据元素,通过一定的方法按关键字顺序排列的过程叫做排序排序也是计算机内经常进行的一种操作,其目的是将一组“无序”的记录序列调整为“有序”的记录序列。
  • java重载/数组/递归

    2017-07-17 20:39:15
    本次主要内容为数组与数组排序
  • 三种方法对java数组排序

    千次阅读 2012-03-26 22:02:04
    1.选择排序法 每一趟从待排序的数据元素中选出最小(或最大)的一个元素,顺序放在已排好序的数列最后,直到全部待排序的数据元素排完。 for (int i = 0; i ; i++) { int min = array[i]; for (int...
  • 代码写的最规范的一次之一 /捂脸 ... * 递归地进行拆分数组并合并,如[1,2,3,4] 第一次拆分为[1,2],[3,4], 第二拆分为[1],[2] [3],[4] 然后合并 * * @param a 待排序数组 * @param beginIndex
  • Java数组

    2020-08-01 11:11:18
    11、java数组 声明数组变量 dataType[] arrayRefVar; // 首选的方法 dataType arrayRefVar[]; // 效果相同,但不是首选方法 创建数组 arrayRefVar = new dataType[arraySize]; dataType[] arrayRefVar = {value0,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 60,652
精华内容 24,260
关键字:

java数组递归排序

java 订阅