【编译原理】语言认知之Java、Python、C++快速排序&三者运行效率与开发效率比较

一、实验目的

强化对编译器两端的认识，了解语言多样性，了解语言特性对语言实现的影响。

二、实验环境

语言	实验环境
C++	Dev C++
Python	PyCharm
Java	Eclipse

三、实验步骤

• 1.了解快速排序的基本思想：即通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
• 2.快速排序的速度是非常快的，手敲的数字排序时间是0ms，所以先生成十万行数据

import random
my_list = list(range(100000))
random.shuffle(my_list)
print(my_list)

3.画流程图

四、快速排序程序

C++:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void display(int* array, int size) {
    for (int i = 0; i < size; i++) {
        printf("%d ", array[i]);
    }
    printf("\n");
}

int getStandard(int array[], int i, int j) {
    // 基准数据
    int key = array[i];
    while (i < j) {
        // 因为默认基准是从左边开始，所以从右边开始比较
        // 当队尾的元素大于等于基准数据 时,就一直向前挪动 j 指针
        while (i < j && array[j] >= key) {
            j--;
        }
        // 当找到比 array[i] 小的时，就把后面的值 array[j] 赋给它
        if (i < j) {
            array[i] = array[j];
        }
        // 当队首元素小于等于基准数据 时,就一直向后挪动 i 指针
        while (i < j && array[i] <= key) {
            i++;
        }
        // 当找到比 array[j] 大的时，就把前面的值 array[i] 赋给它
        if (i < j) {
            array[j] = array[i];
        }
    }
    // 跳出循环时 i 和 j 相等,此时的 i 或 j 就是 key 的正确索引位置
    // 把基准数据赋给正确位置
    array[i] = key;
    return i;
}

void QuickSort(int array[], int low, int high) {
    // 开始默认基准为 low
    if (low < high) {
        // 分段位置下标
        int standard = getStandard(array, low, high);
        // 递归调用排序
        // 左边排序
        QuickSort(array, low, standard - 1);
        // 右边排序
        QuickSort(array, standard + 1, high);
    }
}

int main() {
	long start,end; 
	
    {
    	int array[]={73451, 66296, 96131, 97376, 27998, 73940, 71435, 8534, 29171, 49081, 48034, 37764, 92023, 25097};
	    int size    = sizeof(array) / sizeof(int);

	    // 打印数据
	    printf("%d \n", size);
	    start = clock();
	    QuickSort(array, 0, size - 1);
	    end = clock(); 
	    display(array, size);

	}
    printf("This cost %ld\n",end-start); //单位：毫秒
    return 0;
}

Python:

import time 
def quick_sort(li, start, end):
    # 分治 一分为二
    # start=end ,证明要处理的数据只有一个
    # start>end ,证明右边没有数据
    if start >= end:
        return
    # 定义两个游标，分别指向0和末尾位置
    left = start
    right = end
    # 把0位置的数据，认为是中间值
    mid = li[left]
    while left < right:
        # 让右边游标往左移动，目的是找到小于mid的值，放到left游标位置
        while left < right and li[right] >= mid:
            right -= 1
        li[left] = li[right]
        # 让左边游标往右移动，目的是找到大于mid的值，放到right游标位置
        while left < right and li[left] < mid:
            left += 1
        li[right] = li[left]
    # while结束后，把mid放到中间位置，left=right
    li[left] = mid
    # 递归处理左边的数据
    quick_sort(li, start, left-1)
    # 递归处理右边的数据
    quick_sort(li, left+1, end)
 
if __name__ == '__main__':
	l=[27711, 89787, 67411, 950, 3307, 34546, 22610, 72210, 31808, 44582, 9]
    # [2, 1, 5, 6, 5, 4]
    startTime=time.time() #开始时间 
    quick_sort(l,0,len(l)-1)
    endTime=time.time() #结束时间 
    print(l)
    # 稳定性：不稳定
    # 最优时间复杂度：O(nlogn)
    # 最坏时间复杂度：O(n^2)
TimeT=(endTime-startTime)
print("time:%f" % TimeT) 

Java:
刚开始运行出现了一个错误：

经检查发现：

然后令Java自己生成

import java.util.function.IntPredicate;

public class sort {
    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 = new int[100000];
     	for (int i = 0; i < 100000; i++) {
     		arr[i] = (int)(Math.random() * 100000 + 1);
		}
     	//排序
     	long startTime = System.currentTimeMillis(); //获取开始时间
    	quickSort(arr, 0, arr.length-1);
    	long endTime = System.currentTimeMillis(); //获取结束时间 
    	//打印
        for (int i = 0; i < arr.length; i++) {
        	System.out.print(arr[i] + ",");
        }
        System.out.println();
        System.out.println("数组长度为:" + arr.length);
        
        System.out.println("程序运行时间：" + (endTime - startTime) + "ms");
    }  
    
}

五、实验结果

C++:耗时15ms

Python:耗时537.580ms

Java:耗时39ms

六、总结

1、效率排行：C++>Python>Java
2、运行效率：C++ >Java> Python

• C++与Python比较：Python代码和C++最终都会变成CPU指令来跑，但一般情况下，比如反转和合并两个字符串，Python最终转换出来的CPU指令会比C++ 多很多。
  首先，Python东西比C++多，经过了更多层，Python中甚至连数字都是object
  其次，Python是解释执行的，和物理机CPU之间多了解释器这层，而C++是编译执行的，直接就是机器码，编译的时候编译器又可以进行一些优化。
• Java与C++比较：Java 语言同样是解释型的，在运行时要先被翻译成计算机能辨识的二进制代码，然后才能执行。
• Java与Python比较：Java是半编译的，而Python是脚本语言，所以Java的执行效率高，但是Python经常使用C做扩展，执行效率有时候也不是问题。

3、开发效率：Python >Java> C++

• Python和C++比较：Python一两句代码就搞定的东西，C++往往要写一大堆。用C++解析下Json你就明白了，很可能好几天过去了，你还在调bug，刚调好bug又内存泄漏了，再试试Python会爽得不要不要的。开发效率上，Python要比C++快很多，所以说：“人生苦短，我用Python”。
• Java和C++比较：Java 语言则是解释型的。Java 语言运行时要先被翻译成计算机能辨识的二进制代码，然后才能执行。虽然在一些的程序测试 中 C 语言要快于Java语言，但这并不是绝对的。在实际中，要根据不同语言应用范围，才能选择某一语言程序。
• Java和Python比较：Python的开发效率要更高一些，尤其在与数据相关的开发任务中（数据分析等），会有更明显地体现，这一点相信很多程序员也有切身体会。之所以Python的开发效率更高，主要原因在于Python语言的语法设计上和丰富的开发库支持上，这与Python语言的设计理念有非常直接的关系。Python对面向对象的支持更好，所以在开发效率，可维护性更胜一筹。