C/C++、Java、Python的比较及学习（4）

最新推荐文章于 2024-07-17 10:38:14 发布

九霄云客

最新推荐文章于 2024-07-17 10:38:14 发布

阅读量311

点赞数

分类专栏： C/C++、Java、Python的比较及学习文章标签： c语言 c++ java

本文链接：https://blog.csdn.net/qq_43595030/article/details/129105434

版权

C/C++、Java、Python的比较及学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

冒泡排序：首先将待排序数列中的第1个元素和第2个元素进行比较，如果是逆序进行一次交换；
接着对第2个元素和第3个元素进行比较，如果是逆序进行一次交换；依次类推，直到对第n-1个元素和第n个元素比较完为止。此过程称为一轮冒泡，这时最大的一个元素便被“沉”到了最后一个元素的位置上。然后再从第1个元素开始到第n-1个元素进行第二轮冒泡比较交换，将次大元素“沉”到了倒数第二个元素的位置上。如此这般，直到第n-1轮冒泡后，没有元素需要交换为止。

#include<stdio.h>

void sort(int score[],int n){
	int i,j,temp;
	for(i=0;i<n-1;i++)
		for(j=0;j<n-i-1;j++)
			if(score[j]>score[j+1]){
				temp = score[j];
				score[j] = score[j+1];
				score[j+1] = temp;
			}
}
void main(){
	int score[40];
	int i,j,n;
	printf("Input total numbers:\n");
	scanf("%d",&n);
	printf("Input score:\n");
	for(i=0;i<n;i++)
		scanf("%d",&score[i]);
	sort(score,n);
	printf("output score:\n");
	for(i=0;i<n;i++)
		printf("%d ",score[i]);
}

#include<iostream>
#include<algorithm>
using namespace std;

void main(){
	int score[40];
	int i,j,n;
	printf("Input total numbers:\n");
	scanf("%d",&n);
	printf("Input score:\n");
	for(i=0;i<n;i++)
		scanf("%d",&score[i]);
	sort(score,score+n);
	printf("output score:\n");
	for(i=0;i<n;i++)
		printf("%d ",score[i]);
}

import java.util.*;
public class one {
	public static void main(String args[]) {
		int i;
		int[] score=new int[100];
		Scanner sc = new Scanner(System.in);
		System.out.println("Input total numbers:");
		int n = sc.nextInt();
		System.out.println("Input score:");
		for(i=0;i<n;i++)
			 score[i]=sc.nextInt();
		Arrays.sort(score,0,n);
		System.out.println("output score:");
		for(i=0;i<n;i++)
			System.out.print(score[i]+" ");
    }
}

print("Input total numbers:")
n = input()
# 输入一个一维数组
score = input()
# 将输入每个数以空格键隔开做成数组
nums = [int(n) for n in score.split()]
nums.sort()
print("Input score:")
print(nums)

Python输入的程序归类： Python输入（一维数组、字符串、二维数组、三维数组等）程序。

1.输入一个一维数组

#输入一个数组
arr = input()
num = [int(n) for n in arr.split(',')] #如果是输入一系列由空格隔开的数就是split()
print(num)

2.输入一个二维数组

# 输入一个二维数组
n = int(input())
line = [[0]*n]*n
for i in range(n):
    line[i] = input().split(" ")
    line[i] = [int(j) for j in line[i]]
print(line)

输入一个字符串将其放入列表中

# 输入一个二维数组
arr = []
n = str(input())
for i in n:
    arr.append(i)
print(arr)

如果想把这个列表中的数合并成一个字符串输出：

# 输入一个二维数组
arr = []
n = str(input())
for i in n:
    arr.append(i)
s = "".join(arr)
print(s)

输入三维列表

t = int(input())  #输入这个三维的列表包含几个二维列表
n_list = []
for k in range(t):
    n = int(input())   #输入二维列表中包含几个一维列表
    arr = [[0]*n]*2
    for i in range(0,2):
        arr[i] = input().split(" ")
        arr[i] = [int(j) for j in arr[i]]
    n_list.append(arr)
print(n_list)

