数据结构中八大排序算法

版权声明:本文为博主原创文章,转载请注明出处。 https://blog.csdn.net/tan313/article/details/51146170

一、冒泡排序

思想:重复走访过要排序的序列,一次比较两个元素,如果他们的顺序错误就将他们进行交换,一次冒上来的是最小的,其次是第二小。

时间复杂度:O(n^2)

空间复杂度:O(1)

稳定性:稳定

1.

/**
	 * 冒泡排序
	 * @param disOrderArray
	 * @return
	 */
	public static int[] BubbleSort(int[] disOrderArray) {
		int temp;
		// 第一层循环:表明比较的次数, 比如 length 个元素,比较次数为 length-1 次(肯定不需和自己比)
		for(int i=0;i<disOrderArray.length-1;i++)
		{
			// 把最小的数交换着"冒泡"的相对的最上边,一次冒上来的是最小的,其次是第二小的.
			for(int j=disOrderArray.length-1;j>i;j--)
			{
				//此处为<时其返回是从小到大排序,>时其返回从大到小
				if(disOrderArray[j] < disOrderArray[j-1])
				{
					temp = disOrderArray[j];
					disOrderArray[j] = disOrderArray[j-1];
					disOrderArray[j-1] = temp;
				}
			}
		}
		return disOrderArray;
	}

二、快速排序

思想:通过一趟排序将待排记录分割成两个部分,其中一部分记录关键字均比另一部分记录的关键字小,则可以分别对这两部分关键字继续排序,以达到整个序列有序的目的。

时间复杂度:O(nlogn),最坏的情况下为O(n^2)

空间复杂度:O(1)

稳定性:不稳定

	/*
	*
	* 快速排序
	*
	* 思想: 
	* 通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分的关键字小,
	* 则可以分别对这两部分记录继续进行排序,已达到整个序列有序的目的
	* 
	* 本质就是,找一个基位(枢轴,分水岭,作用是左边的都比它小,右边的都比它大.可随机,取名base
	* 首先从序列最右边开始找比base小的
	* ,如果小,换位置,从而base移到刚才右边(比较时比base小)的位置(记为临时的high位),这样base右边的都比base大
	* 然后,从序列的最左边开始找比base大的
	* ,如果大,换位置,从而base移动到刚才左边(比较时比base大)的位置(记为临时的low位),这样base左边的都比base小
	* 
	* 循环以上两步,直到 low == heigh, 这使才真正的找到了枢轴,分水岭. 返回这个位置,分水岭左边和右边的序列,分别再来递归
	*/
	public static int[] quickSort(int[] arr, int low, int heigh) {
		if(low < heigh)
		{
			int division = partition(arr, low, heigh);
			
			quickSort(arr, low, division - 1);
			
			quickSort(arr, division + 1, heigh);
		}
		return arr;
	}

	// 分水岭,基位,左边的都比这个位置小,右边的都大
	private static int partition(int[] arr, int low, int heigh) {
		int base = arr[low]; //用子表的第一个记录做枢轴(分水岭)记录
		while (low < heigh)
		{  
			//更改下面两个while循环中的<=和>=,即可获取到从大到小排列
			//从表的两端交替向中间扫描,从小到大排列
			while (low < heigh && arr[heigh] >= base)
			{
				heigh--;
			}
			
			// 如果高位小于base,base 赋值给 当前 heigh 位,base 挪到(互换)到了这里,heigh位右边的都比base大
			swap(arr, heigh, low);
			
			while(low < heigh && arr[low] <= base)
			{
				low++;
			}
			
			// 如果低位大有base,
			swap(arr, heigh, low);
		}
		
		//现在low=heigh
		return low;
	}

	//交换大小
	private static void swap(int[] arr, int heigh, int low) {
		int temp = arr[heigh];
		arr[heigh] = arr[low];
		arr[low] = temp;
	}

三、直接选择排序:

