c语言指针数组排序?

Posted 2023-03-17

用指针实现：由键盘输入10个整数，将他们按由小到大的顺序排列。
输入： 键盘输入的10个整数。
输出： 按由小到大的顺序排列。
输入样例： 1 5 4 3 2 9 23 11 5 7
输出样例： 1 2 3 4 5 5 7 9 11 23
#include<stdio.h>
main()

char i,a[10];
float *p;
p=a;
for(i=0;i<10;i++)
gets(a[i]);
if(a[i]>a[i+1])

p=a[i];
a[i]=a[i+1];
a[i]=p;

printf("%d\n",i);


哪里错误?!

p是int类型指针，指向数组a的第1个元素即一个一维的数组1,2,3首地址所以p[1]相当于a[0][1]所以printf("%d\n",p[1]);
输出2 。 int **pp =pa 是声明了一个指向pa的指针，而pa又是指向a首地址的int类型指针。pa指向的是a的第一维，pa[0] = a[0] ，pp[2][1]相当于a[2][1]而a数组的[2]中只初始化了[2][0]位置的7，那[2][1]位置就是默认的值0，所以printf("%d\n",pp[2][1]);
输出0 参考技术A //冒泡排序算法
#include<stdio.h>
void swap2(int*,int*);
void bubble(int a[],int n);
int main(void)

int n,a[8];
int i;

printf("Enter n(n<=8):");
scanf("%d",&n);
printf("Enter a[%d]:",n);
for(i=0;i<n;i++)
scanf("%d",&a[i]);
bubble(a,n);

printf("After sorted,a[%d]=",n);//输出
for(i=0;i<n;i++)
printf("%3d",a[i]);

return 0;

void bubble(int a[],int n) //n是数组a中待排序元素的数量

int i,j;
for(i=1;i<n;i++) //外部循环
for(j=0;j<n-i;j++) //内部循环
if(a[j]>a[j+1]) //比较两个数的大小
swap2(&a[j],&a[j+1]); //如果前一个元素大，则交换

void swap2(int*px,int*py)

int t; //两数交换
t=*px;
*px=*py;
*py=t;
参考技术B #include<stdio.h>
main()

char i,a[10];/*这里是int*/
float *p;/*这里也是int p */
p=a;/*这个不要*/
for(i=0;i<10;i++)/*这里是10-1*/
gets(a[i]);
if(a[i]>a[i+1])

p=a[i];
a[i]=a[i+1];
a[i]=p;

printf("%d\n",i);/*for(i=0;i<10;i++)printf("%d",a[i]);*/
参考技术C #include<stdio.h>
void main()

void paixu(int *);
int a[10],*p;
p=a;
for(;p<a+10;p++)
scanf("%d",p);
paixu(a);
for(p=a;p<a+10;p++)
printf("%4d"*p);

void paixue(int *p)
int *i,*j,num;
for(i=p;i<p+10;i++)
for(j=i;j<i+10;j++)
if(*i>*(j+1))

mun=*i;
*i=*(j+1);
*(j+1)=mun;
参考技术D 输出的应该还是数组里的值而不是下标吧。另外i应该定义成int型不能定义为char型。先初始化时循环读入十个数，比较时也要循环十次，不能放一个for循环里边。

C 语言二级指针内存模型 ( 指针数组 | 二维数组 | 自定义二级指针 | 将 一二 模型数据拷贝到 三 模型中 并 排序 )

文章目录

• 一、指针数组 和 二维数组 数据 拷贝到 自定义二级指针 中
• • 1、函数形参 设计规则
  • 2、三种内存模型 对应 函数形参 指针退化规则
• 二、完整代码示例

一、指针数组 和 二维数组 数据 拷贝到 自定义二级指针 中

---

将 指针数组 和 二维数组 中的数据 拷贝到 自定义二级指针 内存模型中 , 并进行排序 ;

1、函数形参 设计规则

