数据结构-各类排序算法

最新推荐文章于 2024-07-27 16:12:17 发布
最新推荐文章于 2024-07-27 16:12:17 发布
阅读量300 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38332722/article/details/88956848

在这里插入图片描述

1. 交换排序

冒泡排序

思想：将数据进行两两比较，共循环 n-1次；每次循环确定一个数的位置，全局有序，如：第一次循环将元素两两比较，确定最大或者最小值放在数组的最后一个位置length-1。第二次循环比较未确定位置的元素(n-1)，得出无序中的最值放在数组的倒数第二个位置length-2…

  • 时间复杂度：

    • 最好时间复杂度：当数据有序时外循环只需一次就可以得出结果。
    • 最坏时间复杂度：当数据逆序时，外循环需要循环n-1次。
    • 平均时间复杂度：

  • 稳定性：稳定。

  • 代码：

    package 交换排序算法;

import java.util.Arrays;
//冒泡排序算法
public class BubbleSort {

	public static void main(String[] args) {
		int[] arr = new int[]{1,2,3,4,5,7,6};
		System.out.println(Arrays.toString(arr));
		BubbleSort.bubbleSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 冒泡排序
	 * @param arr
	 */
	public static void bubbleSort(int[] arr) {
		for(int i = 0;i < arr.length-1 ;i++) {
			for(int j = 0 ;j<arr.length - 1 - i;j++) {
				if(arr[j] > arr[j+1]) {
					arr[j] = arr[j] + arr[j+1];
					arr[j+1] = arr[j] - arr[j+1];
					arr[j] = arr[j] - arr[j+1];
				}
			}
		}
	}
	
	public static void bubbleSort1(int[] arr) {
		boolean flag = true;
		int count = 0;
		for(int i = 0 ;i<arr.length - 1;i++) {//比较length-1次就可以了
			flag = true;
			for(int j = 0; j < arr.length - 1 - i;j++) {//第一轮确定一个数，第二轮确定两个数.....
				if(arr[j] > arr[j+1]) {
					arr[j] = arr[j] + arr[j+1];
					arr[j+1] = arr[j]-arr[j+1];
					arr[j] = arr[j] - arr[j+1];
					flag = false;
				}
			}
			count++;
			if(flag) {//说明这一趟没有交换，数组已经有序
				break;
			}
			
		}
		System.out.println(count);
	}
}
快速排序

思想：
（1）确定数组中的第一个元素的位置：将第一个元素作为标准stard，
从数组的最后一个元素arr[j]和stard比较，如果值比它大，则j–，继续将从后往前和stard比较，直到找到比stard小的元素arr[j]，将arr[j]替换arr[i]；
然后从前往后和stard的比较，如果值比它小，则i++，否则退出循环，将arr[i]替换arr[j]；当i=j时说明元素已经比较完，stard的位置已经确定，将stard替换arr[i]/arr[j]。
（2）递归计算stard左边的元素。
（3）递归计算stard右边的元素。

  • 时间复杂度：

    • 最好时间复杂度：
    • 最差时间复杂度：
    • 平均时间复杂度：

  • 稳定行：

  • 代码

    package 交换排序算法;

import java.util.Arrays;

public class QuickSort {

