精华内容
下载资源
问答
  • 快速排序 java代码

    2012-04-16 15:42:24
    快速排序 java代码
  • 快速排序java代码

    2015-08-19 06:19:45
    快速排序算法,可以运行,运行截图一并打包,分享给大家。
  • 快速排序Java代码

    千次阅读 2014-09-10 16:44:30
    public class 快速排序 { public static void qSort(int[] arr, int low, int high) { if (low ) { int i = low; int j = high; int x = arr[i]; // 基准 while (i x) j--; if (i ) {
    public class 快速排序 {
    	public static void qSort(int[] arr, int low, int high) {
    		if (low < high) {
    			int i = low;
    			int j = high;
    			int x = arr[i]; // 基准
    			while (i < j && arr[j] > x)
    				j--;
    			if (i < j) {
    				arr[i] = arr[j];
    				i++;
    			}
    			// 对称
    			while (i < j && arr[i] < x)
    				i++;
    			if (i < j) {
    				arr[j] = arr[i];
    				j--;
    			}
    			arr[i] = x;
    			qSort(arr, low, i - 1);
    			qSort(arr, i + 1, high);
    		}
    	}
    
    	public static void main(String[] args) {
    		int[] arr = { 1, 3, 2, 4 };
    		qSort(arr, 0, arr.length - 1);
    		for (int i : arr) {
    			System.out.print(i + " ");
    		}
    	}
    }

    展开全文
  • 快速排序java代码.zip

    2021-01-28 15:15:57
    快速排序
  • 快速排序java代码实现

    千次阅读 2018-03-01 14:57:22
    说明: 快速排序是一个速度非常快的交换排序算法,它的基本思路很简单,从待排的数据序列中任取一个数据(如第一个数据)作为基准值,所有比它小的元素放到左边,所有比它大的元素放到右边。经过这样一趟下来,该...

    说明:

        快速排序是一个速度非常快的交换排序算法,它的基本思路很简单,从待排的数据序列中任取一个数据(如第一个数据)作为基准值,所有比它小的元素放到左边,所有比它大的元素放到右边。经过这样一趟下来,该序列形成左右两个子序列,左边序列中的数据元素的值都比基准值小,右边序列中数据元素的值都比基准值大。接下来对左右两个子序列进行递归排序。

    平均时间复杂度是T(n) = o(logn)

    实现步骤:

        1、定义一个变量i从坐起第一个索引开始,找大于基准值的元素的索引,并用i记录;

        2、定义一个变量j,从右起第一个索引开始,找小于基准值的元素的索引,并用j来记录。

        3、如果i < j,交换i、j两个索引处的元素。

        重复执行以上1、2、3步骤,直到i>=j,可以判断j左边的元素都小于基准值,j右边的元素都大于基准值,最后将基准值与j索引处的元素交换即可。

    代码:

    public class Test {
    
    	public static void main(String[] args) {
    		int[] data = new int[]{ 5, 3, 6, 2, 1, 9, 4, 8, 7, 10};
    		System.out.println("排序前的数组");
            print(data);
            System.out.println("开始排序");
            quickSort(data,0,data.length-1);
            System.out.println("排序后的数组");
            print(data);
    	}
    
    	/**
    	 * 快速排序
    	 * @param data	数组
    	 * @param begin	开始下标
    	 * @param end	结束下标
    	 */
    	private static void quickSort(int[] data, int begin, int end) {
    		if(begin>=end)return;
    		int point = data[begin];//保存起始值作为基准数
    		int i = begin+1;
    		int j = end;
    		while(true){
    			while(i<end && data[i]<point){//从前往后:找到大于point的数的下标i
    				i++;
    			}
    			while(j>begin && data[j]>point){//从后往前:找到小于point的数的下标j
    				j--;
    			}
    			if(i<j){//如果i在前面,则交换位置
    				swap(data,i,j);
    			}else{//否则退出循环
    				break;
    			}
    		}
    		//以上循环完成后,小于point的数全都在前面,大于point的数全都在后面,
    		//下标j对应的数data[j]是小于point的,所以要单独交换
    		System.out.println("交换前:");
    		print(data);
    		swap(data,begin,j);
    		System.out.println("交换后:");
    		print(data);
    		//递归两边
    		quickSort(data,begin,j-1);
    		quickSort(data,j+1,end);
    	}
    
    	/**
    	 * 打印数组
    	 * @param data
    	 */
    	private static void print(int[] data) {
    		for(int i=0;i<data.length;i++){
                System.out.print(data[i]+"\t");
            }
            System.out.println();
    	}
    
    	/**
    	 * 交换数组中两个不同下标位置对应的数据
    	 * @param data	数组
    	 * @param i		下标i
    	 * @param j		下标j
    	 */
        public static void swap(int[] data,int i,int j){
            if(i==j){
                return;
            }
            data[i] = data[i]+data[j];
            data[j] = data[i]-data[j];
            data[i] = data[i]-data[j];
        }
    }
    输出结果:

    排序前的数组
    5	3	6	2	1	9	4	8	7	10	
    开始排序
    交换前:
    5	3	4	2	1	9	6	8	7	10	
    交换后:
    1	3	4	2	5	9	6	8	7	10	
    交换前:
    1	3	4	2	5	9	6	8	7	10	
    交换后:
    1	3	4	2	5	9	6	8	7	10	
    交换前:
    1	3	2	4	5	9	6	8	7	10	
    交换后:
    1	2	3	4	5	9	6	8	7	10	
    交换前:
    1	2	3	4	5	9	6	8	7	10	
    交换后:
    1	2	3	4	5	7	6	8	9	10	
    交换前:
    1	2	3	4	5	7	6	8	9	10	
    交换后:
    1	2	3	4	5	6	7	8	9	10	
    排序后的数组
    1	2	3	4	5	6	7	8	9	10	
    




    展开全文
  • 快速排序Java代码简洁实现

    千次阅读 2020-04-29 16:29:11
    本文将阐述算法的基本思想,并用Java代码的形式实现快速排序代码。 算法思想 快速排序主要采用分治的基本思想,每次将一个位置上的数据归位,此时该数左边的所有数据都比该数小,右边所有的数据都比该数大,然后...

    学习过数据结构的同学们都知道,快速排序算法是一种时间复杂度为O(nlogn)的排序算法,在各种排序算法中算是较为高效的方法,企业面试中也经常有手撕快排的环节。本文将阐述算法的基本思想,并用Java代码的形式实现快速排序代码。

    算法思想

    快速排序主要采用分治的基本思想,每次将一个位置上的数据归位,此时该数左边的所有数据都比该数小,右边所有的数据都比该数大,然后递归将已归位的数据左右两边再次进行快排,从而实现所有数据的归位。

    举例

    我们有一组待排序数据:

    5 2 6 9 1 3 4 8 7 10

    我们首先拿到数组中的首个数字k=5,并且设置两个指针i和j。将i设置指向数组的起始数字5,j设置指向数组的末尾数字10。首先将j指向的数字与k比较,如果比k小,则将i和j指向的数字交换,如果不小于k则j指针不断向前移动。我们可以看到本例中j的移动过程是10->7->8->4,此时4比5小,则交换4和5,变成了如下序列:

    4 2 6 9 1 3 5 8 7 10

    每次交换后,另一个指针开始移动,i指针不断向后移动,寻找比5大的数字。i的移动过程是4->2->6,此时6比5大,则交换5和6,变成了如下序列:

    4 2 5 9 1 3 6 8 7 10

    再次轮到j指针向前移动,移动过程是6->3,此时3比5小,则交换3和5,变成了如下序列:

    4 2 3 9 1 5 6 8 7 10

    再次轮到i指针向后移动,移动过程是3->9,此时9比5大,则交换9和5,变成了如下序列:

    4 2 3 5 1 9 6 8 7 10

    再次轮到j指针向前移动,移动过程是9->1,此时1比5小,则交换1和5,变成了如下序列:

    4 2 3 1 5 9 6 8 7 10

    此时i指针和j指针相遇,数字5归位。再利用上述思想递归将5左右两边的序列进行排序,最终所有数字归位即可结束。

    Java代码实现

    public class QuickSort {
    	private void swap(int[] arr, int i, int j) {
    		int temp = arr[i];
    		arr[i] = arr[j];
    		arr[j] = temp;
    	}
    	
    	public void quickSort(int[] arr, int start, int end) {
    		if (start >= end)
    			return;
    		int k = arr[start];
    		int i = start, j = end;
    		while (i != j) {
    			while (i < j && arr[j] >= k)
    				--j;
    			swap(arr, i, j);
    			while (i < j && arr[i] <= k)
    				++i;
    			swap(arr, i, j);
    		}
    		quickSort(arr, start, i - 1);
    		quickSort(arr, i + 1, end);
    	}
    	
    	public static void main(String[] args) {
    		int[] arr = {5, 2, 6, 9, 1, 3, 4, 8, 7, 10};
    		new QuickSort().quickSort(arr, 0, arr.length - 1);
    		System.out.println(Arrays.toString(arr));
    	}
    }
    
    

    参考引用

    程序设计与算法(二)算法基础-快速排序

    展开全文
  • 快速排序JAVA代码

    2009-11-27 20:57:02
    快速排序JAVA代码,已运行成功 同时可以记录整个过程中的比较次数
  • java代码-JAVA快速排序

    2021-07-15 04:29:21
    java代码-JAVA快速排序
  • 快速排序算法java代码

    2012-08-11 23:34:51
    快速排序算法java代码,内附运行结果,望对大家有帮助,谢谢!
  • 主要介绍了Java 冒泡排序、快速排序实例代码,需要的朋友可以参考下
  • 主要介绍了java 算法之快速排序实现代码的相关资料,需要的朋友可以参考下
  • Java快速排序代码

    2008-06-10 14:41:48
    这是用Java写的快速排序的源代码
  • 本文主要介绍了java冒泡排序和快速排序的实例代码。具有很好的参考价值。下面跟着小编一起来看下吧
  • 排序有哪几种方法?请列举。并用JAVA实现一个快速排序.,需要的朋友可以参考下
  • java 快速排序代码

    2009-04-20 11:23:15
    java实现的快速排序,有详细的注释,可以下载下来运行查看的哈
  • 快速排序java代码实现)

    万次阅读 2018-08-18 10:45:07
    常用排序的时间及空间复杂度: 时间复杂度和空间复杂度详见:https://blog.csdn.net/jsjwk/article/details/84315770 稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录...

     常用排序的时间及空间复杂度:

    时间复杂度和空间复杂度详见:https://blog.csdn.net/jsjwk/article/details/84315770

    稳定性:假定在待排序的记录序列中,存在多个具有相同的关键字的记录,若经过排序,这些记录的相对次序保持不变,即在原序列中,r[i]=r[j],且r[i]在r[j]之前,而在排序后的序列中,r[i]仍在r[j]之前,则称这种排序算法是稳定的;否则称为不稳定的。

    一趟快速排序的算法是:

    1)设置两个变量i、j,排序开始的时候:i=0,j=N-1;

    2)以第一个数组元素作为关键数据,赋值给key,即key=A[0];

    3)从j开始向前搜索,即由后开始向前搜索(j--),找到第一个小于key的值A[j],将A[j]和A[i]互换;

    4)从i开始向后搜索,即由前开始向后搜索(i++),找到第一个大于key的A[i],将A[i]和A[j]互换;

    5)重复第3、4步,直到i=j; (3,4步中,没找到符合条件的值,即3中A[j]不小于key,4中A[i]不大于key的时候改变j、i的值,使得j=j-1,i=i+1,直至找到为止。找到符合条件的值,进行交换的时候i, j指针位置不变。另外,i==j这一过程一定正好是i+或j-完成的时候,此时令循环结束)

     

    示例

    假设用户输入了如下数组:

    下标012345
    数据627389

    创建变量i=0(指向第一个数据), j=5(指向最后一个数据), k=6(赋值为第一个数据的值)。

    我们要把所有比k小的数移动到k的左面,所以我们可以开始寻找比6小的数,从j开始,从右往左找,不断递减变量j的值,我们找到第一个下标3的数据比6小,于是把数据3移到下标0的位置,把下标0的数据6移到下标3,完成第一次比较:

    下标012345
    数据327689

    i=0 j=3 k=6

    接着,开始第二次比较,这次要变成找比k大的了,而且要从前往后找了。递加变量i,发现下标2的数据是第一个比k大的,于是用下标2的数据7和j指向的下标3的数据的6做交换,数据状态变成下表:

    下标012345
    数据326789

    i=2 j=3 k=6

    称上面两次比较为一个循环。

    接着,再递减变量j,不断重复进行上面的循环比较。

    在本例中,我们进行一次循环,就发现i和j“碰头”了:他们都指向了下标2。于是,第一遍比较结束。得到结果如下,凡是k(=6)左边的数都比它小,凡是k右边的数都比它大:

    下标012345
    数据326789

    如果i和j没有碰头的话,就递加i找大的,还没有,就再递减j找小的,如此反复,不断循环。注意判断和寻找是同时进行的。

    然后,对k两边的数据,再分组分别进行上述的过程,直到不能再分组为止。

    注意:第一遍快速排序不会直接得到最终结果,只会把比k大和比k小的数分到k的两边。为了得到最后结果,需要再次对下标2两边的数组分别执行此步骤,然后再分解数组,直到数组不能再分解为止(只有一个数据),才能得到正确结果。

    java代码实例:

    public class QuickTest {
         public static void sort(int[] a) {
            if (a.length > 0) {
                sort(a, 0, a.length - 1);
            }
    
        }
    
        public static void sort(int[] a, int low, int height) {
            int i = low;
            int j = height;
            if (i > j) {//放在k之前,防止下标越界
                return;
            }
            int k = a[i];
    
            while (i < j) {
                while (i < j && a[j] > k) { //找出小的数
                    j--;
                }
                while (i < j && a[i] <= k) { //找出大的数
                    i++;
                }
                if (i < j) {//交换
                    int swap = a[i];
                    a[i] = a[j];
                    a[j] = swap;
                }
    
            }
             //交换K
            k = a[i];
            a[i] = a[low];
            a[low] = k;
    
            //对左边进行排序,递归算法
            sort(a, low, i - 1);
            //对右边进行排序
            sort(a, i + 1, height);
        }
    
    
        public static void main(String[] args) {
            int[] arr = {5, 9, 7, 4, 5, 7, 6, 1, 9, 9, 7, 4};
            System.out.println(Arrays.toString(arr));
            sort(arr);
            System.out.println(Arrays.toString(arr));
        }
    
    }
    

    结果为:

    [5, 9, 7, 4, 5, 7, 6, 1, 9, 9, 7, 4]
    [1, 4, 4, 5, 5, 6, 7, 7, 7, 9, 9, 9]

    展开全文
  • 网上关于快速排序的算法原理和算法实现都比较多,不过java是实现并不多,而且部分实现很难理解,和思路有点不搭调。所以整理了这篇文章。如果有不妥之处还请建议。
  • 与本人博文《算法专项(1)——快速排序》相配套的工程源码,用JAVA实现
  • 快速排序java

    2012-10-21 11:13:38
    代码快速排序的实现代码,采用分治的方法,能垢计算计算机处理快速排序的时间。
  • 快速排序算法原理及Java代码实现1 基本思想1.1 意义1.2 简单解释1.3 基本思想1.4 图示2 Java代码实现快速排序 1 基本思想 1.1 意义 快速排序是冒泡排序的改进版,也是最好的一种内排序,还涉及到分治和递归 1.2 简单...
  • java代码-这是一个快速排序
  • 主要介绍了Java编程实现快速排序及优化代码详解,具有一定借鉴价值,需要的朋友可以了解下。
  • java代码-快速排序-----

    2021-07-16 11:31:07
    java代码-快速排序-----

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 124,019
精华内容 49,607
关键字:

快速排序java代码

java 订阅