- 冒泡排序：首先将待排序数列中的第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])
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
