田忌赛马贪心算法c语言_数据结构与算法(二)——十大排序算法

最新推荐文章于 2023-12-02 16:25:30 发布

weixin_39942726

最新推荐文章于 2023-12-02 16:25:30 发布

阅读量420

点赞数 2

文章标签：田忌赛马贪心算法c语言

本文链接：https://blog.csdn.net/weixin_39942726/article/details/112750908

版权

前言

秋招已经开启一个月了，九月份和十月份是我们秋招找工作的黄金时期。但是大多数的企业都会在笔试或者面试中会考察我们数据结构的知识点，有的会直接考查数据结构的代码实现，比如说树的三种深度优先遍历代码递归以及迭代方式的实现。其次就是考察最多的就是几种排序和常用的查找方法，需要我们熟练掌握。还有的就是会通过一个实际问题来对相关的算法进行考察，比如说动态规划、穷举法、贪心算法等。前一篇文章给大家介绍了数据结构中帮助大家理解代码的执行过程和相应算法的工具。本文给大家介绍数据结构中最为重要也是面试中经常考察的算法之一——排序算法的总结。

十大排序算法实现

在数据结构与算法中，我们会学到十大算法，他们分别是冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序。我们在任何时候，都应该要写出相关的代码，只有这样，我们才能够在写其他算法中更好的应用。由于该算法比较基础，也是比较重要的，接下来，我们通过C语言、java和python三种流行语言将其算法进行实现。接下来给大家介绍第一种排序——冒泡排序的实现。

1、冒泡排序

冒泡排序的原理在于要么元素上浮，从右（大）往左（小）依次确认，相邻元素间，如果右小于左，则交换，每次确认一位最小数。要么元素下沉，从左（小）往右（大）依次确认，相邻元素间，如果左大于右，则交换，每次确认一位最大数。我们用动图解释如下：

接下来我们分别用C语言、java和python3三种语言将其实现：

1、我们用C语言将其实现，代码如下：

#include<stdio.h>
void BubbleSort(int k[],int n){
    
	int i,j,temp,count1=0,count2=0,flag;
	flag=1;
	for(i=0;i<n-1 && flag;i++){
    
		for(j=n-1;j>i;j--){
    
			count1++;
			flag=0;
			if(k[j-1]>k[j]){
    
				count2++;
				temp=k[j-1];
				k[j-1]=k[j];
				k[j]=temp;
				flag=1;
			}
		}
	}
		printf("总过进行了%d次比较，进行了%d次移动！！",count1,count2);
}
int main(){
    
	int i,a[10]={
    1,0,2,3,4,5,6,7,8,9};
	BubbleSort(a,10);
	printf("排序后的结果是： n");
	for(i=0;i<10;i++){
    
		printf("%d ",a[i]);
	}
	printf("nn");
	return 0;
}

排序效果如下图所示：

2、我们用java语言将其实现，代码如下：

package 数据结构.排序;

public class 冒泡排序 {
    
    public static void bubbleSort(int [] a, int n){
    
        int j , k;
        int flag = n ;
        //flag来记录最后交换的位置，也就是排序的尾边界

        while (flag > 0){
    
            //排序未结束标志
            k = flag;
            //k 来记录遍历的尾边界
            flag = 0;

            for(j=1; j<k; j++){
    
                if(a[j-1] > a[j]){
    
                    //前面的数字大于后面的数字就交换
                    //交换a[j-1]和a[j]
                    int temp;
                    temp = a[j-1];
                    a[j-1] = a[j];
                    a[j]=temp;
                    flag = j;
                }
            }
        }
    }

    public static void main(String[] args) {
    
        int[] arr = {
    2,1,5,4,3,8,7};

        冒泡排序.bubbleSort(arr, arr.length);

        for(int i:arr){
    
            System.out.print(i+"t");
        }
    }
}

排序效果如下图所示：

3、我们用python语言将其实现，代码如下：

def bubble_sort(alist):
    n = len(alist)
    for j in range(n-1):
        count = 0
        for i in range(0,n-1-j):
            if alist[i]>alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
                count+=1
        if count == 0:
            return

if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print("排序之前为:", li)
    bubble_sort(li)
    print("排序之后为:",li)

排序效果如下图所示：

2、选择排序

选择排序的原理在于要么拿未确认的最左位元素，依次和右边元素比较，如果右边元素更小，则交换。要么拿未确认的最右位元素，依次和左边元素比较，如果左边元素更大，则交换。我们用动态图解释如下：

接下来我们分别用C语言、java和python3三种语言将其实现：

1、我们用C语言将其实现，代码如下：

