`
qindongliang1922
  • 浏览: 2148255 次
  • 性别: Icon_minigender_1
  • 来自: 北京
博客专栏
7265517b-f87e-3137-b62c-5c6e30e26109
证道Lucene4
浏览量：116343
097be4a0-491e-39c0-89ff-3456fadf8262
证道Hadoop
浏览量：124612
41c37529-f6d8-32e4-8563-3b42b2712a50
证道shell编程
浏览量：58490
43832365-bc15-3f5d-b3cd-c9161722a70c
ELK修真
浏览量：70378
社区版块
存档分类
最新评论

JAVA各种排序思想和示例

    博客分类：
  • JAVA
 
阅读更多

JAVA里面几种排序算法的原理
序号名称原理
1冒泡排序冒泡排序   排序原理： 通过两层循环控制， 外层循环，控制查找第i层的数，在余下的数据里最小或最大的   内层循环，负责依次比较下标相邻的两个数的大小，并负责将小数或大数的位置替换     每次的比较，都是上次在内存中替换完的新数组比较
2选择排序选择排序     对比数组中前一个元素跟后一个元素的大小， 如果后面的元素比前面的元素小则用一个变量k来记住他的位置，   接着第二次比较，前面“后一个元素”现变成了“前一个元素”， 继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变量 k记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最 小的那个数的下标了，然后进行判断，如果这个元素的下标不是第一个元素的下标，   就让第一个元素跟他交换一下值，这样就找到整个数组中最小的数了。然后找到数组中 第二小的数，让他跟数组中第二个元素交换一下值，以此类推。       a）第一次循环：记录第一个数的下标 b）将第一个数的值与后面的值相比、如果比后面值大、则将下标值改为后面值所对应的下标。 c）   第一次循环结束后、如果下标值有改动、说明后面有比此数值小的元素、交换两者位置 d）重复上述操作、直到所有数值都已排序
3插入排序 插入排序 基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排   好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数 也是排好顺序的。如此反复循环，直到全部排好顺序。
4希尔排序 基本思想：　    先取一个小于n的整数d1作为第一个增量，把文件的全部记录分成d1个组。所有距离为dl的倍数的记录放在同一个组中。先在各组内进行直接插人排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。
5快速排序  快速排序的原理   对于一个数组，进行按照某个key值进行拆分，   key值左边的数，统一小于key，key值右边统一大于key   然后递归对两边的的数组进行排序，   最后结果整体有序     怎么找到某个key值的点，默认按照取最后一个的数值来进行划分
6桶排序 桶排序 (Bucket sort)或所谓的箱排序，是一个排序算法，工作的原理是将阵列分到有限数量的桶子里。每个桶子再个别排序（有可能再使用别的排序算法或是以递回方式继续使用桶排序进行排序）。桶排序是鸽巢排序的一种归纳结果。当要被排序的阵列内的数值是均匀分配的时候，桶排序使用线性时间（Θ（n））。但桶排序并不是 比较排序，他不受到 O(n log n) 下限的影响。
7 堆排序堆积排序(Heapsort)是指利用堆积树（堆）这种资料结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。堆排序是不稳定的排序方法，辅助空间为O(1)， 最坏时间复杂度为O(nlog2n) ，堆排序的堆序的平均性能较接近于最坏性能。
8 归并排序 　归并排序是利用递归和分而治之的技术将数据序列划分成为越来越小的半子表，再对半子表排序，最后再用递归步骤将排好序的半子表合并成为越来越大的有序序列，归并排序包括两个步骤
9基数排序(radix sort）则是属于“分配式排序”（distribution sort），基数排序法又称“桶子法”（bucket sort）或bin sort，顾名思义，它是透过键值的部份资讯，将要排序的元素分配至某些“桶”中，藉以达到排序的作用，基数排序法是属于稳定性的排序，其时间复杂度为O (nlog(r)m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的比较性排序法。
 

package com.sanjiesanxian.sort.test;

/**
 * 所有排序算法的集合
 * **/
public class AllSort {

	static int datas[] = { 5, 2, 1, 3, 6,100,0,-9,999,12 };

	public static void main(String[] args) {

		// bubbleSort();
		// selectSort();
		//insertSort();
//	/	print("打印数组", datas);
 
		
		
		//shellSort1(datas, datas.length);
		
		//quickSort(datas, 0, datas.length-1);
	 	//print("\n打印数组", datas);
		
		
		
	}
	
	/**
	 * @param a 待排序的数组
	 * @param n 数组的长度
	 * 
	 * **/
	public static void shellSort1(int []a,int n){
		//gap为步长，每次减为原来的一半
		for(int gap=n/2;gap>0;gap/=2){
			//共有gap个组,对每一个组都执行直接插入排序
			
			for(int i=0;i<gap;i++){
				
				for(int j=i+gap;j<n;j+=gap){
					//如果a[j]<a[j-gap].则寻找a[j]位置，并将后面的数据的位置都后移
				if(a[j]<a[j-gap]){
					int tmp=a[j];
					int k=j-gap;
					while(k>=0&&a[k]>tmp){
						a[k+gap]=a[k];
						k-=gap;
					}
					a[k+gap]=tmp;
				}	
					
					
				}
			}
			
			
			
		}
		
	}
	
	
	/**
	 * 
	 * 对希尔排序中的单个组进行排序
	 * 
	 * @param a 待排序的数组
	 * @param n 数组总的长度
	 * @param i 组的起始位置
	 * @param gap 组的增量间隔
	 * 
	 *拆开2个方法
	 * 
	 * **/
	public static void groupSort(int[] a,int n,int i,int gap){
		
		for(int j=i+1;j<n;j+=gap){
			//如果a[j]<a[j-gap].则寻找a[j]位置，并将后面的数据的位置都后移
		if(a[j]<a[j-gap]){
			int tmp=a[j];
			int k=j-gap;
			while(k>=0&&a[k]>tmp){
				a[k+gap]=a[k];
				k-=gap;
			}
			a[k+gap]=tmp;
		}	
			
			
		}
		
		
	}
	
	/**
	 * 希尔排序，拆分版
	 * @param a 待排序的数组
	 * @param n 数组的长度
	 * 
	 * */
	public static void shellSort2(int []a ,int n){
		
		
		//gap为增量，每次减少为原来的一半
		for(int gap=n/2;gap>0;gap/=2){
			//共gap个组，对每一组都执行直接插入排序
			for (int i = 0; i < gap; i++) {
				groupSort(a, n, i, gap);
			}
		}
		
		
	}
	
	
	
	
	
	
	

	/**
	 * 冒泡排序
	 * 
	 * 排序原理： 通过两层循环控制， 外层循环，控制查找第i层的数，在余下的数据里最小或最大的
	 * 内层循环，负责依次比较下标相邻的两个数的大小，并负责将小数或大数的位置替换
	 * 
	 * 每次的比较，都是上次在内存中替换完的新数组比较
	 * 
	 * **/
	public static void bubbleSort() {

		System.out.print("排序前： ");
		for (int t : datas) {
			System.out.print(t + " ");
		}

		System.out.println();
		for (int i = 0; i < datas.length; i++) {

			for (int j = i + 1; j < datas.length; j++) {
				int temp = 0;
				System.out.println("i=" + i + " datas[i]=" + datas[i] + "  , "
						+ "j=" + j + " datas[j]=" + datas[j]);
				if (datas[i] > datas[j]) {
					temp = datas[j];
					datas[j] = datas[i];
					datas[i] = temp;
				}
				System.out.print("数组内容: ");
				for (int t : datas) {
					System.out.print(t + " ");
				}
				System.out.println("");

			}

			System.out.println("\n===========外部下面=============");
			for (int t : datas) {
				System.out.print(t + " ");
			}
			System.out.println("");

		}
		// System.out.print("排序后： ");
		// for(int t:datas){
		// System.out.print(t+" ");
		// }

	}
	
	/**
	 * 
	 * 快速排序的原理
	 * 
	 * 对于一个数组，进行按照某个key值进行拆分，
	 * key值左边的数，统一小于key，key值右边统一大于key
	 * 然后递归对两边的的数组进行排序，
	 * 最后结果整体有序
	 * 
	 * 怎么找到某个key值的点，默认按照取最后一个的数值来进行划分
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 
	 * 快速排序
	 * @param arr 要排序的数组
	 * @param from 开头
	 * @param to 结尾
	 * 
	 * **/
	public static void quickSort(int arr[],int from ,int to){
		//1,5,2,4
		if(from<to){//仅当form<to时，才进行排序
			int temp=arr[to];//temp等于数组最后一位数字
			int i=from-1;//i等于-1；
			for(int j=from;j<to;j++){//j=0；j小于最大的长度to，j++
				if(arr[j]<=temp){//如果arr[j]的元素小于等于最后一位 数字
					i++;//i++；0
					int tempValue=arr[j];
					arr[j]=arr[i];
					arr[i]=tempValue;
				}
				
			//	print("\n循环中的 ", arr);
				
			}
			arr[to]=arr[i+1];
			arr[i+1]=temp;
			//System.out.println("轴的位置: "+arr[i]);
			quickSort(arr, from, i);
			quickSort(arr, i+1, to);
			
		}
		
		
		
		
	}
	
	
	
	

	/**
	 * 打印排序
	 * **/
	public static void print(String info, int datas[]) {
		System.out.print(info + ": ");
		for (int i : datas) {
			System.out.print(i + " ");
		}
	}

	/**
	 * 选择排序
	 * 
	 * 对比数组中前一个元素跟后一个元素的大小， 如果后面的元素比前面的元素小则用一个变量k来记住他的位置，
	 * 接着第二次比较，前面“后一个元素”现变成了“前一个元素”， 继续跟他的“后一个元素”进行比较如果后面的元素比他要小则用变量
	 * k记住它在数组中的位置(下标)，等到循环结束的时候，我们应该找到了最 小的那个数的下标了，然后进行判断，如果这个元素的下标不是第一个元素的下标，
	 * 就让第一个元素跟他交换一下值，这样就找到整个数组中最小的数了。然后找到数组中 第二小的数，让他跟数组中第二个元素交换一下值，以此类推。
	 * 
	 * 
	 * a）第一次循环：记录第一个数的下标 b）将第一个数的值与后面的值相比、如果比后面值大、则将下标值改为后面值所对应的下标。 c）
	 * 第一次循环结束后、如果下标值有改动、说明后面有比此数值小的元素、交换两者位置 d）重复上述操作、直到所有数值都已排序
	 * 
	 * 
	 * 
	 * 
	 * 
	 * **/
	public static void selectSort() {

		print("排序前", datas);
		for (int i = 0; i < datas.length; i++) {

			int lowIndex = i;// 最小值的下标
			for (int j = i + 1; j < datas.length; j++) {
				if (datas[j] < datas[lowIndex]) {
					lowIndex = j;
				}
			}

			// 当lowindex的值与i的不一致时，就进行交换
			if (lowIndex != i) {
				int temp = datas[i];
				datas[i] = datas[lowIndex];// 找到最小值付给当前的值
				datas[lowIndex] = temp;// 最小值下标的等于
			}
			// print("\n排序", datas);

		}

		print("\n排序后", datas);
	}

	/**
	 * 插入排序 基本思想：在要排序的一组数中，假设前面(n-1) [n>=2] 个数已经是排
	 * 好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数
	 * 也是排好顺序的。如此反复循环，直到全部排好顺序。
	 * 
	 * 
	 * 
	 * **/
	public static void insertSort() {

		print("插入排序前: ", datas);
		for (int i = 0; i < datas.length; i++) {
			// 取出当前要插入的值
			int insertVal = datas[i];
			// 拿当前要插入的值和前一位比，一直比到第一位
			int index = i - 1;
			while (index >= 0 && datas[index] > insertVal) {
				// 如果插入的值比前一位小，则将前一位的值，赋给插入位置，再拿当前值，和前一位比
			   //每次迭代都把最小的值放在前面
				datas[index + 1] = datas[index];
				index--;
			}
			datas[index + 1] = insertVal;
			
			
			print("\n排序中: ", datas);
		}

		print("\n插入排序后: ", datas);

	}

}



package com.sanjiesanxian.sort.test;

/**
 * 桶排序
 * 
 * */
public class BucketSort {

	
	
	/**
	 * 桶排序
	 * @param a 待排序数组
	 * @param max 数组a中最大值的范围
	 * **/
	public static void bucketSort(int[] a,int max){
		int buckets[];
		if(a==null||max<1){
			return;
		}
		//创建一个为max的数组buckets，并且将buckets中所有数据初始化为0
		buckets=new int[max];
		//1，计数
		for(int i=0;i<a.length;i++){
			buckets[a[i]]++;
		}
		
		//排序
		
		for(int i=0,j=0;i<max;i++){
			while((buckets[i]--)>0){
				a[j++]=i;
			}
		}
		buckets=null;
		
	}
	
	public static void print(String info,int a[]){
		System.out.print(info);
		for(int aa:a){
			System.out.print(aa+"  ");
		}
		System.out.println();
	}
	
	
	public static void main(String[] args) {
		
		//不支持负数排序
		int a[]={1,5,2,88,9};
		print("排序前: ", a);
		bucketSort(a, 89);
		print("排序后: ", a);
	}
	
	
	
}





package com.sanjiesanxian.sort.test;

/**
 * 堆排序
 * 
 * **/
public class HeapSort {

	
	/**
	 * 最大堆的向下调整算法
	 * 
	 * 数组实现的堆中，第N个节点左孩子的索引值是2N+1，右孩子的索引值是2N+2
	 * 其中，N为数组下标索引值，如数组中第一个数对应的N为0
	 * 
	 * @param a  待排序的数据
	 * @param start 被下调节点的起始位置 一般从0开始，表示从第一个开始
	 * @param  end  截至范围一般为数组中最后一个元素索引
	 * 
	 * **/
	public static void maxHeapDown(int []a ,int start,int end){
		int c=start; //当前节点的位置
		int l=2*c+1; //左孩子的位置
		
		int tmp=a[c]; //当前节点的大小
		for(;l<=end;c=l,l=2*l+1){
			//l 是左孩子，l+1是右孩子
			
			if(l<end&&a[l]<a[l+1]){//最大堆
			//	if(l<end&&a[l]>a[l+1]){//最小堆
				 
				l++; //左右两孩子里面选择较大者，即为_heap[l+1]
			}
			if(tmp>a[l]){//最大堆
				//if(tmp<=a[l]){//最小堆
				break;
			}else{
				a[c]=a[l];
				a[l]=tmp;
				
			}	
		}
		
	}
	
	 /**
	  * 堆排序从小到大
	  * 
	  * @param a  排序的数组
	  * @param n  数组的长度
	  * 
	  * */
	public static void heapSortAsc(int [] a,int n){
		int i,tmp;
		//从(n/2-1)--->0逐次遍历，遍历之后，得到的数组，实际上是一个最大的二叉堆
		
		for(i=n/2-1;i>=0;i--){
			maxHeapDown(a, i, n-1);
		}
		
		//从最后一个元素开始对序列，进行调整，不断的缩小调整的范围，知道第一个元素
		for(i=n-1;i>0;i--){
			//交换a[0]和a[i],交换后a[i]是0....i中最大的
			tmp=a[0];
			a[0]=a[i];
			a[i]=tmp;
			//调整a[0.....i-1],使得a[0....i-1]中最大的
			//即,保证a[i-1]是[0...i-1]中最大的值
			maxHeapDown(a, 0, i-1);
		}
		
		
		
		
	}
	
	
	public static void main(String[] args) {
		
	             int i;
	             int a[] = {1,4,-2,2,7,0,5};
	      
	               print("排序前:", a);
	              
	              heapSortAsc(a, a.length);//升序排列
	              
	               print("排序后:", a);
	                 
	}
	
	public static void print(String info,int a[]){
		System.out.print(info);
		for(int aa:a){
			System.out.print(aa+"  ");
		}
		System.out.println();
	}
	
	
	
	
	
	
	
	
	
	
}






package com.sanjiesanxian.sort.test;


/**
 * 
 * 归并排序
 * 
 * */
public class MergeSort {

	/**
	 * 将一个数组中两个相邻有序的区间合并成一个
	 * 
	 * @param a 包含有序区间的数组
	 * @param start  第一个有序区间的开始地址
	 * @param mid  第一个有序区间的结束地址，也是第二个有序区间的开始地址
	 * @param end 第二个有序区间的结束地址
	 * 
	 * */
	public static void merge(int []a,int start,int mid,int end){
		int []temp=new int[end-start+1];
		int i=start; //第一个有序区索引
		int j=mid+1; //第二个有序区的索引
		int k=0;  //临时区域的索引
		
		while(i<=mid&&j<=end){
			if(a[i]<=a[j]){
				temp[k++]=a[i++];
				
			}else{
				temp[k++]=a[j++];
			}
		}
		
		while(i<=mid){
			temp[k++]=a[i++];
		}
		
		while(j<=end){
			temp[k++]=a[j++];
		}
		
		for(i=0;i<k;i++){
			a[start+i]=temp[i];
		}
		
		
		temp=null;
		
	}
	
	
	
	
	
	
	
	
	/**
	 * 归并排序从上向下
	 * 
	 * a待排序的数组
	 * start数组的起始地址
	 * end 数组的结束地址
	 * 
	 * */
	
	public static void mergeSortUp2Down(int []a,int start,int end){
		if(a==null||start>=end){
			return;
		}
		
		int mid=(end+start)/2;
		mergeSortUp2Down(a, start, mid);//递归排序a[start...mid]
		mergeSortUp2Down(a, mid+1, end);//递归排序a[mid+1...end]
		
		//a[start...mid] 和 [mid+1...end] 两个有序空间
		//将他们排序成一个有序的空间a[start....end]
		merge(a, start, mid, end);
		
	}
	
	/***
	 * 对数组a做若干次合并: 数组a的总长度为len，将它分为若干个长度为gap的子数组；
	 * 将每2个相邻的子数组，进行合并排序
	 * 
	 * @param   a    待排序的数组
	 * @param   len  数组的长度
	 * @param   gap  子数组的长度
	 * **/
	
	public static void mergeGroups(int []a,int len,int gap){
		
		int i;
		int twolen=2*gap; //两个相邻子数组的长度
		
		//将每2ge相邻的子数组，进行合并排序
		for(i=0;i+2*gap-1<len;i+=(2*gap)){
			merge(a, i, i+gap-1, i+2*gap-1);
			
			
			//若i+gap-1< len-1 ,则剩余一个子数组没有配对
			//将该子数组合并到已排序的数组中
			if(i+gap-1<len-1){
				merge(a, i, i+gap-1, len-1);
			}
			
		}
		
	}
	
	/**
	 * 归并排序(从下往上)
	 * 
	 * @param a 待排序的数组
	 * **/
	public static void mergeSortDown2Up(int[]a){
		if(a==null){
			return;
		}
		for(int n=1;n<a.length;n*=2){
			mergeGroups(a, a.length, n);
		}
		
	}
	
	
	public static void main(String[] args) {
		
	 int []a={3,4,-1,44,32,9};
	 
	 print("排序前: ", a);
	 mergeSortUp2Down(a, 0, a.length-1);
	 print("排序后: ", a);
	 
	 
	}
	
	/**
	 * 输出排序
	 * 
	 * */
	private static void print(String info,int arr[]){
		
		System.out.println(info);
		for(int a:arr){
			System.out.print(a+" ");
		}
		System.out.println();
	}
	
	
	
	
	
	
	
	
	
	
	
	
	
}




package com.sanjiesanxian.sort.test;


/***
 * 
 * 不支持负数
 * 基数排序
 * */
public class RadixSort {
	
	 /*
	      * 获取数组a中最大值
	      *
	      * 参数说明：
	      *     a -- 数组
	      *     n -- 数组长度
	      */
	     private static int getMax(int[] a) {
	         int max;
	 
	         max = a[0];
	        for (int i = 1; i < a.length; i++)
	           if (a[i] > max)
	                max = a[i];
	
	         return max;
	     }
	 
	     /*
	      * 对数组按照"某个位数"进行排序(桶排序)
	      *
	      * 参数说明：
	      *     a -- 数组
	      *     exp -- 指数。对数组a按照该指数进行排序。
	     *
	      * 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；
	      *    (01) 当exp=1表示按照"个位"对数组a进行排序
	      *    (02) 当exp=10表示按照"十位"对数组a进行排序
      *    (03) 当exp=100表示按照"百位"对数组a进行排序
	      *    ...
	      */
	     private static void countSort(int[] a, int exp) {
	         //int output[a.length];    // 存储"被排序数据"的临时数组
	         int[] output = new int[a.length];    // 存储"被排序数据"的临时数组
	         int[] buckets = new int[10];
	
	         // 将数据出现的次数存储在buckets[]中
	         for (int i = 0; i < a.length; i++)
	             buckets[ (a[i]/exp)%10 ]++;
	 
	         // 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。
	         for (int i = 1; i < 10; i++)
	             buckets[i] += buckets[i - 1];

	        // 将数据存储到临时数组output[]中
	         for (int i = a.length - 1; i >= 0; i--) {
	             output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];
	             buckets[ (a[i]/exp)%10 ]--;
	         }
	 
	        // 将排序好的数据赋值给a[]
	         for (int i = 0; i < a.length; i++)
	            a[i] = output[i];
	 
	         output = null;
	         buckets = null;
	     }
	
	     /*
	     * 基数排序
	      *
	      * 参数说明：
	      *     a -- 数组
	    */
	    public static void radixSort(int[] a) {
	        int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...
	         int max = getMax(a);    // 数组a中的最大值
	 
	         // 从个位开始，对数组a按"指数"进行排序
	         for (exp = 1; max/exp > 0; exp *= 10)
             countSort(a, exp);
	     }

	    public static void print(String info,int a[]){
			System.out.print(info);
			for(int aa:a){
				System.out.print(aa+"  ");
			}
			System.out.println();
		}
		
	    
	    public static void main(String[] args) {
			//不支持负数排序
	    	int a[]={1,5,2,88,9};
			print("排序前: ", a);
			 radixSort(a);
			print("排序后: ", a);
		}
}




分享到：
| JAV程序解析搜狗词库scel文件格式
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java经典算法教程：快速排序-代码非常清晰小白也能看懂

    在这个教程中，我们将深入探讨快速排序的工作原理，并提供一个Java示例来演示如何实现它。无论您是新手还是有经验的Java开发者，通过学习这个算法，您将获得一个强大的排序工具，有助于解决各种排序问题。 快速排序...

    Java实现直接插入排序和折半插入排序算法示例

    主要介绍了Java实现直接插入排序和折半插入排序算法示例,文中对算法的思想和时间复杂度都有简单的讲解,需要的朋友可以参考下

    java实现基数排序算法

    基数排序的关键思想是按照数字的个位、十位、百位等逐个进行计数排序，从最低位到最高位。在每个位上，使用计数排序来稳定地排序数组。通过多次迭代，对所有位进行排序后，最终得到有序的数组。 在示例代码中，我们...

    JAVA基础课程讲义

    绘制各种图形示例 207 图像处理 208 加载图片示例 208 图片任意缩放并输出新图片 209 使用JMF处理音频和视频 211 JMF的下载 211 JMF的安装和配置 211 使用JMF播放音频文件 212 上机作业 213 第十二章 GUI编程之AWT ...

    Thinking in Java 中文第四版+习题答案

    1.11 Java和因特网 1.11.1 什么是Web？ 1.11.2 客户端编程 1.11.3 服务器端编程 1.11.4 一个独立的领域：应用程序 1.12 分析和设计 1.12.1 不要迷失 1.12.2 阶段0：拟出一个计划 1.12.3 阶段1：要制作什么？ 1.12.4 ...

    java基础案例与开发详解案例源码全

    2.4 Java类库组织结构和文档27 2.5 Java虚拟机简介28 2.6 Java技术两种核心运行机制29 2.7 上机练习30 第3章 3.1 变量32 3.1.1 什么是变量32 3.1.2 为什么需要变量32 3.1.3 变量的声明和赋值33 3.1.4 变量应用实例33...

    C／C++常用算法手册.秦姣华(有详细书签).rar

    阐述到位 算法思想、算法实现和完整示例合理搭配，相辅相成。 示例完善 示例分析精准，代码注释精确，每段代码皆可通过编译执行。 计算机技术的发展和普及不仅改变了人们的生活和娱乐方式，也改变了人们的工作方式...

    数据结构与算法程序示例。常用算法思想总结归档。使知识体系化.zip

    算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...

    程序设计抽象思想：C语言描述-

    图书目录 第Ⅰ部分 预备知识 　第1章 ANSI C概述1 　1.1 什么是C 　1.2 C程序的结构 　1.3 变量、值和类型 　1.4 表达式 　1.5 语句 　1.6 函数 　1.7 小结 ...　2.2 数据和内存 ...　第17章 展望Java

    Java弱引用实现源码-DataStructure::kiss_mark::kiss_mark:数据结构、算法总结、学习算法的时间复杂度、空间复杂度、分析算法特点以及应用、Java面

    下面的算法都打包在一个应用当中，你只需要下载安装即可，里面有算法的介绍，时间复杂度，空间复杂度，代码示例 二叉树的遍历 二叉排序树 红黑树 AVL树 图的邻接表存储构成图 有向图的创建 拓扑排序-邻接矩阵存储-...

    数组：删除排序数组中的重复项双指针Java实现

    数组相关的算法问题，一般都可以使用双指针完成操作，有异步指针、快慢指针等，其实就是一种升维的思想，通过一个指针访问数组就相当于一维，用两个指针操作数组，就会出现两个数组同时存在的效果，这就是升维的一种...

    java外部注册机源码-CSS143B:CSS143B

    熟悉高级编程技术（递归、泛型编程、堆栈、队列、树、搜索和排序）。 强调算法思想和实现之间的联系。 关键信息 约会时间 下午 5:45 - 晚上 7:45 讲师 博士。 电子邮件 （[CSS143] 必须显示在主题上） 讲座地点 第 ...

    astar算法matlab代码-Coursework:该资料库包含所有已完成的课程，包括思想，扩展和讨论

    该资料库包含选定的已完成的课程，以及思想，扩展和讨论。 第一学期3年 Java_软件_开发 包含两个项目，分别是游戏和图像编辑器 C_OS 包含示例计划策略的实现。 Java_Algorithm_Correctness_and_Efficiency 包含用于...

    thinkinjava

    1.11 Java和因特网 1.11.1 什么是Web？ 1.11.2 客户端编程 1.11.3 服务器端编程 1.11.4 一个独立的领域：应用程序 1.12 分析和设计 1.12.1 不要迷失 1.12.2 阶段0：拟出一个计划 1.12.3 阶段1：要制作什么？ 1.12.4 ...

    编写可读代码的艺术.[美]Dustin Boswell,Trevor Foucher(带详细书签)

    本书解释了这种思想，并且用不同语言的大量例子来讲解，包括C++、Python、JavaScript和Java。我们避免使用某种高级的语言特性，所以即使你不是对所有的语言都了解，也能很容易看懂。（以我们的经验，反正可读性的大...

    算法思维导图【全面】.xmind.zip

    总结常规排序算法：选则、冒泡、插入、希尔、归并、快排、桶排序等，涵盖：设计思想、时间复杂度、空间杂度度、稳定性、使用场景、代码示例等。

    ARCH4系统开发指南

    2.1.3 查询排序 11 2.2 如何执行HQL查询 11 2.3 如何执行SQL查询 12 2.4 如何使用Mail 12 2.4.1 确保资源文件正确 12 2.4.1.1 确认mail.properties文件设置正确 12 2.4.1.2 确认applicationContext-mail.xml文件设置...

    Visual C++ 2010入门经典(第5版)--源代码及课后练习答案

    　Ivor Horton是撰著Java、C和C++编程语言图书的杰出作家之一。大家一致认为，他的著作独具风格，无论是编程新手，还是经验丰富的编程人员，都很容易理解其内容。在个人实践中，Ivor Horton也是一名系统顾问。他从事...

    Visual C++ 2005入门经典--源代码及课后练习答案

    Ivor Horton还著有Beginning Visual C++ 6、Beginning C Programming和Beginning Java 2等多部入门级好书。 目录 封面 -18 前言 -14 目录 -9 第1章　使用Visual C++ 2005编程 1 1.1　.NET Framework 1 1.2　CLR 2...

    javaSE代码实例

    第6章　对象和类——Java世界的细胞　77 6.1　面向对象概述　77 6.1.1　面向对象程序设计思想的诞生　77 6.1.2　面向过程与面向对象思想的对比　78 6.1.3　面向对象技术的背景和特点　79 6.2　类的定义与对象的创建...

Magicbox
Global site tag (gtag.js) - Google Analytics