函数形参 设计规则 : 向 函数中 传入 二级指针 , 如果只是 使用 该 二级指针 指向的数据 , 可以 直接传入 二级指针 作为形参 ; 如果 需要 修改 二级指针 的指向 , 则需要 传入 三级指针 ;

2、三种内存模型 对应 函数形参 指针退化规则

① 指针数组 : 指针数组 参数 , 外层是数组 , 内层是指针 , 外层数组 退化成 指针 , 整体退化成 二级指针 ;

    // 指针数组
    char *p1[] = "ab", "ef", "cd";

退化为 :二级指针 ;

char **p1

② 二维数组 : 二维数组 , 最高维退化成 指针 , 整体退化成 数组指针 , 指向数组的指针 ;

    // 二维数组
    char p2[3][5] = "13", "35", "22";

退化为 : 数组指针 ;

// 数组指针 
char (*p2)[5]

③ 二维指针 : 二维指针 作为参数 不退化 ;

    // 二级指针
    char **p3 = NULL;

退化为 :

// 二维指针 
char **p3

代码示例 :

/**
 * @brief copy_data 将 指针数组 和 二维数组 中的数据拷贝到 二维指针 中
 * @param p1 指针数组 参数 , 外层是数组 , 内层是指针 , 外层数组 退化成 指针 , 整体退化成 二级指针
 * @param count1 指针数组 中的 指针变量元素个数
 * @param p2 二维数组 , 最高维退化成 指针 , 整体退化成 数组指针 , 指向数组的指针
 * @param count2 二维数组的 一维数组 个数
 * @param newp 指向 二级指针 的 三级指针
 * @param count3p 指向一个数字的指针 , 该 数字是 二级指针 指向的 一级指针 个数
 * @return
 */
int copy_data(char **p1, int count1, char (*p2)[5], int count2, char ***newp, int *count3p)

二、完整代码示例

---

完整代码示例 :

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

/* 计算数组 array 大小 */
#define LENGTH(array) (sizeof(array)/sizeof(*array))

/**
 * @brief copy_data 将 指针数组 和 二维数组 中的数据拷贝到 二维指针 中
 * @param p1 指针数组 参数 , 外层是数组 , 内层是指针 , 外层数组 退化成 指针 , 整体退化成 二级指针
 * @param count1 指针数组 中的 指针变量元素个数
 * @param p2 二维数组 , 最高维退化成 指针 , 整体退化成 数组指针 , 指向数组的指针
 * @param count2 二维数组的 一维数组 个数
 * @param newp 指向 二级指针 的 三级指针
 * @param count3p 指向一个数字的指针 , 该 数字是 二级指针 指向的 一级指针 个数
 * @return
 */
int copy_data(char **p1, int count1, char (*p2)[5], int count2, char ***newp, int *count3p)

    // 返回值
    int ret = 0;

    // 循环控制变量
    int i = 0, j = 0;

    // 临时长度
    int len = 0;

    // 创建的新的 二级指针 , 用于存放 指针数组 二维指针 中的数据
    char **p3 = NULL;

    // 分配一块内存 , 这块内存中存放 count1 + count2 个一级指针
    p3 = (char **)malloc((count1 + count2) * sizeof(char *));

    // 验证指针合法性
    if (p3 == NULL)
    
        ret = -1;
        return ret;
    

    // 遍历将 p1 指针数组 中的数据 拷贝到 二级指针 中
    for (i = 0; i < count1; i++)
    
        // 指针数组 中指针 指向的 字符串长度
        // 最后的 + 1 是加上 \\0 字符
        len = strlen(p1[i]) + 1;

        // 为 指向字符串的 一级指针 在堆内存中分配内存
        p3[i] = (char *)malloc( len * sizeof(char)) ;
        // 如果堆内存分配失败 , 直接退出
        if (p3[i] == NULL)
        
            return -2;
        

        // 向堆内存中拷贝 字符串 数据
        strcpy(p3[i], p1[i]);
    

    // 遍历将 p2 二维数组 中的数据 拷贝到 二级指针 中
    // 之前已经拷贝了 count1 个 , 因此从第 count1 + 1 位置开始拷贝
    // 第 count1 + 1 个的索引从 0 开始 , 其索引是 count1 ;
    for (j = 0; j < count2; j++)
    
        // 计算 二维数组 中第 j 个一维数组 字符串长度
        // 最后的 + 1 是加上 \\0 字符
        len = strlen(p2[j]) + 1;

        // 为 指向字符串的 一级指针 在堆内存中分配内存
        p3[count1 + j] = (char *)malloc(len * sizeof(char));

        // 堆内存分配失败 , 退出
        if (p3[count1 + j] == NULL)
        
            return -3;
        

        // 向堆内存中拷贝 字符串 数据
        strcpy(p3[count1 + j], p2[j]);
    

    // p3 二维指针 中存储的 字符串个数
    len = count1 + count2;

    // 指针 间接赋值 作为 返回值
    *count3p = len; // 二维指针 赋值给 三维指针形参 指向的内存地址
    *newp = p3;     // 字符串个数 赋值

    return 0;