#include<stdio.h>
void SelectSort(int k[],int n){
    
	int i,j,min,temp,count1=0,count2=0;
	for(i=0;i<n-1;i++){
    
		min=i;
		for(j=i+1;j<n;j++){
    
			count1++;
			if(k[j]<k[min]){
    
				min=j;
			}
		}
		if(min!=i){
    
			count2++;
			temp=k[min];
			k[min]=k[i];
			k[i]=temp;
		}
	}
		printf("总共进行了%d次比较，进行了%d次移动！！",count1,count2);
}
int main(){
    
	int i,a[10]={
    5,2,8,4,9,3,1,7,0,6};
	SelectSort(a,10);
	printf("排序后的结果是： n");
	for(i=0;i<10;i++){
    
		printf("%d ",a[i]);
	}
	printf("nn");
	return 0;
}

效果图如图所示：

2、我们用java语言将其实现，代码如下：

package 数据结构.排序;

public class 选择排序 {
    
    public static void main(String[] args) {
    
        int[] arr = {
    52, 63, 14, 59, 68, 35, 8, 67, 45, 90};
        System.out.println ("原数组:");
        for (int i:arr){
    
            System.out.print(i+" ");
        }
        System.out.println ();
        selectSort(arr);
        System.out.println ("排序后");
        for (int i:arr){
    
            System.out.print(i+" ");
        }
    }
    public static void selectSort(int[] arr){
    
        for (int i =0; i < arr.length-1; i++){
    
            int min = i;
            for (int j = i+1; j < arr.length;j++){
    
                if(arr[j] < arr[min]){
    
                    min = j;
                }
            }
            if(min != i){
    
                swap(arr, i, min);
            }
        }
    }
    public static void swap(int[] arr, int a, int b){
    
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

排序效果如下图所示：

3、我们用python语言将其实现，代码如下：

def select_sort(alist):
    min = 0
    n = len(alist)
    for j in range(n-1): 
        min_index=j
        for i in range(j+1, n):
            if alist[min_index] > alist[i]:
                min_index = i
        alist[j],alist[min_index] = alist[min_index],alist[j]
if __name__ == '__main__':
    li = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    print("排序之前为:", li)
    select_sort(li)
    print("排序之后为:",li)

排序效果如下图所示：

3、插入排序

插入排序的原理在于：将某一元素插入已经排序好的数组中，元素位于数组右方，则元素依次与左方比较，找出合适位置，被比较元素后移一位，该元素前置，要么元素位于数组左方，则元素依次与右方比较，找出合适位置，被比较元素前移一位，该元素后置。我们用动图解释如下：

接下来我们分别用C语言、java和python3三种语言将其实现：

1、我们用C语言将其实现，代码如下：

#include <stdio.h>
//自定义的输出函数
void print(int a[], int n ,int i){
    
    printf("%d:",i);
    for(int j=0; j<8; j++){
    
        printf("%d",a[j]);
    }
    printf("n");
}
//直接插入排序函数
void InsertSort(int a[], int n)
{
    
    for(int i= 1; i<n; i++){
    
        if(a[i] < a[i-1]){
    //若第 i 个元素大于 i-1 元素则直接插入；反之，需要找到适当的插入位置后在插入。
            int j= i-1;
            int x = a[i];
            while(j>-1 && x < a[j]){
      //采用顺序查找方式找到插入的位置，在查找的同时，将数组中的元素进行后移操作，给插入元素腾出空间
                a[j+1] = a[j];
                j--;
            }
            a[j+1] = x;      //插入到正确位置
        }
        print(a,n,i);//打印每次排序后的结果
    }
}

int main(){
    
    int a[8] = {
    3,1,7,5,2,4,9,6};
    InsertSort(a,8);
    return 0;
}

排序效果如下图所示：

2、我们用java语言将其实现，代码如下：

package 数据结构.排序;

public class 插入排序 {
    
    public static void main(String[] args) {
    
        int[] ins = {
    2,3,5,1,23,6,78,34};
        int[] ins2 = InsetSort(ins);
        for (int in:ins2){
    
            System.out.println (in);
        }
    }
    public static int[] InsetSort(int[] ins){
    
        for (int i = 1; i < ins.length; i&

最低0.47元/天解锁文章

weixin_39942726

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
0
评论
田忌赛马贪心算法c语言_数据结构与算法(二)——十大排序算法

前言秋招已经开启一个月了，九月份和十月份是我们秋招找工作的黄金时期。但是大多数的企业都会在笔试或者面试中会考察我们数据结构的知识点，有的会直接考查数据结构的代码实现，比如说树的三种深度优先遍历代码递归以及迭代方式的实现。其次就是考察最多的就是几种排序和常用的查找方法，需要我们熟练掌握。还有的就是会通过一个实际问题来对相关的算法进行考察，比如说动态规划、穷举法、贪心算法等。前一篇文章给大家介绍了数据...
复制链接

扫一扫