思想:每一趟排序将会选择出最小的(或者最大的)值,顺序放在已排好序的数列的后面

时间复杂度:O(n^2)

空间复杂度:O(1)

稳定性:不稳定

	/**
	 * 直接选择排序
	 * 直接选择排序每一趟选择出最小的值
	 * @param arr
	 * @return
	 */
	public static int[] selectionSort(int[] arr) {
		for(int i=0;i<arr.length;i++)
		{
			for(int j=i+1;j<arr.length;j++)
			{
				if(arr[i] > arr[j])
				{
					int temp = arr[j];
					arr[j] = arr[i];
					arr[i] = temp;
				}
			}
		}
		return arr;
	}

四、堆排序

思想:堆排序利用这种堆这种数据结构所设计的一种排序算法,可以利用数组的特点快速定位指定索引的元素

时间复杂度:O(nlogn)

空间复杂度:O(1)

稳定性:不稳定

	/**
	 * 堆排序
	 * 堆排序(Heapsort)是指利用堆这种数据结构所设计的一种排序算法,可以利用数组的特点快速定位指定索引的元素。
	 * @param arr
	 * @return
	 */
	public static int[] heapSort(int[] arr) {
		int i;
		// 将arr构成一个大顶堆
		// 从 0 到 arr.length/2 ,这些都是有孩子的节点
		// 没孩子的节点构造大顶堆就无意义了
		for (i = arr.length / 2; i >= 0; i--)
		{
			heapAdjust(arr, i, arr.length - 1);
		}
		for (i = arr.length - 1; i > 0; i--)
		{
			swap(arr, 0, i);
			// 将arr[0...i-1] 重新构造成一个大顶堆
			heapAdjust(arr, 0, i - 1);
		}
		return arr;
	}

	private static void heapAdjust(int[] arr, int s, int m) {
		int temp, j;
		temp = arr[s]; // 指向临时(相对与root节点)的根节点
		for (j = 2 * s; j <= m; j *= 2) 
		{
			// 如果右节点比左节点大,当前节点移到右节点
			if (j < m && arr[j] < arr[j + 1])
			{
				// 指向右节点
				j++;
			}
			// 当前的父节点大于现在指向的节点
			// 不需要做任何处理
			if (temp >= arr[j])
			{
				break;
			}
			
			// 当前的父节点小于其下的子节点
			// 换位置,把这个子节点替换到父节点
			// 当前这个位置,如果是叶子节点,则它应该是最小的(相对于它的祖先们)
			// 这个方法目的就是交换parent与children的值,构造大根堆
			 
			// 执行到这里表明当前节点的父节点(临时根节点小于当前的节点),
			// 把当前节点移到上面,换位置
			// arr[s]被覆盖无所谓,因为temp记了这个值(原来的根节点(相对的parent))
			arr[s] = arr[j];
			 
			// 现在把当前的这个元素,看做是临时的parent节点
			// 为了找到此时这个元素的孩子节点,看看是否有比当前这个值还大的
			// 最后s指向 当前遍历到的这个元素
			s = j;
		}
		arr[s] = temp;
	}



五、插入排序

思想:将一个记录插入到一个已排好序的有序表中,从而得到一个新的、记录增1的有序表。默认将第一个元素看为有序表,然后依次插入后边的元素

时间复杂度:O(n^2)

空间复杂度:O(1)

稳定性:稳定

	/**
	 * 插入排序
	 * 思想:将一个记录插入到已排好序的有序表中,从而得到一个新的、记录数增1的有序表,
	 * 默认将第一个元素看为有序表,一次插入后边的所欲元素
	 * 时间复杂度O(n^2)
	 * 空间复杂度O(1) 适用于记录数量小的
	 * @param arr
	 * @return
	 */
	public static int[] InsertSort(int[] arr) {
		//从小到大排列
		for(int i=1;i<arr.length;i++)
		{
			//待插入元素
			int temp = arr[i];
			int j;
			for(j=i-1;j>=0 && temp < arr[j];j--)
			{
				//待插入元素小于已有的,就将已有往后挪,直到元素大于插入元素或已经到序列最首端了
				arr[j+1] = arr[j];
			}
			arr[j+1] = temp;
		}
		return arr;
	}