/**
 * @brief sort_data 二级指针 指向的 一级指针 数据排序
 * 需要修改 二级指针 指向的一级指针次序
 * 二级指针 不需要修改 , 因此这里传入 二级指针即可
 * 如果需要修改 二级指针 , 则需要传入 三级指针
 * @param p3 二级指针 数据
 * @param num3 二级指针 指向的 一级指针 个数
 * @return
 */
int sort_data(char **p3, int len)

    // 循环控制变量
    int i = 0, j = 0;

    // 交换 字符串 时的临时变量
    char *p = NULL;

    // 验证指针合法性
    if(p3 == NULL)
    
        return -1;
    

    // p3 指向的 若干 字符串 之间的排序
    for (i = 0; i < len; i++)
    
        for (j = i + 1; j < len; j++)
        
            if ( strcmp(p3[i], p3[j]) > 0 )
            
                // 交换 i, j 位置的 一级指针
                p = p3[i];
                p3[i] = p3[j];
                p3[j] = p;
            
        
    
    return 0;


/**
 * @brief sort_data 二级指针 指向的 一级指针 数据排序
 * 需要修改 二级指针 指向的一级指针次序
 * 二级指针 不需要修改 , 因此这里传入 二级指针即可
 * 如果需要修改 二级指针 , 则需要传入 三级指针
 * @param p3 二级指针 数据
 * @param num3 二级指针 指向的 一级指针 个数
 * @return
 */
int print_data(char **p3, int len)

    // 循环控制变量
    int i = 0;

    // 交换 字符串 时的临时变量
    char *p = NULL;

    // 验证指针合法性
    if(p3 == NULL)
    
        return -1;
    

    // p3 指向的 若干 字符串 之间的排序
    for (i = 0; i < len; i++)
    
        printf("%s\\n", p3[i]);
    
    return 0;



/**
 * @brief 主函数入口
 * @return
 */
int main(int argc, char* argv[], char**env)


    // 指针数组
    char *p1[] = "ab", "ef", "cd";
    // 二维数组
    char p2[3][5] = "13", "35", "22";
    // 二级指针
    char **p3 = NULL;

    // 存储 p3 指向的一级指针个数
    int len3 = 0;

    // 将 指针数组 二维数组 数据 拷贝到 二级指针 中
    copy_data(p1, 3, p2, 3, &p3, &len3);

    // 拷贝之后的结果
    print_data(p3, len3);

    // 数据排序
    sort_data(p3, len3);


    // 打印排序之后的结果
    printf("\\nSort :\\n");
    print_data(p3, len3);

    // 命令行不要退出
    system("pause");
    return 0;

执行结果 :

ab
ef
cd
13
35
22

Sort :
13
22
35
ab
cd
ef
请按任意键继续. . .