数据结构-八大排序--java实现

最新推荐文章于 2022-02-28 13:17:35 发布
最新推荐文章于 2022-02-28 13:17:35 发布
阅读量397 收藏
点赞数
分类专栏： 数据结构 自我思考 文章标签： java 数据结构 算法 排序算法 快速排序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/S_xy_god/article/details/107784833
版权

八大排序–java实现

最近在做面试题，遇到Partition函数，看剑指offer并没看懂，于是自己琢磨，感觉很熟悉，于是决定看下排序算法，发现这就是快速排序。写次博客，也方便以后自己查找简单。

冒泡排序

冒泡排序最为简单，学C语言，首先就是学会冒泡排序。自我理解：
从第一个开始，如果前一个大于后一个，两两交换，则会使得最大的数一直向后移。遍历完一遍后，最大的数就是最后一个数。然后从头开始，遍历除了最后一个以外的数，则第二个数也会沉底。以此类推，完成排序。
整个过程看起来就像是一连串泡泡，逐渐变大，所以称作冒泡排序。

package sort;
//冒泡排序，最为熟悉的排序
public class Bubble_sort {

	private void Bubble_sort(int[] a) {
		// TODO Auto-generated constructor stub
		for(int i=0;i<a.length-1;i++) {
			for(int j=0;j<a.length-i-1;j++) {
				if(a[j]<a[j+1]) {
					int temp =a[j];
					a[j] = a[j+1];
					a[j+1] = temp;
				}
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[]{9,6,4,5,7,3,2};
		Bubble_sort s= new Bubble_sort();
		s.Bubble_sort(a);
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+",");
		}
	}

}

插入排序

插入排序和冒泡排序有异曲同工之妙。插入排序：将一个数插入到其合适的位置。
默认第一个数为排序好的数，若第二个数大于他就放在其后，小于它则放在它前面。
第三个数则在前面两个数中选择合适位置进行插入。相应的数字向后移即可。
以此类推，完成数组排序。

package sort;
//插入排序
public class insert_sort {

	public static void insert_sort(int[] a) {
		// TODO Auto-generated constructor stub
		for(int i=0;i<a.length;i++) {
			int num = a[i];
			int j;
			for(j=i;j>0&&num<a[j-1];j--) {
				a[j] = a[j-1];//数组后移
			}
			a[j] =num;//找到位置，插入进去
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[]{9,6,4,5,7,3,2};
		insert_sort(a);
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+",");
		}	
	}
}

希尔排序

希尔排序是在插入排序的基础上选择步长进行插入。我的理解：
设定步长h，间隔为步长的n/h个数进行插入排序，则此n/h个数已经完成排序。循环后移，完成所有间隔为h的数排序。
减小步长，直至减为1，进行插入排序。
希尔排序相比插入排序，减少了遍历的次数，提高了相率。后续进行学习复杂度再来比较其真正的不同。

package sort;

public class Shell_sort {

	public static void Shell_sort(int[] a) {
		// TODO Auto-generated constructor stub
		int h= a.length/2;
		for(;h>=1;h/=2) {
			for(int i=0;i<a.length;i+=h) {
				int num = a[i];
				int j;
				for(j=i;j>0 && num<a[j-h];j-=h) {
					a[j] = a[j-h];//数组后移
				}
				a[j]=num;
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[]{9,6,4,5,7,3,2,1,4,9,50,20,32};
		Shell_sort(a);
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+",");
		}
	}

}

选择排序

选择排序的思想比较简单：从数组中选取最小的数将其放在起始位置，逐步选取，然后填充即可。

package sort;

public class Selection_sort {

	public static void Selection_sort(int[] a) {
		// TODO Auto-generated constructor stub
		int min;
		for(int i=0;i<a.length-1;i++) {
			min = i;
			for(int j=i+1;j<a.length;j++) {
				if(a[min]>a[j]) {
					min = j;
				}
			}
			if(a[min]!=a[i]) {
				int temp = a[i];
				a[i] = a[min];
				a[min] = temp;
			}
		}
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[]{9,6,4,5,7,3,2,1,4,9,50,20,32};
		Selection_sort(a);
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+",");
		}
	}
}