六、折半插入排序

思想:折半插入排序是基于直接插入排序进行改写的,其可以减少"移动"和"比较"的次数

时间复杂度:O(n^2)

空间复杂度:O(1)

稳定性:稳定

	/**
	 * 折半插入排序
	 * 优点:可以减少"比较"和"移动"的次数
	 * @param arr
	 * @return
	 */
	public static int[] BInsertSort(int[] arr){
		for(int i=1;i<arr.length;i++)
		{
			//待插入元素
			int temp = arr[i];
			int j;
			int low = 0, high = i-1;
			while(low <= high)  //在arr[low..high]中折半查找有序插入的位置
			{
				int m = (low + high)/2;//折半
				if(temp < arr[m])
				{
					high = m-1;  //插入点在低半区
				}
				else
				{
					low = m+1;  //插入点在高半区
				}
			}
			
			//记录后移
			for(j=i-1;j>=high+1;j--)
			{
				arr[j+1] = arr[j];
			}
			arr[j+1] = temp;
		}
		return arr;
	}

七、希尔排序:

思想:希尔排序也是插入排序的一种,是直接针对插入排序进行改进的,该方法又称为"缩小增量排序"。

时间复杂度:O(n^2)

空间复杂度:O(1)

稳定性:不稳定

	/**
	 * 希尔排序(缩小增量排序)
	 * 希尔排序也是插入排序的一种,只是其有增量,而且最后一次增量必须为1
	 * @param arr
	 * @return
	 */
	public static int[] ShellInsert(int[] arr){
		int step = arr.length/2; //取增量
		//保证最后一个增量为1
		while(step >= 1)
		{
			for(int i=step;i<arr.length;i++)
			{
				int temp = arr[i];
				int j = 0;
				
				//根插入排序的区别在这里
				for(j=i-step;j>=0 && temp<arr[j];j-=step)
				{
					arr[j+step] = arr[j];
				}
				arr[j+step] = temp;
			}
			step /= 2;
		}
		return arr;
	}

八、归并排序

思想:归并排序是将两个或两个以上的有序表组合成一个有序表,该算法是采用分治法实现

时间复杂度:O(nlogn)

空间复杂度:O(n)

稳定性:稳定

	/**
	 * 归并排序
	 * 归并排序是将两个或两个以上的有序表组合成一个新的有序表
	 * 时间复杂度 O(nlog2n)
	 * @param arr
	 * @param tempArray
	 * @param left
	 * @param right
	 * @return
	 */
	public static int[] mergeSort(int[] arr, int left,int right) {
		if (left < right)
		{
			// 取分割位置
			int middle = (left + right) / 2;
			// 递归划分数组左序列
			mergeSort(arr, left, middle);
			// 递归划分数组右序列
			mergeSort(arr, middle+1, right);
			//将左数组和右数组进行归并
			Merge(arr, left, middle, right);
		}
		return arr;
	}

	private static void Merge(int[] arr, int left, int middle,int right) {
		int[] tempArray = new int[arr.length];  
		int leftEnd = middle;
		int rightStart = middle+1;
		// 临时数组的下标
		int tempIndex = left;
		int tmp = left;
		
		// 先循环两个区间段都没有结束的情况
		while ((left <= leftEnd) && (rightStart <= right))
		{
			// 左边的比右边的小,先插入左边的
			if (arr[left] < arr[rightStart])
			{
				tempArray[tempIndex++] = arr[left++];
			}
			else
			{
				tempArray[tempIndex++] = arr[rightStart++];
			}
		}
		
		// 判断左序列是否结束
		while (left <= leftEnd)
		{
			tempArray[tempIndex++] = arr[left++];
		}
		
		// 判断右序列是否结束
		while (rightStart <= right)
		{
			tempArray[tempIndex++] = arr[rightStart++];
		}
		
		// 将临时数组中的内容拷贝回原数组中  
        // (原left-right范围的内容被复制回原数组)
		while (tmp <= right) {  
            arr[tmp] = tempArray[tmp++];  
        } 
	}

