数据结构之排序算法

最新推荐文章于 2024-03-22 23:21:01 发布

爱吃西瓜的小松鼠

最新推荐文章于 2024-03-22 23:21:01 发布

阅读量193

点赞数

分类专栏：数据结构

本文链接：https://blog.csdn.net/qq_40979622/article/details/93213076

版权

数据结构专栏收录该内容

6 篇文章 0 订阅

订阅专栏

http://www.atool9.com/sort.php 各种排序动图展示

1、冒泡排序

思路：每次比较两个相邻的元素，将较大的元素交换至右端。（每次冒泡排序操作都会将相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足，就交换这两个相邻元素的次序，一次冒泡至少让一个元素移动到它应该排列的位置，重复N次，就完成了冒泡排序。）

2、快速排序

思路：快速排序是一种分治的排序算法 https://blog.csdn.net/shujuelin/article/details/82423852

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

public class QuickSort {
public static void quickSort(int[] arr,int low,int high){
int i,j,temp,t;
if(low>high){
return;
}
i=low;
j=high;
//temp就是基准位
temp = arr[low];

while (i<j) {
//先看右边，依次往左递减
while (temp<=arr[j]&&i<j) {
j--;
}
//再看左边，依次往右递增
while (temp>=arr[i]&&i<j) {
i++;
}
//如果满足条件则交换
if (i<j) {
t = arr[j];
arr[j] = arr[i];
arr[i] = t;
}

}
//最后将基准为与i和j相等位置的数字交换
arr[low] = arr[i];
arr[i] = temp;
//递归调用左半数组
quickSort(arr, low, j-1);
//递归调用右半数组
quickSort(arr, j+1, high);
}

public static void main(String[] args){
int[] arr = {10,7,2,4,7,62,3,4,2,1,8,9,19};
quickSort(arr, 0, arr.length-1);
for (int i = 0; i < arr.length; i++) {
System.out.println(arr[i]);
}
}
}

3、插入法排序

思路：是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。参考：https://blog.csdn.net/qq_42857603/article/details/81605124

æå¥æåºæ³å¨æå¾

public class Insert
{
	public static void main(String[] args)
	{
		int[] ins = {2,3,5,1,23,6,78,34};
		int[] ins2 = sort(ins);
		for(int in: ins2){
			System.out.println(in);
		}
	}