二分查找：
第一步：把一个包含n个数的有序数列放在数组a中，将待查的数放在x中。设3个位置变量d,m,h。d用来表示查找范围的顶部，即d的初值为0。h用来表示查找范围的底部，即h的初值为n-1。m用来表示查找范围的中间位置，即m=(d+h)/2。再把m作为数组a的下标，这样就把n个数分成以a[m]为中点的两段区间。
第二步：重复进行以下三种判断，不断缩小查找范围，并在下列两种情况下不再重复进行判断而退出循环：一是已找到，则可以退出循环；二是没有找到，即本身数组a中不存在这个数，以至于使d大于h了，这时也应该退出循环。
（1）如果x等于a[m],则已找到，就此可以结束查找过程。
（2）如果x大于a[m],则x必定落在大于后半段范围，即在a[m+1]~a[h]范围内，所以舍弃前半段范围，保留后半段范围，定出新的d和m的值，并在新定义出的区间内重新再划分两段范围，重新进行判断。
（3）如果x小于a[m]，则x必定落在前半段范围，即在a[d]~a[m-1]范围内。这时再重新定义h和m，并在新定出的范围内重新再划分两段范围，重新进行判断。

折半查找法：也称为二分查找法, 二分搜索。是一种在有序数组中查找某一特定元素的搜索算法。搜索过程中从数组的中间元素开始，如果中间元素正好是要查找的元素，则搜索过程结束；如果某一特定元素大于或者小于中间元素，则在数组大于或小于元素的那一半中查找。而且跟开始一样从中间元素开始比较，若某个步骤中数组为空，则代表找不到。这种搜索算法每一次比较都使搜索范围缩小一半。这种方法对待查找的列表有两个要求–必须采用顺序存储结构–必须按关键字大小有序排列。

#include<iostream>
#include<algorithm>
using namespace std;
void main(){
	int a[10],d,h,x,i,m;
	printf("Please input 10 numbers:");
	for(i=0;i<10;i++)
		scanf("%d",&a[i]);
	printf("Please input x:");
	scanf("%d",&x);
	sort(a,a+10);
	d=0,h=9;
	while(d<=h){
		m=(d+h)/2;
		if(x==a[m])
			break;
		else if(x>a[m])
			d=m+1;
		else
			h=m-1;
	}
	if(d<=m)
		printf("%d is the position %d\n",x,m);
	else
		printf("there is no %d\n",x);
}

杨辉三角形：

1
1  1
1  2  1
1  3  3  1
1  4  6  4  1
1  5 10 10  5  1

#include<stdio.h>
#define N 15
void main(){
	int i,j,n,a[N][N];
	printf("Input n(1-15):\n");
	scanf("%d",&n);
	for(i=0;i<=n;i++)
		a[i][0]=a[i][i]=1;
	for(i=2;i<=n;i++)
		for(j=1;j<i;j++)
			a[i][j]=a[i-1][j-1]+a[i-1][j];
	for(i=0;i<=n;i++){
		for(j=0;j<=i;j++)
			printf("%d  ",a[i][j]);
	    printf("\n");
	}
}

魔方阵：每行每列和对角线之和均相等。

8   1   6
3   5   7
4   9   2

#include<stdio.h>
#define n 3
void main(){
	int i,j,k,i1,j1;
	int a[n][n]={0};
	j=n/2;i=0;
	a[i][j]=1;
	for(k=2;k<=n*n;k++){
		i1=i,j1=j;
		i--;j++;
		if(i<0) i=n-1;
		if(j>n-1) j=0;
		if(a[i][j]==0) 
			a[i][j]=k;
		else{
			i=i1+1;
			j=j1;
			a[i][j]=k;
		}
	}
	for(i=0;i<n;i++){
		for(j=0;j<n;j++)
			printf("%d  ",a[i][j]);
	    printf("\n");
	}
}

螺旋方阵：

1  2  3  4  5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

#include<stdio.h>

void main(){
	int n,s[15][15],x=1;
	scanf("%d",&n);
	int t=n,a=1,b=n;
	while(n){
		if(n==1){
			s[t/2+1][t/2+1]=t*t;
			n=0;
			continue;
		}
		n=n-2;
		//第一部分  
		for(int i=a;i<=t-a;i++)
			s[a][i]=x++;
		//第二部分 
		for(int i=a;i<=t-a;i++)
			s[i][b]=x++;
		//第三部分 
		for(int i=b;i>t-b+1;i--)
			s[b][i]=x++;
		//第四部分  
		for(int i=b;i>t-b+1;i--)
			s[i][a]=x++;	
		a++,b--;
	}
	for(int i=1;i<=t;i++){
		for(int j=1;j<=t;j++)
			printf("%3d",s[i][j]);
		puts("");
	}
}