	public static void main(String[] args) {
		int[] arr = new int[] {4,1,3,5,2,8,6,7};
		quickSort(arr, 0, arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 快速排序：一次循环只能确定一个数的位置
	 * @param arr
	 * @param start
	 * @param end
	 */
	public static void quickSort(int[] arr,int start,int end) {
		if(start < end) {//如果start = end 表示只有一个数，不需要排序
		
			//将数组的第一个元素作为标准数
			int stard = arr[start];
			//记录需要排序的下标
			int low = start;
			int high = end;
			//循环找出比标准数大的数和比标准数小的数
			while(low < high) {
				//右边的数字和标准数比较，当右边的数字比标准数小时退出循环
				while((arr[high] >= stard) && (low<high)) high--;
				//让右边比标准数小的数替换左边的数
				arr[low] = arr[high];
				//左边的数字标准数比较，当左边的数字大于标准数时退出循环
				while((arr[low] < stard) && (low<high)) low++;
				//让左边比标准数大的数替换右边的数
				arr[high] = arr[low];
			}//当low = high时退出循环,此时这个数已经赋值到其它位置，需要被标准数替换
			//已经找到标准数相对于数组的位置，比左边的数大，比右边的数小，但是左、右里面的大小位置不确定
			arr[low] = stard;
			
			//处理左边的数字
			quickSort(arr,start,low-1);
			//处理右边的数字
			quickSort(arr,low+1,end);
		}
	}
}

2. 选择排序

简单选择排序

  • 时间复杂度：

    • 最好时间复杂度：
    • 最差时间复杂度：
    • 平均时间复杂度：

  • 稳定行：

  • 代码：

    package 选择排序;

import java.util.Arrays;

public class SelectSort {

	public static void main(String[] args) {
		int[] arr = new int[] { 4, 5, 2, 3, 1, 4, 6 };
		selectSort1(arr);
		System.out.println(Arrays.toString(arr));
	}

	/**
	 * 选择排序算法1:只要找到比第一个小的都交换
	 * @param arr
	 */
	public static void selectSort(int[] arr) {
		for (int i = 0; i < arr.length - 1; i++) {
			for (int j = i + 1; j < arr.length; j++) {
				 if(arr[j] < arr[i]) {
				 arr[j] = arr[j] + arr[i];
				 arr[i] = arr[j] - arr[i];
				 arr[j] = arr[j] - arr[i];
				 }
			}
		}
	}
	
	/**
	 * 简单选择排序
	 * 选择排序算法2：找到还未排序的元素中最小值的下标，如果下标和未排序的第一个下标
	 *               不一致则交换
	 * @param arr
	 */
	public static void selectSort1(int[] arr) {
		for(int i = 0; i < arr.length-1;i++) {
			int minIndex = i;
			for(int j = i+1;j<arr.length;j++) {
				if(arr[j] < arr[minIndex]) {
					minIndex = j;
				}
			}
			if(minIndex != i) {
				arr[minIndex] = arr[minIndex] + arr[i];
				arr[i] = arr[minIndex] - arr[i];
				arr[minIndex] = arr[minIndex] - arr[i];
			}
		}
	}
}
堆排序

思想：
1.构造初始堆：将待排序的元素构造成一个大根堆

  • [1] 根据元素顺序构造一个完全二叉树。
  • [2] 从最后一个非终节点开始构造一个大跟堆。

2.堆排序：

  • [1] 将第一个节点和最后一个交换。
  • [2] 重新调整最后一个以外的树，调成为一个大跟堆（第一步）。

  • 时间复杂度：

    • 最好时间复杂度：
    • 最差时间复杂度：
    • 平均时间复杂度：

  • 稳定性：

  • 代码

   package 选择排序;

   import java.util.Arrays;

  //堆排序
  public class HeapSort {
	public static void main(String[] args) {
		int[] arr = new int[] {9,6,8,7,0,1,10,4,2};
		heapSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void heapSort(int[] arr) {
		//开始位置是最后一个非叶子节点，即最后一个节点的父节点
		int start = (arr.length-1)/2;
		//调整为大跟堆
		for(int i=start;i>=0;i--) {
			maxHeap(arr,arr.length,i);
		}
		//先把数组中的第0个和堆中的最后一个数交换位置，再把前面的处理为大跟堆
		for(int i = arr.length-1;i>0;i--) {
			int temp = arr[0];
			arr[0] = arr[i];
			arr[i] = temp;
			maxHeap(arr,i,0);
		}
	}
	public static void maxHeap(int[] arr,int size,int index) {
		//左子节点
		int leftNode = 2*index+1;
		//右子节点
		int rightNode = 2*index+2;
		int max = index;
		//和两个子节点分别对比，找出最大的节点
		if(leftNode<size && arr[leftNode] > arr[max]) {
			max = leftNode;
		}
		if(rightNode<size && arr[rightNode] > arr[max]) {
			max = rightNode;
		}
		//交换
		if(max != index) {
			int temp = arr[max];
			arr[max] = arr[index];
			arr[index] = temp;
			//交换位置以后，可能会破坏之前的大根堆，所以，之前排好的堆需要重新调   整
			maxHeap(arr,size,max);
		}
	}
   }

package _52.数据流中的中位数;

import java.util.Arrays;

/**
 * 堆排序：大根堆
 * @author Administrator
 *
 */
public class HeapSort {
	
	public static void main(String[] args) {
		int[] arr = {1,4,3,5,2,6};
		maxHeapSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 堆排序的入口
	 * @param arr
	 */
	public static void maxHeapSort(int arr[]){
		//1.从堆的最后一个非叶子结点开始构造一个大根堆
		int start = (arr.length-1-1) / 2;//最后一个非叶子结点,下标从0开始的
		for(int i = start; i >= 0; i--){
			maxShift(i,arr.length - 1,arr);
		}
		System.out.println(Arrays.toString(arr));
		//2.将大根堆中的第一个元素和最后一个元素交换，交换后的最后一个元素就确定了自己的位置
		for(int i = arr.length - 1; i > 0; i--){
			arr[0] = arr[0] + arr[i];
			arr[i] = arr[0] - arr[i];
			arr[0] = arr[0] - arr[i];
			
			maxShift(0,i-1,arr);
		}
	}

	/**
	 * 调整大根堆
	 * @param low	需要调整的堆的根结点
	 * @param high	堆的最后一个结点
	 */
	public static void maxShift(int low,int high,int arr[]){
		//需要调整的堆的根结点
		int root = low;
		//左孩子结点
		int left = 2*low+1;
		while(left <= high){
			//找出左孩子结点和右孩子结点中值最大的一个
			if(left < high && arr[left] < arr[left+1])
				left++;
			//如果孩子结点的最大值比根结点大则交换
			if(arr[left] > arr[root]){
				arr[root] = arr[root] + arr[left];
				arr[left] = arr[root] - arr[left];
				arr[root] = arr[root] - arr[left];
				//交换后可能会破坏left的大根堆，继续调整
				root = left;
				left = 2 * root +1;
			}
			else{
				break;
			}
		}
	}
}

3. 插入排序

思想：将元素分为两个部分：有序部分和无序部分。将无序部分的第一个元素和有序部分的最后一个元素开始比较大小，如果无序的元素比有序的元素大，则将该无序的元素插入到该有序元素的后一个数。

直接插入排序

  • 时间复杂度：

    • 最好时间复杂度：
    • 最坏时间复杂度：
    • 平均时间复杂度：

  • 稳定性：

  • 代码：

    package 插入排序;

import java.util.Arrays;

public interface InsertSort {

	public static void main(String[] args) {
		int[] arr = new int[] {2,5,3,1,4,7,6};
		insertSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 直接插入排序
	 * @param arr
	 */
	public static void insertSort(int[] arr) {
		//对于整个数组
		for(int i = 1 ;i<arr.length;i++) {//需要循环的次数&&对于arr[i]是需要插入的元素
			//将数组分成两部分，arr[i-1]之前有序区，arr[i]之后无序区
			
			//当无序区的第一个数arr[i]小于有序区的最后一个数arr[i-1]时，需要将arr[i]插入到有序区中
			if(arr[i] < arr[i-1]) {
				//把当前需要插入的数字保存起来，以便有序区中比它大的数字向后挪
				int tmp = arr[i];
				
				int j;
				//从有序中确定tmp的位置，比tmp大的数字往后面挪，然后将其插入
				for(j = i-1;j>=0 && tmp < arr[j];j--) {
					arr[j+1] = arr[j];//将该数字往后挪,将该数字的值赋给后一个数字
				}//当j=-1（将tmp插入到有序数组的第0个位置）、tmp>arr[j](将tmp插入到arr[j]的后面）结束循环
				arr[j+1] = tmp;
			}
		}
	}
}
希尔排序

  • 时间复杂度：

    • 最好时间复杂度：
    • 最坏时间复杂度：
    • 平均时间复杂度：

  • 稳定性：

  • 代码：

    package 插入排序;

import java.util.Arrays;

public class ShellSort {
	public static void main(String[] args) {
		int[] arr = new int[] {2,5,7,3,8,1,9,0};
		shellSort(arr);
		System.out.println(Arrays.toString(arr));
	}

	/**
	 * 希尔排序：将数组分成 d=n/2 个组，在每个组中采用直接插入排序
	 * 
	 * @param arr
	 */
	public static void shellSort(int[] arr) {

		int d = arr.length/2;
		while(d>0) {
			for (int i = d; i < arr.length; i++) {//对于arr[d]是需要插入有序列d的元素
				//对于一组中：arr[i-d]之前有序，arr[i]之后无序，需要将arr[i]这个元素插入到有序列中
				if (arr[i] < arr[i-d]) {
					int tmp = arr[i];
					int j;
					for (j = i-d; (j >= 0) && (tmp < arr[j]);) {
						arr[j+d] = arr[j];
						j = j-d;
					} // 循环结束后arr[j]<tmp
					arr[j+d] = tmp;
				}
			}
			d = d/2;
		}
	}
}
折半插入排序：

  • 时间复杂度：

    • 最好时间复杂度：
    • 最差时间复杂度：
    • 平均时间复杂度：

  • 稳定性：

  • 代码：

4. 归并排序

归并思想：将两个有序的数组合并到一个数组

二路归并排序

思想（递归）：将数组左边的元素排好序，将数组右边的元素排好序，将两个有序的数组合并到一个数组。

  • 时间复杂度：

    • 最好时间复杂度：
    • 最坏时间复杂度
    • 平均时间复杂度：

  • 稳定性：

  • 代码：

    package 归并排序;

import java.util.Arrays;

public class MergeSort {
	public static void main(String[] args) {
		int[] arr = new int[] {1,5,3};
		mergeSort(arr,0,arr.length-1);
		System.out.println(Arrays.toString(arr));
	}
	
	/**
	 * 归并算法（递归）
	 * @param arr
	 * @param low
	 * @param high
	 */
	public static void mergeSort(int[] arr,int low,int high) {
		int mid = 0;
		if(low<high) {
			mid = (low+high)/2;	
			mergeSort(arr,low,mid);
			mergeSort(arr,mid+1,high);
			merge(arr,low,mid,high);
		}
	}
	
	/**
	 * 归并：将两个有序的数组合成一个新的有序数组
	 * @param arr
	 * @param low
	 * @param mid
	 * @param high
	 */
	public static void merge(int[] arr,int low,int mid,int high) { 
		//用于存储归并后的临时数组
		int[] temp = new int[high-low+1];
		//记录第一个数组中需要遍历的下标
		int i = low;
		//记录第二个数组中需要遍历的下标
		int j = mid+1;
		//用于记录临时数组的下标
		int index = 0;
		
		//遍历临时数组取出小的数字，放入临时数组中
		while(i <= mid && j<= high) {
			if(arr[i] < arr[j])
			{
				temp[index++] = arr[i];
				i++;
			}
			else {
				temp[index++] = arr[j];
				j++;
			}
		}
		
		//将较长数组的其它元素加入到temp的后面
		while(i <= mid) {
			temp[index++] = arr[i];
			i++;
		}
		while(j <= high) {
			temp[index++] = arr[j];
			j++;
		}
		
		//把临时数组中的数据放入原数组中
		for(int k = 0;k<temp.length;k++) {
			arr[k+low] = temp[k];
		}
	}
}

5. 基数排序

思想：首先找出元素中值最大的元素，获取最大元素的位数来作为循环比较的次数。第一次循环：将元素安个位排序；第二次循环：按十位排序；第三次循环：按百位排序…

  • 时间复杂度：

    • 最好时间复杂度：
    • 最坏时间复杂度：
    • 平均时间复杂度：

  • 稳定性：

  • 代码：

    • 方法一：

      package 基数排序;

import java.util.Arrays;

//用一个二维数组来存比较后的元素，在用一个数组存放二维数组中每个数组的元素个数
public class RedixSort {

	public static void main(String[] args) {
		int[] arr = new int[] {23,6,189,45,9,287,34,56,1,798,652,5};
		radixSort(arr);
		System.out.println(Arrays.toString(arr));
	}
	
	public static void radixSort(int[] arr) {
		//1.先找出数组中的最大值
		int max = Integer.MIN_VALUE;
		for(int i = 0;i < arr.length;i++) {
			if(arr[i] > max) {
				max = arr[i];
			}
		}
		
	    //2.计算最大值的位数
		int maxLength = String.valueOf(max).length();
		
		//3.根据最大值的位数决定要循环的次数:n为除数
		
		//用于临时存储按个位、十位....比较好的元素
		int[][] temp = new int[10][arr.length];
		//用于记录temp数组中每个一位数组中的数组中的元素个数
		int[] counts = new int[10];
		
		for(int i = 0,n=1;i < maxLength;i++,n*=10) {//第一次循环比较个位，第二次循环比较十位，第三次循环比较百位
			
			//将数组中的元素取余后存入桶中
			for(int j = 0 ;j < arr.length;j++) {
				//计算余数
				int ys = arr[j]/n%10;
				temp[ys][counts[ys]] = arr[j];
				//记录数量
				counts[ys]++;
			}
			
			//将桶中的元素一次取出
			int index = 0;
			for(int k = 0;k<counts.length;k++) {
				if(counts[k] != 0) {//判断该桶中的是否有元素
					//遍历取出元素
					for(int m = 0;m<counts[k];m++) {
						arr[index++] = temp[k][m];
					}
					//将counts中的k位置的值为0，以便下一轮存放
					counts[k] = 0;
				}
			}
		}
	}
}

    • 方法二：

      package 基数排序;

//根据桶中"先进先出"的性质：直接用一个队列数组来存放比较后的值
public class RedixSortQueue {

	public static void radixSort(int[] arr) {
		// 1.先找出数组中的最大值
		int max = Integer.MIN_VALUE;
		for (int i = 0; i < arr.length; i++) {
			if (arr[i] > max) {
				max = arr[i];
			}
		}

		// 2.计算最大值的位数
		int maxLength = String.valueOf(max).length();

		// 3.根据最大值的位数决定要循环的次数:n为除数

		// 用于临时存储按个位、十位....比较好的元素
		MyLinkQueue[] temp = new MyLinkQueue[10];

		for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {// 第一次循环比较个位，第二次循环比较十位，第三次循环比较百位
			// 将数组中的元素取余后存入桶中
			for (int j = 0; j < arr.length; j++) {
				// 计算余数
				int ys = arr[j] / n % 10;
				temp[ys].enQueue(arr[j]);
			}

			// 将桶中的元素一次取出
			int index = 0;
			for (int k = 0; k < temp.length; k++) {
				arr[index++] = temp[k].deQueue();
			}
		}
	}
}

package 基数排序;

//队列的链式存储结构
public class MyLinkQueue {

	class DataNode {
		int data;
		DataNode next;
	}

	private DataNode front;// 队首节点
	private DataNode rear;// 队尾节点，一直指向最后一个元素

	public MyLinkQueue() {
		front = new DataNode();
		front.next = null;
		rear = new DataNode();
		rear = null;
	}

	/**
	 * 判断节点是否为空
	 * @return
	 */
	public boolean isEmpty() {
		return rear == null;
	}

	/**
	 * 进队：采用尾插入法，后进队的元素在后面
	 * @param element
	 * @return
	 */
	public boolean enQueue(int element) {
		DataNode data = new DataNode();
		data.data = element;
		if (isEmpty()) {// 如果队列为空，则首节点和尾节点都指向它
			front.next = data;
			rear = data;
			return true;
		} else {//否则，只将尾节点指向它
			// 将新增节点插入到链表的最后面
			rear.next = data;
			// 然后将rear尾节点指向最后一个元素
			rear = data;
			return true;
		}
	}
	
	/**
	 * 出队:出首节点的后节点，因为采用的是尾插入法
	 * @return
	 * @throws RuntimeException
	 */
	public int deQueue() throws RuntimeException{
		if(isEmpty()) {
			throw new RuntimeException("队列为空");
		}
		if(front.next == rear) {//如果队列中只要一个节点时
			int result = front.next.data;
			front.next = null;
			rear = null;
			return result;
		}
		else {
			int result = front.next.data;
			front.next = front.next.next;
			return result;
		}
	}
}
7-冒泡排序&选择排序
sunshine612的博客
03-23 255
十大排序算法详解 冒泡排序:挨个挨个去比较 时间复杂度：O(n^2) 空间复杂度：O（1） 算法稳定性：稳定 原理： 从数组的第一个位置开始两两比较arr[j]和arr[j+1]， 如果arr[j]大于arr[j+1]则交换他两个的位置，直到数组结束； 从数组的第一个位置开始，重复上面的动作，止到数组长度减一个位置结束； 从数组的第一个位置开始，重复上面的动作，止到数组长度减二个位置结束； 例：4...
排序算法（一）直接插入排序
weixin_44792333的博客
12-13 630
直接插入排序是一种基本的插入排序方法，其基本操作是将第i个记录插入到前面第i-1个以排好序的记录中 给出下面这一组数据，要求按从小到大的顺序排序（当然，也可以将其按从小到大排序，这里只说一种） 12 34 5 62 20 45 32 我们先选定第一个数据，此时他是第一位，所以不需要进行其他的操作，我们第二位，他比12大，意识不需要进行任何操作，当我们看到第三...
冒泡排序
weixin_34357928的博客
04-09 92
冒泡排序时间复杂度上为O(n^2) 冒泡排序三种方式，第一种也是最基本的排序： void bubbleSort1(int *arr,int length){ int i,j,k; for(i=0;i&lt;length;i++){ for(j=i+1;j&lt;length;j++){ if(arr[i]&gt;arr[j])...
排序算法：冒泡排序
weixin_33726943的博客
03-05 134
冒泡排序算法的运作如下：（从后往前） ​1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。 3.针对所有的元素重复以上的步骤，除了最后一个。 4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 ...
有序数组和二分查找
执妄
11-23 189
数组优缺点分析 有序数组的优点： 采用二分查找效率高 O(log⁡2n\log_2^nlog2n​) 有序数组的缺点 插入的时候，需要移动元素O(n) 有序数组和无序数组共同缺点 删除的时候都要移动元素O(n) package array; public class ArrayTest2 { //程序的入口 public static void main(String[] args) { OrderArray orderArray = new O
数据结构-各类排序算法总结.doc
10-10
数据结构-各类排序算法总结.doc
数据结构与算法-常用排序算法
evesmith520的博客
02-23 1516
典型的例子是二分查找算法。无论输入规模的大小如何，算法的执行时间都是固定的。例如，访问数组中的一个元素，计算数组的长度等。工作原理：采用分治法，选取一个基准值，将小于基准值的放在左边，大于基准值的放在右边，然后递归地对左右两部分进行排序。工作原理：利用堆的性质（最大堆或最小堆），将待排序数组构建成堆，然后每次取出堆顶元素，重新调整堆，直至完成排序。算法的额外空间使用是一个固定的常数，与输入规模无关。工作原理：是插入排序的改进版，通过比较距离较远的元素进行交换，最终使数据基本有序，然后再使用插入排序。
C语言---内部排序算法的性能分析.zip
11-16
随机产生五组一百个数，存入单链表中，对每组数进行起泡排序、直接插入排序、简单...分别输出采用各种排序算法对每组数据进行排序前的待排序序列和排序后的排序结果序列；分别输出对应5组数据，各类算法比较的结果表。
数据结构中十大排序算法 详解
Hanshy123的博客
07-27 1561
排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
数据结构-复习.pdf【数据结构与算法】常见数据结构知识点复习：线性表、树、图及算法分析与应用
最新发布
05-09
内容概要：本文档《数据结构-复习.pdf》涵盖了数据结构的核心知识点，包括但不限于线性表、栈和队列、广义表、树与二叉树、图、查找算法、排序算法等。文档通过具体题目详细解释了各种数据结构的特点和应用场景，如...
用直接插入法进行数组排序
bool的博客
12-02 1539
用直接插入法进行数组排序
插入排序——直接插入排序
copbint
07-07 575
思路： 对位置i上的元素排序(设为升序)时（设为Ai），假设从0~(i-1)位置上的元素都已经全部排好序。 所以，只需要为Ai在已经排好序的元素中找到合适的位置，并将其插入即可。最朴素的插入算法是直接插入，即从i-1开始，如果Ai小于Ai-1，则交换这两个元素的位置。以此类推，直到比前一个元素大，或者已经被交换到了第一个位置，则结束。 代码： package dataStructureAndAlg...
排序算法-直接插入排序
Move_now的博客
09-30 718
直接插入排序(Straight Insertion Sort)是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。 大致思路就是：把数组中的元素一个一个遍历一遍，寻找该元素应该插入的位置，使得数组有序。待遍历的元素都会用key值记录下来，方便插入操作。其实就是不断地比较、记录key、移位和插入的过程。这里使用算法导论上的图片 ，数组A[6
经典排序算法--冒泡排序
weixin_30871701的博客
05-23 149
冒泡排序的基本思想： 在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。 关于程序中4中冒泡排序写法的说明： bubble_sort1：基本的冒泡排序的写法。 bubble_sort2：基本冒泡排序的不同写法，基本的冒泡排序是每次遍历，每次...
数据结构排序算法之冒泡排序
qq_39431405的博客
11-21 664
数据结构排序算法之冒泡排序（有动图）
数字排序（冒泡排序法）
weixin_30951743的博客
02-24 390
将以组数字以从大到小的顺序排列，也称为冒泡排序法： 比如将下面组数字从大到小排列，我们可以用二个数相比较的方法，首先将第一个数和第二个数相比较，如果第一个数比第二个数大则不动，如果小则交换位置：结果为： 22,10,50, 100, 65, 56, 98, 105, 200, 900,4,1 (第一次排列，即i=0,j循环一次) 22,50, 100, 65, 56, 98, ...
【数算-07】冒泡排序
weixin_45729934的博客
02-02 480
文章目录1、冒泡排序算法思路2、冒泡排序算法图解3、冒泡排序代码实现（已优化） 1、冒泡排序算法思路 2、冒泡排序算法图解 3、冒泡排序代码实现（已优化） 优化思路： import org.junit.Test; import java.lang.reflect.Array; import java.util.Arrays; /** * @author zhihua.li * @date 2021/2/2 - 9:29 **/ public class BubbleSorting {
JAVA实现数据结构排序算法详解
教材的这一章节通常是介绍各类排序算法的理论基础和实现方式，涵盖了从简单到复杂的多种排序技术。 通过JAVA语言实现排序算法，意味着该资源为学习者提供了一种面向对象的编程语言来深入理解各种排序方法。JAVA语言...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值