常用排序算法总结+源代码

排序

  • 稳定性:排序前后具有相同关键字的记录的相对顺序不发生改变,则该排序算法是稳定的
  • 适用性:排序算法适用于顺序存储结构还是链式存储结构

1.选择排序

  • 首先,找到数组中最小的那个元素,其次,将它和数组的第一个元素交换位置(如果第一个元素就是最小的元素那么它就和自己交换)。再次,在剩下的元素中找到最小的元素,将它于数组的第二个元素交换位置。如此往复,直到整个数组排序。
  • 对于长度为N的数组,选择排序需要大约n(n-1)/2次比较和n次交换
  • 时间复杂度与初始顺序无关
平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
O(n^2)O(n^2)O(n^2)O(1)不稳定
public class Selection {
    public static void sort(Comparable[] a){
        int N = a.length;
        for(int i=0;i<N;i++){
            int min = i;
            for(int j=i+1;j<N;j++){
                if(less(a[j],a[min])) min=j;
            }
            exch(a,i,min);
        }
    }
}

2.插入排序

  • 一个一个元素的来,将每一个元素插入到其他已经有序的元素中的适当位置。
  • 对于随机排列的长度为N的主键不重复的数组,平均情况下插入排序需要n(n-1)/4次比较和n(n-1)/4交换
  • 时间复杂度与初始顺序有关
平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
O(n^2)O(n)O(n^2)O(1)稳定
public class Insertion{
	public static void sort(Comparable[] a){
		int N = a.length;
		for(int i=1;i<n;i++){
			for(int j=i;j>0&&less(a[j],a[j-1]);j--){
				exch(a,j,j-1);
			}
		}
	}
}

3.希尔排序

  • 插入排序的改进,交换不相邻的元素以对数组的局部进行排序,并最终用插入排序将局部有序的数组排序
  • 时间复杂度与初始顺序有关
平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
O(n^1.3)O(n)O(n^2)O(1)不稳定
public class Shell{
	public static void sort(Comparable[] a){
		int N = a.length;
		int h = 1;
		while(h<N/3) h=h*3+1;
		while(h>=1){
			for(int i=h;i<N;i++){
				for(int j=i;j>=h&&less(a[j],a[j-h]);j-=h){
					exch(a,j,j-h);
				}
			}
			h/=3;
		}
	}
}

4.冒泡排序

  • 对元素依次进行两两比较,将较大的元素放后面,这样每次循环都能将一个较大的元素放在数组最后,经历n-1次循环数组变为有序状态
  • 对于一个长度为N的数组,平均情况下冒泡排序需要进行n(n-1)/2次比较和n(n-1)/4次交换
  • 时间复杂度与初始排序有关
平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
O(n^2)O(n)O(n^2)O(1)稳定
public class Bubble{
	public static void sort(Comparable[] a){
		int N = a.length;
		boolean flag = false;
		for(int i=0;i<N;i++){
			for(int j=0;j<N-1-i;j++){
				if(less(a[j+1],a[j])){exch(a,j,j+1);flag=true;}
			}
			if(!flag) break;
			flag = false;
		}
	}
}

5.归并排序

  • 采用分治法,先使每个子序列有序,再使子序列段间有序
  • 对于一个长度为N的数组,平均情况下归并排序需要进行(nlog2n)/2次比较
  • 时间复杂度与初始排序无关
平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
O(nlog2n)O(nlog2n)O(nlog2n)O(n)稳定
public class Merge{
	private static Comparable[] aux;
	public static void sort(Comparable[] a){
		aux = new Comparable[a.length];
		sort(a,0,a.length-1);
	}
	private static void sort(Comparable[] a,int lo,int hi){
		if(lo>=hi) return;
		int mid = (lo+hi)/2;
		sort(a,lo,mid);
		sort(a,mid+1,hi);
		merge(a,lo,mid,hi);
	}
	private static void merge(Comparable[] a,int lo,int mid,int hi){
		for(int i=lo;i<=hi;i++){aux[i]=a[i];}
		int i,j,k;
		for(k=lo,i=lo,j=mid+1;i<=mid&&j<=hi;){
			if(lessOrEqual(aux[i],aux[j])) a[k++]=aux[i++];
			else a[k++]=aux[j++];
		}
		while(i<=mid){a[k++]=aux[i++];}
		while(j<=hi){a[k++]=aux[j++];}
	}
	private static boolean lessOrEqual(Comparable v,Comparable w){return v.compareTo(w)<=0;}
}