以上四个排序算法比较简单，看一看文档以及相关博客即可理解思想，完成编程。
下面四个算法相对比较难，多思考，看着程序想想实现，就会明白的。

快速排序

快速排序就是开头说的partition函数。其中心思想为：
选定一个数，比它小的放前面，比它大的放后面。再分为对小数组和大数组进行递归快速排序，直至完成所有数字排序。
如何实现：
选取两个指针（一个从前向后遍历，一个从后向前遍历），一个基数 m， 找到第一个比它小的数，指针停留，找到第一个比它大的指针，两个指针所指向的数进行交换，然后指针再次移动，直至两个指针相遇，于是我们找到了m所对应的位置，进行交换。

生动形象的一个介绍快速排序的文档：生动形象的快速排序
快速排序的优化可针对基数的选取进行优化，不进行随机选取，而选择中间的数进行优化。

package sort;
//递归版本的快速排序
public class Quick_gui_sort {

	public static void Quick_sort(int[] a,int low,int high) {
		// TODO Auto-generated constructor stub
		if(low>=high) {
			return;
		}
		int left = low;
		int right = high;
		int pri = a[left];
		/*while (left < right) {
			while (left < right && a[right] >= pri) {
				right--;
			}
			a[left] = a[right];
			while (left < right && a[left] <= pri) {
				left++;
			}
			a[right] = a[left];
		}
		a[left] = pri;
		Heap_sort(a, low, left - 1);
		Heap_sort(a, left + 1, high);*/
		while(left<right) {
			while(left<right && a[right]>=pri) {
				right--;
			}
			while(left<right && a[left]<=pri) {
				left++;
			}
			if(left<right) {
				//找到了需要交换的数
				int temp = a[left];
				a[left] = a[right];
				a[right] = temp;
			}
		}
		//将pri放在他应该在的位置
		int temp = a[left];
		a[left] = pri;
		a[low] = temp;
		//继续排序前面一个数组和后面一个数组
		Quick_sort(a, low, left - 1);
		Quick_sort(a, left + 1, high);
	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[]{9,6,4,5,7,3,2};
		Quick_sort(a,0,a.length-1);
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+" ");
		}
	}
}

基数排序

基数排序是非常有趣的一种排序，据说一般不会问到，但我认为基数排序比较有趣，于是写了下来。
基数排序的理解：
找到最大的数，获取其位数，将比它小的数前面填充0。然后对每个数的每一位进行遍历。这里就需要一个桶，用来存放某个位数上相同的数。
先遍历个位，将各位相同的放入一个桶中，输出数组，在对十位进行排序，逐位排序，输出。遍历完之后就得到了最终的排序结果。

package sort;

import java.util.ArrayList;
import java.util.List;

public class radix_sort {
    public static void main(String[] args) {
        int[] a = {542, 3521, 13459, 852, 742, 46, 2, 1, 633, 32};
        System.out.println("Before Sort the Array is:");
        for (int array : a
                ) {
            System.out.print(array + " ");
        }
        // 调用基数排序
        myRadixSort(a);
        System.out.println();
        System.out.println("After Sort the Array is:");
        for (int array : a
                ) {
            System.out.print(array + " ");
        }
    }

    public static void myRadixSort(int[] arr) {
    	//获取数组的最大数
    	int max = 0;
    	for(int i=0;i<arr.length;i++) {
    		if(max<arr[i]) {
    			max = arr[i];
    		}
    	}
    	//确定最大数的位数
    	int time = 0;
    	while(max>0) {
    		max = max/10;
    		time++;
    	}
    	//初始化十个桶
    	ArrayList<ArrayList> num_list = new ArrayList();
    	for(int i=0;i<10;i++) {
    		ArrayList<Integer> list1 = new ArrayList();
    		num_list.add(list1);
    	}
    	
    	for(int i=0;i<time;i++) {
    		//对应数字存入对应桶中
    		for(int j=0;j<arr.length;j++) {
    			int x = (arr[j] % (int)Math.pow(10, i+1) / (int)Math.pow(10, i));
    			num_list.get(x).add(arr[j]);
    		}
    		
    		//从桶中取出数，然后进行递归高位排序
    		int index=0;
    		for(int j=0;j<10;j++) {
    			while(num_list.get(j).size()>0) {
    				ArrayList<Integer> sma_list = num_list.get(j);
    				arr[index] = sma_list.get(0);
    				sma_list.remove(0);
    				index++;
    			}
    		}	
    	}	
    }
}