在C语言中没有专门的字符串变量，通常用一个字符数组来存放和处理一个字符串。
字符数组的输入与输出：
（1）用格式符%c一个字符一个字符地输入或输出。
（2）用格式符%s将字符串作为一个整体来输入或输出。

#include<stdio.h>

void main(){
	char str1[6],str2[6],str3[6];
	printf("input string:\n");
	scanf("%s%s%s",str1,str2,str3);
	printf("%s %s %s\n",str1,str2,str3);
}

（3）用字符串处理函数gets和puts来输入或输出一个字符串。

#include<stdio.h>

void main(){
	char str[15];
	printf("input string:\n");
	gets(str);
	puts(str);
}

常用的字符串处理函数：
1、字符串连接函数strcat strcat(字符数组名1，字符数组名2)
功能：把字符数组2中的字符串连接到字符数组1中字符串的后面，并删去字符数组1中字符串后的串标志“\0”。函数返回的是字符数组1的首地址。

#include<stdio.h>
#include<string.h>

void main(){
	char str1[25]="My name is:";
	char str2[50];
	printf("input your name:\n");
	gets(str2);
	strcat(str1,str2);
	puts(str1);
}

2、字符串复制函数strcpy strcpy(字符数组名1，字符数组名2)
功能：把字符数组2中的字符串复制到字符数组1中。字符串结束标志"\0"也一同复制。字符数组2也可以是一个字符串常量，这时相当于把一个字符串赋予一个字符数组。

#include<stdio.h>
#include<string.h>

void main(){
	char str1[25],str2[]="C language";
	strcpy(str1,str2);
	puts(str1);
}

3、字符串比较函数strcmp strcmp(字符串1，字符串2)
功能：按照ASCII码值比较两个字符串的大小，并由函数返回值返回比较结果。结果分为三种情况：
（1）字符串1=字符串2，返回值为0。
（2）字符串1>字符串2，返回值为一个正整数。
（3）字符串1<字符串2，返回值为一个负整数。
字符串的比较方法为：对两个字符串从左至右按字符的ASCII码值大小逐个字符相比较，直到出现不同的字符或遇到’\0’为止。也就是说，当出现第一对不相等的字符时，就由这两个字符的大小来决定所在字符串的大小。

#include<stdio.h>
#include<string.h>

void main(){
	int k;
	char str1[25],str2[]="C language";
	printf("input a string:\n");
	gets(str1);
	k=strcmp(str1,str2);
	if(k==0) printf("str1==str2\n");
	if(k>0) printf("str1>str2\n");
	if(k<0) printf("str1<str2\n");
}

求字符串长度函数strlen()
输入一个字符串，统计其中有多少个单词。单词之间用空格分隔开。

#include<stdio.h>

void main(){
	char str[80],c;
	int i,num=0,flag=0;
	printf("Please input string:\n");
	gets(str);
	for(i=0;(c=str[i])!='\0';i++)
		if(c==' ')
			flag=0;
		else if(flag==0){
			flag=1;
			num++;
		}
	printf("There are %d words in the string.\n",num);
}

import java.util.*;
public class one {
	public static void main(String args[]) {
		int n=0;
		Scanner sc = new Scanner(System.in);
	    String str = sc.nextLine();
	    String[] split = str.split(" ");
	    for(String string : split){
	    	System.out.println(string);
	    	n++;
	    }	   
	    System.out.print(n);
	}
}

Python:首先，我们需要导入 Python 的 re 模块，这个模块提供了正则表达式的功能，可以帮助我们按照空格分割字符串。
然后，我们可以定义一个函数，接受一个字符串作为输入，使用 re.split() 函数按照空格分割字符串，并返回分割后的单词列表。
最后，我们只需要返回列表的长度即可得到单词的个数。

import re

def count_words(string):
  # 使用 re.split() 函数按照空格分割字符串
  words = re.split(r'\s', string)
  # 返回列表的长度
  return len(words)

s = str(input())
print(count_words(s))

输入一个无符号整数，将其转换成二进制字符串并输出。
思路：将十进制整数转换成二进制一般采用“除2取余”的方法，即将该十进制数不断除以2，并保留每次除以2所得的余数，直到余数为0为止。然后再将所得余数按逆序（即倒着排列）排列，即为所求的二进制数。

#include<stdio.h>