6.快速排序

  • 采用分治法,将一个数组分成两个子数组,将两部分独立地排序,重复上述步骤
  • 对于一个长度为N的数组,平均情况下快速排序需要进行nlog2n次比较
  • 时间复杂度与初始排序有关
平均时间复杂度最好时间复杂度最坏时间复杂度最好空间复杂度最坏空间复杂度稳定性
O(nlog2n)O(nlog2n)O(n^2)O(log2n)O(n)不稳定
public class Quick{
    public static void sort(Comparable[] a,int lo,int hi){
        if(lo>=hi) return;
        int j = partition(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);
    }
    private static int partition(Comparable[] a,int lo,int hi){
        int i=lo,j=hi+1;
        Comparable stan = a[lo];
        while(true){
            while(less(a[++i],stan)) if(i>=hi) break;
            while(less(stan,a[--j])) if(j<=lo) break;
            if(i>=j) break;
            exch(a,i,j);
        }
        exch(a,j,lo);
        return j;
    }
    private static boolean less(Comparable v,Comparable w){return v.compareTo(w)<0;}
    private static void exch(Comparable[] a,int i,int j){Comparable temp=a[i];a[i]=a[j];a[j]=temp;}
}

7.堆排序

  • 将待排序列组成一个大顶堆,不断将根节点与最后一个节点交换然后重新排序,就能得到有序序列
  • 时间复杂度与初始排序无关
平均时间复杂度最好时间复杂度最坏时间复杂度空间复杂度稳定性
O(nlog2n)O(nlog2n)O(nlog2n)O(1)不稳定
public class Heap {
    public static void sort(Comparable[] a){
        int N = a.length;
        for(int i=N/2-1;i>=0;i--){sink(a,i,N);}
        for(int j=N-1;j>0;j--){
            exch(a,j,0);
            sink(a,0,j);
        }
    }
    private static void sink(Comparable[] a,int i,int N){
        Comparable temp = a[i];
        for(int k=i*2+1;k<N;k=k*2+1){
            if(k+1<N-1&&less(a[k],a[k+1])) k++;
            if(less(temp,a[k])){exch(a,i,k);i=k;}
            else break;
        }
        a[i] = temp;
    }
    private static void exch(Comparable[] a,int i,int j){Comparable temp=a[i];a[i]=a[j];a[j]=temp;}
    private static boolean less(Comparable v,Comparable w){return v.compareTo(w)<0;}
}