归并排序

归并排序是指一种分而治的思想，和快速排序有点相似。快速排序是从大范围向小范围的并。递归排序是小范围向大范围的并。
我的理解：将数组进行细分，分到单一数组之后，进行两两排序合并，逐渐合并到原来数组，完成排序。
思想：
（1）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列
（2）设定两个指针，最初位置分别为两个已经排序序列的起始位置
（3）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置
（4）重复步骤3直到某一指针达到序列尾
（5）将另一序列剩下的所有元素直接复制到合并序列尾

推荐文档: link.

归并排序有两种实现方式：
1. 递归法
2. 迭代法
代码如下

package sort;
//归并排序的递归实现
import java.util.Arrays;

public class Gb_sort {

	public  void Gb_sort(int[] a,int low,int high) {
		// TODO Auto-generated constructor stub
		int mid = low+(high-low)/2;
		if(low<high) {
			Gb_sort(a,low,mid);
			Gb_sort(a,mid+1,high);
			merge(a,low,mid,high);
		}
	}
	private  void merge(int[] a,int low,int mid,int high) {
		int left = low;
		int right = mid+1;
		int index = 0;
		int[] t = new int[high-low+1];
		while(left<=mid && right<=high) {
			//分为之后，根据大小填入数组t
			if( a[left]<a[right]) {
				t[index++] = a[left++];	
			}else {
				t[index++] = a[right++];
			}
		}
		//将多余的数填入数组t
		while(left<=mid) {
			t[index++] = a[left++];
		}
		while(right<=high) {
			t[index++] = a[right++];
		}
		for(int k=0;k<t.length;k++) {
			a[low+k]=t[k];
		}
		
		System.out.println("temp::"+Arrays.toString(t));
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		int[] a = new int[]{9,6,4,5,7,3,2};
		Gb_sort g= new Gb_sort();
		g.Gb_sort(a,0,a.length-1);
		for(int i=0;i<a.length;i++) {
			System.out.print(a[i]+",");
		}
	}

}


package sort;
 
import java.util.Arrays;
 
//迭代的方式进行  归并排序
public class Gb_iter_sort {
 
	private static void gb_iter_sort(int[] a,int low,int high) {
		int left_begin = 0;
		int left_end = 0;
		int right_begin = 0;
		int right_end = 0;
		int[] temp = new int[high-low+1];
		int index=0;
		for(int i=low;i<high;i*=2) {
			//low传入的1，所以不会影响
			for(left_begin = 0;left_begin<high-i;left_begin=right_end) {
				//必须添加“left_begin = 0”，如果不添加，当步长为1的循环跳出后，left_begin=high-2（因为high=a.length），
				//不会进入接下来的循环
				left_end = left_begin+i;
				right_begin = left_begin+i;
				right_end = right_begin+i;
				
				if(right_end>high) {
					right_end = high;
				}
				while(left_begin<left_end && right_begin<right_end) {
					//这里之所以不采用<=，是因为left_end = left_begin+i;
					//right_begin = left_begin+i;right_end = right_begin+i;
					//end超出选取数组的范围
					if(a[left_begin]<a[right_begin]) {
						temp[index++] = a[left_begin++];
					}else {
						temp[index++] = a[right_begin++];
					}
				}
				if(left_begin<left_end) {
					temp[index++] = a[left_begin++];
				}
				if(right_begin<right_end) {
					temp[index++] = a[right_begin++];
				}
				
				while(index>0) {
					//即控制了index，又省去了右边多余数组在添加一遍的时间复杂度
					a[--right_begin] = temp[--index];
				}
				System.out.println("temp:"+Arrays.toString(temp));
			}
		}
	}
	
	
	