void main(){
	unsigned n;
	char str[10],t;
	int k,i,j;
	printf("Please input:");
	scanf("%u",&n);
	for(i=0;n!=0;i++){
		str[i]=n%2+'0';
		n/=2;
	}
	str[i]='\0';
	printf("The result is:");
	for(k=0,j=i-1;k<j;k++,j--){
		t=str[k];//这里不开辟数组的原因在于仅用一个变量便可代替数组，大大节省了空间开销。
		str[k]=str[j];
		str[j]=t;
	}
	puts(str);
}

输入5个国家的名称，并按字母排序排列输出这些国家名称。
具体的算法步骤：
（1）输入5个国家名保存到二维数组name中。
（2）用冒泡法对数组name按由小到大顺序排列。
思路：可设一个5X20的二维字符数组name来存放5个国家名。由于C语言规定可以把一个二维数组当成多个一维数组处理，因此二维字符数组name又可以按5个一维数组处理，而每个一维数组就代表一个国家名字符串。

#include<stdio.h>
#include<string.h>
void main(){
	char str[20],name[5][20];
	int i,j;
	printf("input country's name:\n");
	for(i=0;i<5;i++)
		gets(name[i]);
	for(i=0;i<4;i++)
		for(j=0;j<4-i;j++)
			if(strcmp(name[j],name[j+1])>0){
				strcpy(str,name[j]);
				strcpy(name[j],name[j+1]);
				strcpy(name[j+1],str);
			}
	printf("The result is:\n");
	for(i=0;i<5;i++)
		puts(name[i]);
}

注意：java这里的容器使用要多看看练练！

import java.util.*;
public class one {
	public static void main(String args[]) {
		Scanner scanner=new Scanner(System.in);
		  int len=scanner.nextInt();//几个字符串
		  String[] target=new String[len];//定义长度为n的字符串数组
		  for (int i = 0; i < len; i++) {
		   target[i]=scanner.next();
		  }
		  //按字典排序
		  Arrays.sort(target);
		  //输出
		  for (String string : target) {
		   System.out.println(string);
		  }
    }
}

c = []
n = int(input())
for i in range(n):
    s = input()
    c.append(s)
c.sort()
for i in range(n):
    print(c[i])

判断任意一个字符串是否为回文。

#include<stdio.h>
#include<string.h>
char fin(char a[]);
int main(){
    char a[80];
    printf("Input a string:\n");
    gets(a);
    if (fin(a)){
        printf("This string is a plalindrome.\n");
    }
    else{
        printf("This string is not a plalindrome.\n");
    }
}
char  fin(char a[]){
    int i, j;
    for (i = 0, j = strlen(a) - 1; i < j; i++, j--){
        if (a[i] != a[j]){//这里表示回文不需要两个数组，一个数组即可，时间空间都得到减少。
            return 0;
        }
    }
}

import java.util.*;
public class one {
	//判断一个数是否为回文数
	public static void main(String args[]) {
		Scanner input = new Scanner(System.in);
        System.out.print("请输入需要判断的数字：");
        int num = input.nextInt();
        String s = Integer.toString(num);//此处涉及到库中的容器要记住下次使用！
        char[] array = s.toCharArray();//此处调用了很多库函数要好好注意!
        boolean flag = true;
        for (int i = 0; i < array.length / 2; i++) {
            if (array[i] != array[array.length - i - 1]) {
                flag = false;
                System.out.println("你输入的数字不是回文数！");
                break;
            }
        }
        if (flag)
            System.out.println("你输入的数字是回文数！");
    }
}

python:
1：整数转字符串，通过下标对比确定该整数是否为回文数。

x = int(input())
str_x = str(x)
t = 1
for i in range(0,int(len(str_x)/2)):
    if str_x[i] != str_x[len(str_x)-i-1]:
        t = 0
        print("NO!")
        break
if t==1:
    print("Yes!")

2：字符串切片操作，str[index:index:step]，中括号里面分别为：字符起点、终点和步长。

x = int(input())
str_x = str(x)
if str_x == str_x[::-1]:
        print("Yes!")
else:
    print("No!")

3：数学计算的方法，对比反转整数的值。

x = int(input())
if x<0:
    print("No!")
temp_x = x
palindromeNum = 0
while temp_x != 0:
  palindromeNum = palindromeNum*10 + temp_x%10
  temp_x = int(temp_x/10)