8.基数排序

  • 稳定性:稳定
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
### 回答1: Delaunay三角剖分算法是一个将给定点集进行连边分割成不相交三角形的算法,其分割结果是基于三角形的最小内角,以此来保证分割结果的质量。在计算机图形学、离散数学和计算机视觉等领域中,Delaunay三角剖分算法都有广泛的应用。 C语言是一种常用的编程语言,在许多计算领域中都有着重要的应用。为了实现Delaunay三角剖分算法,我们可以使用C语言编写相关的源代码。该算法代码可分为以下几个步骤: 1. 首先确定点集的边界,以确定整个区域的边界。我们可以使用任意一个叶子点作为三角网格的起点。 2. 将所有的点按照x坐标排序,以方便后续计算。 3. 选取一个凸包三角形,它应该包含所有的点。根据这个凸包三角形来初始化我们的三角形列表。 4. 顺次遍历点集中的每一个点,判断其是否属于当前三角形网格中的某个三角形。如果不属于,则根据Delaunay的定义找到该点能加入的新三角形,以及需要翻转的旧三角形。 5. 将每个新的三角形加入三角形网格中,并将旧的三角形从网格中删去。 6. 重复以上步骤,直到所有点都被处理完毕。 7. 由于边缘的三角形可能不属于需要的结果,因此需要将这些边缘的三角形删除,从而得到最终的Delaunay三角剖分结果。 总的来说,实现Delaunay三角剖分算法需要进行多次计算和遍历,涉及到数据结构、算法设计等方面。在C语言中,我们可以使用数组、堆栈等数据结构来支持算法的实现。最终代码的实现需要根据具体的应用需求而定,可以根据相关的算法描述和设计思路来进行编写和调试。 ### 回答2: Delaunay三角剖分算法是一种广泛应用于计算机图形学和计算几何领域的算法。其主要作用是将一个点集按照一定的规则进行三角剖分,得到无重叠的三角形组合。这些三角形通常用于计算复杂的几何形状线段、点和区域之间的关系。 C语言是一种广泛应用于计算机程序设计和开发的高级编程语言。在Delaunay三角剖分算法的实现过程中,C语言是一种传统的编程语言选择。下面给出一个简单的Delaunay三角剖分算法C语言的实现,以供参考。 首先,我们需要定义一个包含点坐标值的结构体: typedef struct { double x; double y; } Point; 接着,我们需要定义一个包含边线信息的结构体: typedef struct { Point p1; Point p2; } Line; 定义一个检查是否为Delaunay三角形的函数: int isDelaunay(Point p1, Point p2, Point p3, Point test) { double edge1 = (p1.x - p2.x) * (test.y - p2.y) - (p1.y - p2.y) * (test.x - p2.x); double edge2 = (p2.x - p3.x) * (test.y - p3.y) - (p2.y - p3.y) * (test.x - p3.x); double edge3 = (p3.x - p1.x) * (test.y - p1.y) - (p3.y - p1.y) * (test.x - p1.x); if (edge1 > 0 && edge2 > 0 && edge3 > 0) { return 1; } else if (edge1 < 0 && edge2 < 0 && edge3 < 0) { return 1; } else { return 0; } } 定义一个进行三角剖分的函数: void DelaunayTriangulation(Point *points, int numPoints) { Line *lines = malloc(3 * (numPoints - 2) * sizeof(Line)); int numLines = 0; int i, j, k; for (i = 0; i < numPoints - 2; i++) { for (j = i + 1; j < numPoints - 1; j++) { for (k = j + 1; k < numPoints; k++) { int isTri = 1; int l; for (l = 0; l < numPoints; l++) { if (l != i && l != j && l != k) { if(isDelaunay(points[i], points[j], points[k], points[l])) { isTri = 0; break; } } } if (isTri) { lines[numLines].p1 = points[i]; lines[numLines].p2 = points[j]; numLines++; lines[numLines].p1 = points[j]; lines[numLines].p2 = points[k]; numLines++; lines[numLines].p1 = points[k]; lines[numLines].p2 = points[i]; numLines++; } } } } /* perform edge flipping to get a Delaunay triangulation */ int label = 0; for (i = 0; i < numLines; ) { int j; for (j = i+1; j < numLines; j++){ if ((lines[i].p1.x == lines[j].p2.x && lines[i].p1.y == lines[j].p2.y && lines[i].p2.x == lines[j].p1.x && lines[i].p2.y == lines[j].p1.y) || (lines[i].p1.x == lines[j].p1.x && lines[i].p1.y == lines[j].p1.y && lines[i].p2.x == lines[j].p2.x && lines[i].p2.y == lines[j].p2.y) || (lines[i].p1.x == lines[j].p2.x && lines[i].p1.y == lines[j].p2.y && lines[i].p2.x == lines[j].p1.x && lines[i].p2.y == lines[j].p1.y) || (lines[i].p1.x == lines[j].p1.x && lines[i].p1.y == lines[j].p2.y && lines[i].p2.x == lines[j].p2.x && lines[i].p2.y == lines[j].p1.y)){ Point newPt1, newPt2; newPt1 = lines[i].p1 == lines[j].p1 ? lines[i].p2 : lines[i].p1; newPt2 = lines[j].p1 == lines[i].p1 ? lines[j].p2 : lines[j].p1; lines[i].p2 = newPt1; lines[j].p2 = newPt2; i = 0; j = 0; continue; } } i++; } /* print out the completed Delaunay triangulation */ for (i = 0; i < numLines; i++) { printf(" %f,%f - %f,%f\n", lines[i].p1.x, lines[i].p1.y, lines[i].p2.x,lines[i].p2.y); } free(lines); } 最后,我们可以通过编写主函数(main)来测试该算法: int main(int argc, char *argv[]) { /* can be adapted to take in command line args */ Point points[] = {{0,0}, {1,0}, {0,1}, {1,1}, {0.5,0.5}}; int numPoints = sizeof(points) / sizeof(Point); DelaunayTriangulation(points, numPoints); return 0; } 通过以上的代码,我们实现了一个简单的Delaunay三角剖分算法,并通过一个包含5个点的点集进行了测试。在实际应用中,可以根据具体需求进行算法优化和性能调整。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值