	public static void main(String[] args) {
 
		
//		int[] arr={5,7,1,9,2,6,3,4};
		int arr[] = { 5, 2, 6, 0, 3, 9, 1, 7, 4, 8 };
		System.out.println("迭代合并--排序前："+Arrays.toString(arr));
		gb_iter_sort(arr, 1, arr.length);
		System.out.println("迭代合并--排序后："+Arrays.toString(arr));
		
	}
 
}

堆排序

堆排序是我认为八大排序里面最难的排序，所以放在最后面分析。看了许多博客都没太看懂，所以上B站找了视频，幸运的是，第一个就明白了，分享给大家。：堆排序的详细解释
经过学习后，明白了那些博客上写的，先建堆，然后对堆进行排序，我相信看了视频的你会理解的。

package sort;
/**
 * 堆排序演示
 *
 */
public class Heap_sort {
    public static void main(String[] args) {
        int[] tree = {5, 1, 7, 3, 1, 6, 9, 4};
        //int[] tree = {16, 7, 3, 20, 17, 8};
        //heapity(tree, tree.length, 0);
        //build_heap(tree, tree.length);
        heapSort(tree,tree.length);
        for (int i : tree) {
            System.out.print(i + " ");
        }
    }
    
    /*
	*排序，先进行建堆，建好之后的堆符合根节点最大，叶子节点小于根节点
	*之后我们将最后一个节点与最大的节点（根节点）进行交换，置换之后的字树也会进行随之改动。
	*最后进行递归，即可完成堆排序。
	*/
    private static void heapSort(int[] tree,int n) {
    	build_heap(tree, n);
    	for(int i=n-1;i>=0;i--) {
    		swap(tree,i,0);
    		heapity(tree, i, 0);
    	}
    	
    }
    /*
     * 调整堆
     * 1.获取左叶子节点和右子节点。取三者中的最大值放入根节点。
     * 2.若是需要进行调换，则进行递归，保证交换之后的子树也符合最大堆的原则。而不交换的子树不进行改变。
     */
    private static void heapity(int []tree,int n,int i) {
    	if(i>=tree.length) {
    		return;
    	}
    	int lchild = i*2+1;
    	int rchild = i*2+2;
    	int max = i;
    	
    	if(lchild<n && tree[lchild] > tree[max]) {
    		max = lchild;
    	}
    	if(rchild<n && tree[rchild] > tree[max]) {
    		max = rchild;
    		
    	}
    	
    	if(max!=i) {
    		swap(tree,max,i);
    		heapity(tree, n,max);
    	}
    }
    private static void swap(int[] tree,int i,int max) {
    	int temp = tree[i];
    	tree[i] = tree[max];
    	tree[max] = temp;
    }
    
    /*
     * 建立堆
     * 使整个二叉树符合堆：
     * 		从下向上的递归，即可保证最大堆的建立。
     * */
    private static void build_heap(int[] tree, int length) {
    	int last_node = length-1;//最后一个节点
    	int parent = (last_node-1)/2;//最后一个根节点
    	for(int i=parent;i>=0;i--) {
    		heapity(tree, length, i);
    	}
    }
}

感觉排序算法还是很多没搞明白，接下来要对每个算法的时间复杂度和空间复杂度进行分析，力求透彻。加油！！！