if palindromeNum == x:
    print("Yes!")
else:
    print("No!")

4：整数转字符串，反转字符串，对比反转后字符串与原字符串是否相等。（特别关注！）

x = int(input())
str_x = str(x)
str_y = ""
for i in str_x:
  str_y = i + str_y
if str_y == str_x:
    print("Yes!")
else:
    print("No!")

以上是这篇使用python实现回文数的四种方法小结。

C语言规定，数组可以作为函数的参数使用来进行数据传送。数组用作函数参数有两种形式：
一种是把数组元素作为实参使用；另一种是把数组名作为函数的参数使用。
选择排序：先找出10个数中的最小者（降序是找最大者）与数组中的第一个数a[0]交换，再从a[1]~a[9]中找出最小数与a[1]交换…每比较一轮找出一个未经排序的数中的最小数，共比较9轮。

#include<stdio.h>

void sort(int a[],int n){
	int i,j,k,t;
	for(i=0;i<n-1;i++){
		k=i;
		for(j=i+1;j<n;j++)
			if(a[j]<a[k])
				k=j;
		if(k!=j){
			t=a[k];
			a[k]=a[i];
			a[i]=t;
		}
	}
}

void main(){
	int s[10],i;
	printf("input the array:\n");
	for(i=0;i<10;i++)
		scanf("%d",&s[i]);
	sort(s,10);
	printf("output the array:");
	for(i=0;i<10;i++)
		printf("%4d",s[i]);
	printf("\n");
}

用数组名作为函数参数时还应该注意以下几点：
（1）形参数组和实参数组的数组名可以不同，但类型必须一致，否则将引起错误。
（2）形参数组和实参数组的长度可以不相同，因为在调用时只传送实参数组的首地址，而不检查形参数组的长度。

void nzp(int a[5]){}
void main(){
     int b[8];
     nzp(b);
}

（3）在函数形参表中，允许不给出形参数组的长度。为了在被调用函数中处理数组元素的需要，可以另设一个参数，传递数组元素的个数。

void nzp(int a[],int n){
     for(i=0;i<n;i++){
     
     }
}
void main(){
      int b[8];
      nzp(b，8);
}

用多维数组名作为函数参数时，在被调用函数中定义形参数组可以指定每一维的长度，也可以省去第一维的长度。

int fun(int a[3][10])或者int fun(int a[][10])

但要注意不能把第二维以及其他高维的大小说明省略，例如下面的写法就不合法：

int fun(int a[3][])

举个例子：
在矩阵a中选出各行最大的元素组成一个一维数组b。例如：

a=[3  16  87   65      b=[87 108 37]
   4  32  11  108
   10 25  12   37]

#include<stdio.h>

void fun(int a[][4],int b[]){
	int i,j;
	for(i=0;i<=2;i++){
		b[i]=a[i][0];
		for(j=0;j<=3;j++)
			if(a[i][j]>b[i])
				b[i]=a[i][j];
	}
}

void main(){
	int a[][4]={3,16,87,65,4,32,11,108,10,25,12,37};
	int b[3],i,j;
	fun(a,b);
	printf("\narray a:\n");
	for(i=0;i<=2;i++){
		for(j=0;j<=3;j++)
			printf("%5d",a[i][j]);
		printf("\n");
	}
	printf("array b:\n");
	for(i=0;i<=2;i++)
		printf("%5d",b[i]);
	printf("\n");
}

数组是在内存中连续存储的具有相同类型的一组数据的集合。
数组在内存中连续存放且元素下标越大，其地址越高。
数组是使用下标来访问的，下标是从0开始。
数组的大小可以通过计算得到：int sz = sizeof(arr)/sizeof(arr[0])

九霄云客

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
C/C++、Java、Python的比较及学习（4）

字符串的比较方法为：对两个字符串从左至右按字符的ASCII码值大小逐个字符相比较，直到出现不同的字符或遇到’\0’为止。选择排序：先找出10个数中的最小者（降序是找最大者）与数组中的第一个数a[0]交换，再从a[1]~a[9]中找出最小数与a[1]交换…然后，我们可以定义一个函数，接受一个字符串作为输入，使用 re.split() 函数按照空格分割字符串，并返回分割后的单词列表。为了在被调用函数中处理数组元素的需要，可以另设一个参数，传递数组元素的个数。（2）字符串1>字符串2，返回值为一个正整数。
复制链接

扫一扫