	public static int[] sort(int[] ins){
		
		for(int i=1; i<ins.length; i++){
			int temp = ins[i];//保存每次需要插入的那个数
			int j;
			for(j=i; j>0&&ins[j-1]>temp; j--){//这个较上面有一定的优化
				ins[j] = ins[j-1];//吧大于需要插入的数往后移动。最后不大于temp的数就空出来j
			}
			ins[j] = temp;//将需要插入的数放入这个位置
		}
		return ins;
	}

4、希尔排序

思路：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

https://blog.csdn.net/qq_28081081/article/details/80598960

public class Shell
{
	public static void main(String[] args)
	{
		int[] ins = {2,3,5,1,23,6,78,34,23,4,5,78,34,65,32,65,76,32,76,1,9};
		int[] ins2 = sort(ins);
		for(int in: ins2){
			System.out.println(in);
		}
	}
	public static int[] sort(int[] ins){
		
		int n = ins.length;
		int gap = n/2;
		while(gap > 0){
			for(int j = gap; j < n; j++){
				int i=j;
				while(i >= gap && ins[i-gap] > ins[i]){
					int temp = ins[i-gap]+ins[i];
					ins[i-gap] = temp-ins[i-gap];
					ins[i] = temp-ins[i-gap];
					i -= gap;
				}
			}
			gap = gap/2;
		}
		return ins;
	}
}

5、简单选择排序

思路：第一趟，从n个元素中找出关键字最小的元素与第一个元素交换；第二趟，在从第二个元素开始的n-1个元素中在选出关键字最小的元素与第二个元素交换；如此，第k趟，则从第k个元素开始的n-k+1个元素中选出关键字最小的元素与第k个元素交换，直到整个序列按关键字有序。

public static void test(int[] r) {
        for(int i = 1;i < r.length;i++) {
            int j = i - 1;
            int min = r[j]; //默认第一项是最小的元素
            for(;j<r.length;j++) {
                if(min > r[j]) {//查找剩下的元素的最小值
                    int temp = min;
                    min = r[j];
                    r[j] = temp;
                }
            }
            r[i-1] = min; //把最小值赋值给第一项
        }
    }

6、堆排序

思路：堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

public void HeapAdjust(int[] array, int parent, int length) {
 
    int temp = array[parent]; // temp保存当前父节点
    int child = 2 * parent + 1; // 先获得左孩子
    while (child < length) {
 
        // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
        if (child + 1 < length && array[child] < array[child + 1]) {
            child++;
        }
        // 如果父结点的值已经大于孩子结点的值，则直接结束
        if (temp >= array[child])
           break;
 
        // 把孩子结点的值赋给父结点
        array[parent] = array[child];
 
        // 选取孩子结点的左孩子结点,继续向下筛选
        parent = child;
        child = 2 * child + 1;
    }
    array[parent] = temp;
}
 
public void heapSort(int[] list) {
    // 循环建立初始堆
    for (int i = list.length / 2; i >= 0; i--) {
        HeapAdjust(list, i, list.length);
    }
 
    // 进行n-1次循环，完成排序
    for (int i = list.length - 1; i > 0; i--) {
        // 最后一个元素和第一元素进行交换
        int temp = list[i];
        list[i] = list[0];
        list[0] = temp;
 
        // 筛选 R[0] 结点，得到i-1个结点的堆
        HeapAdjust(list, 0, i);
        System.out.format("第 %d 趟: \t", list.length - i);
        printPart(list, 0, list.length - 1);
    }
}

7、归并排序

思路：归并排序是一种概念上最简单的排序算法，与快速排序一样，归并排序也是基于分治法的。归并排序将待排序的元素序列分成两个长度相等的子序列，为每一个子序列排序，然后再将他们合并成一个子序列。合并两个子序列的过程也就是两路归并。https://blog.csdn.net/qq_36442947/article/details/81612870

è¿éåå¾çæè¿°

import org.junit.Test;
public class MergeSort {
    //两路归并算法，两个排好序的子序列合并为一个子序列
    public void merge(int []a,int left,int mid,int right){
        int []tmp=new int[a.length];//辅助数组
        int p1=left,p2=mid+1,k=left;//p1、p2是检测指针，k是存放指针

        while(p1<=mid && p2<=right){
            if(a[p1]<=a[p2])
                tmp[k++]=a[p1++];
            else
                tmp[k++]=a[p2++];
        }

        while(p1<=mid) tmp[k++]=a[p1++];//如果第一个序列未检测完，直接将后面所有元素加到合并的序列中
        while(p2<=right) tmp[k++]=a[p2++];//同上

        //复制回原素组
        for (int i = left; i <=right; i++) 
            a[i]=tmp[i];
    }

    public void mergeSort(int [] a,int start,int end){
        if(start<end){//当子序列中只有一个元素时结束递归
            int mid=(start+end)/2;//划分子序列
            mergeSort(a, start, mid);//对左侧子序列进行递归排序
            mergeSort(a, mid+1, end);//对右侧子序列进行递归排序
            merge(a, start, mid, end);//合并
        }
    }

    @Test
    public void test(){
        int[] a = { 49, 38, 65, 97, 76, 13, 27, 50 };
        mergeSort(a, 0, a.length-1);
        System.out.println("排好序的数组：");
        for (int e : a)
            System.out.print(e+" ");
    }
}

文章参考：https://blog.csdn.net/Quantum_Dog/article/details/88049735

https://blog.csdn.net/weixin_40205234/article/details/86699088

爱吃西瓜的小松鼠

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
数据结构之排序算法

http://www.atool9.com/sort.php 各种排序动图展示1、冒泡排序思路：每次比较两个相邻的元素，将较大的元素交换至右端。（每次冒泡排序操作都会将相邻的两个元素进行比较，看是否满足大小关系要求，如果不满足，就交换这两个相邻元素的次序，一次冒泡至少让一个元素移动到它应该排列的位置，重复N次，就完成了冒泡排序。）2、快速排序思路：快速排序是一种分治的排序算...
复制链接

扫一扫

专栏目录