董滴答滴จุ๊บ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】排序算法（Java实现）
Slimshady的博客
06-26 518
文章目录排序算法排序算法说明算法复杂度总结冒泡排序（Bubble Sort）选择排序（Selection Sort）插入排序（Insertion Sort）希尔排序（Shell Sort）归并排序（Merge Sort）快速排序（Quick Sort）堆排序（Heap Sort） 排序算法 排序算法说明 排序的定义 对一序列对象根据某个关键字进行排序。 术语说明 稳定 ：如果a原本在b前面，并且a=b，则排序之后a仍然在b的前面； 不稳定 ：如果a原本在b的前面，而a=b，则排序之后a可能会出现在b的后面
「Java」- 八大排序
「zero」的博客
11-09 1974
冒泡排序 原理:在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序 一次排序过程
数据结构------常见的八种排序(Java实现)
零度
01-23 1023
数据结构-排序部分了解排序排序分类1.插入排序1.1 直接插入排序1.2 希尔排序2.选择排序2.1 直接选择排序2.2 堆排序3.交换排序3.1 了解排序 排序: 所谓排序,就是使一串记录,按照其中的某个或某些关键字的大小,递增或者递减排列起来的操作. 稳定性: 在一组元素中可能存在相等的元素,如果经过排序,这些记录的相对次序保持不变,那么认为这种排序是稳定的,否则是不稳定的. 如下图所示. 排序分类 1.插入排序 基本思想: 把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中,直
java实现 数据结构之8大排序
like的专栏
09-29 1413
现在来写写数据结构，感觉还是有点陌生，应该多练练，有需要的朋友可以看看。 * 冒泡排序 * 插入排序 * 选择排序 * shell排序 * 堆排序 * 归并排序 * 二叉树排序 * 快速排序
Java数据结构和算法（九）——高级排序
IT可乐
02-15 399
&#13; 　　春晚好看吗？不存在的！！！&#13; 　　在Java数据结构和算法（三）——冒泡、选择、插入排序算法中我们介绍了三种简单的排序算法，它们的时间复杂度大O表示法都是O(N2)，如果数据量少，我们还能忍受，但是数据量大，那么这三种简单的排序所需要的时间则是我们所不能接受的。接着我们在讲解递归的时候，介绍了归并排序，归并排序需要O(NlogN)，这比简单排序要快了...
Java数据结构（排序篇）
aodiyi6351的博客
05-22 77
冒泡排序：是经过n-1趟子排序完毕的，第i趟子排序从第1个数至第n-i个数，若第i个数比后一个数大（则升序，小则降序）则交换两数。大泡在上，小泡在下。 选择排序：每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到所有待排序的数据元素排完。 选择排序是不稳定的排序方法。 插入排序：有一个已经有序的数据序列，要求在这个已经排好的数据序列中插...
用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip
最新发布
09-15
在本压缩包“用Java实现基础数据结构，排序算法、经典算法以及leetcode刷题记录-Java-下载.zip”中，包含的是一个Java编程项目，主要目的是通过代码实践来理解和掌握数据结构、排序算法以及经典的计算机算法。...
java实现数据结构常见排序算法及详解
11-08
### Java 实现数据结构常见排序算法及详解 #### 排序算法概述 排序算法是计算机科学中的基础概念之一，主要用于将一系列数据按照特定规则进行排列。根据数据处理方式的不同，排序算法大致分为两大类：比较排序与非...
数据结构----排序算法总结（Java）
ITCSDN_的博客
08-29 1992
排序算法总结---建议收藏排序算法概述一：冒泡排序（BubbleSorting） 1.冒泡排序简要概述 2.冒泡排序图解 3.代码实现 排序算法概述   所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。排序算法，就是如何使得记录按照要求排列的方法。排序算法在很多领域得到相当地重视，尤其是在大量数据的处理方面。一个优秀的算法可以节省大量的资源。在各个领域中考虑到数据的各种限制和规范，要得到一个符合实际的优秀算法，得经过大量的推理和分析。 一：冒泡排序（BubbleSo
Java实现八大排序算法
09-18
在这里，我们将深入探讨Java实现的八大排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序、归并排序、堆排序以及计数排序。 1. **冒泡排序（Bubble Sort）**：冒泡排序是一种简单直观的排序算法，...
学生成绩信息输入排序输出
04-25
数据结构程序代码 利用C++ 将多个（自定义）学生成绩信息输入 按总成绩排序输出
数据结构（五）：java实现八大排序算法
qq_41623154的博客
04-29 477
今天重新梳理下排序算法，用java实现。 直接插入排序 思想：直接插入排序，从第二个位置开始与前面的值比较，按照关键字的大小进行排序。每次比较时，前面的队列都是有序排列的。 import java.util.Arrays; public class TestInsertSort { public static void main(String[] args) { ...
数据结构中排序算法 Java实现
unstoppable_t的博客
02-01 223
1.插入排序 基本思想：每一步将一个待排序的数据插入到前面已经排好序的有序序列中，直到插完所有元素为止。 每次选择无序区间的第一个元素，在有序区间选择合适的位置插入。当取第一个元素时认为是有序的，第二次从数组的第二个数据开始往前比较，即一开始用第二个数和他前面的一个比较，如果符合条件（比前面的大或者小），则让它们交换位置。 代码实现 public static void insertSort(int[] array){ for (int i = 1; i < array.leng
java中的数据结构--排序
flyuniverse_shell的专栏
04-22 2157
注意：包java.util中的类Arrays定义了对数组按升序进行排序的静态方法sort的几个版本。 对于元素是对象的数组，sort使用归并排序。方法： public static void sort(Object[] a); 对整个对象数组a排序，而方法： public static void sort(Object[] a, int first, int last);   包jav
数据结构-Java实现-排序
Hello code！
12-20 949
直接插入排序 希尔排序（二分插入） 简单选择排序 堆排序 归并排序 快速排序 冒泡排序 桶式排序（基数排序） 1、直接插入排序 插入排序由N-1趟排序组成，对于p=1到p=N-1趟，保证位置0到p上的元素为已排序状态。在第p趟，将位置p上的元素向左移动到正确位置。 S(N)=O(N^2) public static super AnyType>> void insertionSort
Java数据结构—排序算法
我们都是被分成两半的人，一边热爱生活，一边憎恨生活。面对生活，我们总是在矛盾的两端摇摆，在反复的矛盾和犹豫中，一边踉跄前行，一边重振旗鼓。我渴望改变，渴望变得更好，渴望找到出口……就像一个溺水人的挣扎，就像一个救生圈。我是一个矛盾集合体，想要变得快乐，但是
10-25 442
排序算法选择排序选择排序代码实现插入排序选择排序代码算法希尔排序法希尔排序代码实现快速排序快速排序代码实现代码归并排序归并排序代码实现 选择排序 基本介绍 选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出某一元素，再依规定交换位置后达到 排序的目的。 选择排序思想 选择排序(select sorting)也是一种简单的排序方法。它的基本思想是:第一次从arr[0]~arr[n-1]中选取最小值，与arr[0]交换，第二次从ar[1]-ar[n-1]中选取最小值， 与ar[1]交换,第三次从r
【Java数据结构】常见排序详解
weixin_46913665的博客
02-28 1377
文章目录 一、排序的概念和分类 1.排序的基本概念 2.排序的稳定性 二、常见排序 1.直接插入排序 2.希尔排序 3.简单选择排序 4.堆排序 5.冒泡排序 6.快速排序 6.1.递归快速排序 6.1.1.快排优化 6.2.非递归方式实现 7.归并排序
数据结构之排序算法（Java代码实现）
Jake Weng
08-18 468
排序算法的作用就是将无序的数组按升序或降序排列。 一、选择排序 选择排序，就是在每一次大小比较中，为数组的每个位置选出大小适当的值，比如：如果要将数组进行升序排列，那么要为数组的第一个位置选出最小的值，第二个位置选出次大的值。 假设需要对一个整形数组{45, 38, 66, 90, 88, 10, 25}进行升序排序，选择排序的步骤如下： 第一步：为第一个位置（数组索引为0）选出最小的值 ...
关于数据结构算法中的比较排序（附Java代码实现）
Surrounder的博客
10-09 300
     现在已经是10月份，秋招正在进行，不知道是不是有的人会和我一样正在疯狂的复习起数据结构，在这里我将就常见的几种比较排序做一些简单的解析，同时附上具体的代码实现。 1.冒泡排序 冒泡排序通常是我们最先接触道的比较排序的一种，具体排序步骤如下： 1.比较相邻的元素，如果前一个比后一个大（小），就把它们两个调换位置； 2.对每一对相邻元素做同样的工作，从开始从开始第一对到结尾的最后一对...
数据结构Java八大排序
09-06
Java八大排序是指在Java语言中常用的八种排序算法。其中包括堆排序、冒泡排序、选择排序、快速排序、插入排序、希尔排序、归并排序和基数排序。 堆排序是一种利用堆这种数据结构而设计的排序算法。它的时间复杂度为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值