九、基数排序

思想:基数是按照低位先排序,然后收集;再按高位排序,然后再收集,依次类推,直到最高位。

注:表示关键词分类到radix(基数)个盒子,在关键词为数字时,基数为10,当关键词为字母时,基数为26

时间复杂度:O(n+d)

空间复杂度:O(n)

稳定性:稳定

	/**
	 * 基数排序
	 * @radix 基数 表示  按关键词分类到radix(基数)个盒子  在关键词为数字时,基数为10
	 * @d 排序元素的位数  
	 * @return
	 */
	public static int[] RadixSort(int[] arr, int radix, int d){
		//用于暂存元素
		int[] temp = new int[arr.length];
		//用于计数排序
		int[] count = new int[radix];
		int divide = 1;
		
		for(int i=0;i<d;i++)
		{
			System.arraycopy(arr, 0, temp, 0, arr.length);
			
			// 重置count数组,开始统计下一个关键字  
			Arrays.fill(count, 0);
			
			// 计算每个待排序数据的子关键字  
			for(int j=0;j<arr.length;j++)
			{
				int tempKey = (temp[j]/divide)%radix;
				count[tempKey]++;
			}
			
			for(int j=1;j<radix;j++)
			{
				count[j] = count[j] + count[j-1];
			}
			
			// 按子关键字对指定的数据进行排序  
			for(int j=arr.length-1;j>=0;j--)
			{
				int tempKey = (temp[j]/divide)%radix;
				count[tempKey]--;
				arr[count[tempKey]] = temp[j];
			}
			
			divide = divide * radix;
		}
		return arr;
	}


public static void main(String[] args) {
		//基础默认从小到大排列
//		int[] disOrderArray = {3,1,5,7,0};
		//冒泡排序
//		disOrderArray = BubbleSort(disOrderArray);
		
		//快速排序
//		disOrderArray = quickSort(disOrderArray, 0, disOrderArray.length-1);
		
		//直接选择排序
//		disOrderArray = selectionSort(disOrderArray);
		
		//堆排序
//		disOrderArray = heapSort(disOrderArray);
		
		//直接插入排序
//		disOrderArray = InsertSort(disOrderArray);
		
		//折半插入排序(二分查找排序)
//		disOrderArray = BInsertSort(disOrderArray);
		
		//希尔排序
//		disOrderArray = ShellInsert(disOrderArray);
		
		//归并排序
//		disOrderArray = mergeSort(disOrderArray, 0, disOrderArray.length-1);
		
		//基数排序
		int[] disOrderArray = {3,2,3,2,5,333,45566,2345678,78,990,12,432,56};
		
		disOrderArray = RadixSort(disOrderArray, 10, 7);
		for(int i=0;i<disOrderArray.length;i++)
		{
			System.out.print(disOrderArray[i]+" ");
		}
	}

数据结构基本的排序算法基本都全了。


添加一个二分查找算法:类似于折半查找算法

时间复杂度:O(logn)

	/**
	 * 二分查找
	 * @param arr
	 * @param searchnum 待查找元素
	 * @return
	 */
	public static int BSearch(int[] arr, int searchnum){
		int low = 0;
		int high = arr.length-1;
		while(low<=high)
		{
			int m = (low+high)/2;
			if(searchnum == arr[m])
			{
				return m;
			}
			else if(searchnum < arr[m])
			{
				high = m-1;
			}
			else
			{
				low = m+1;
			}
		}
		return -1;
	}



展开阅读全文

没有更多推荐了,返回首页