数组类

对输入的n个数进行排序并输出

输入：

    输入的第一行包括一个整数n(1<=n<=100)。
    接下来的一行包括n个整数。

输出：

    可能有多组测试数据，对于每组数据，将排序后的n个整数输出，每个数后面都有一个空格。
    每组测试数据的结果占一行。

 

#include <stdio.h>
void quick_sort( int num[], int begin, int end ){
        if( begin < end ){
                int left = begin;
                int right = end;
                int temp = num[left];
                while( left < right ){
                        while( left<right && num[right]>=temp ){
                                right--;
                        }
                        if( left<right ){
                                num[left++] = num[right];
                        }
                        while( left<right && num[left]<temp ){
                                left++;
                        }
                        if( left<right ){
                                num[right--] = num[left];
                        }
                }
                num[left] = temp;
                quick_sort(num, begin, left-1);
                quick_sort(num, left+1, end);
        }
}
int main(){
        int num[100];
        int n;
        while( scanf("%d",&n) != EOF ){
                for( int i=0; i<n; i++){
                        scanf("%d",&num[i]);
                }
                quick_sort( num, 0, n-1 );
                for( int i=0; i<n; i++){
                        printf("%d ",num[i]);
                }
                printf("\n");
        }
        return 0;
}

 

 

在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

题目描述：

在一个二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

输入：

输入可能包含多个测试样例，对于每个测试案例，

输入的第一行为两个整数m和n(1<=m,n<=1000)：代表将要输入的矩阵的行数和列数。

输入的第二行包括一个整数t(1<=t<=1000000)：代表要查找的数字。

接下来的m行，每行有n个数，代表题目所给出的m行n列的矩阵(矩阵如题目描述所示，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。

输出：

对应每个测试案例，

输出”Yes”代表在二维数组中找到了数字t。

输出”No”代表在二维数组中没有找到数字t。

样例输入：

3 351 2 34 5 67 8 93 312 3 45 6 78 9 103 3122 3 45 6 78 9 10

样例输出：

YesNoNo

//#include <iostream>

#include <stdio.h>



int main()

{

    //using std::cin;

    //using std::cout;

    //using std::endl;



    int rows = 0, cols = 0;

    //while (cin >> rows >> cols)

    while (scanf("%d %d", &rows, &cols) != EOF)

    {

        int find;

        //cin >> find;

        scanf("%d", &find);



        int ** arr = new int *[rows];

        for (int r = 0; r < rows; r ++)

        {

            arr[r] = new int [cols];

            for (int c = 0; c < cols; c ++)

            {

                //cin >> arr[r][c];

                scanf("%d", &arr[r][c]);

            }

        }



        // Check

        // 鉴于递增的规律性，此处通过判断每一行的第一个数组元素来决定需要检查的数字在哪一个范围内

        int rrr = 0; //保存属于的行数组

        int find_flag = 0; //是否已经确定结论的标记

        // 为了快速，先判断第一个元素是否等于当前的检查值

        if (arr[0][0] == find)

        {

            find_flag = 1;

            //cout << "Yes";

            printf("%s", "Yes");

        }

        else

        {

            for (int rr = 1; rr < rows; rr ++)

            {

                if (arr[rr][0] == find)

                {

                    find_flag = 1;

                    //cout << "Yes";

                    printf("%s", "Yes");

                    break;

                }

                else

                {

                    if (arr[rr - 1][0] < find && arr[rr][0] > find)

                    {

                        find_flag = 2; //不需要进行末行处置

                        rrr = rr - 1;

                    }

                    // 末行修正判断

                    if (find_flag != 2 && rr == rows - 1)

                    {

                        if (arr[rr][0] > find)

                        {

                            find_flag = 1;

                            rrr = 0;

                            //cout << "No";

                            printf("%s", "No");

                            break;

                        }

                        else

                        {

                            rrr = rr;

                        }

                    }

                }

            }

        }



        // check

        if (find_flag != 1)

        {

            // cout << rrr << endl;

            for (int cc = 0; cc < cols; cc ++)

            {

                if (arr[rrr][cc] == find)

                {

                    find_flag = 1;

                    //cout << "Yes";

                    printf("%s", "Yes");

                    break;

                }

            }

            if (find_flag != 1)

            {

                //cout << "No";

                printf("%s", "No");

            }

        }



        //cout << endl;

        printf("%s", "\n");



        // cout << arr[rows - 1][cols - 1] << endl;



        // Release

        for (int r = 0; r < rows; r ++)

        {

            delete arr[r];

        }

        delete [] arr;

    }



    return 0;

}

 3、题目描述：有N个学生的数据，将学生数据按成绩高低排序，如果成绩相同则按姓名字符的字母序排序，如果姓名的字母序也相同则按照学生的年龄排序，并输出N个学生排序后的信息。

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

struct student{
        char name[101];
        int age;
        int grade;
};

int partition(struct student *A, int left, int right);
void quicksort(struct student *A, int begin, int end);

int main()
{
        struct student students[1001];
        int i, n;

        while(scanf("%d",&n) != EOF)
        {
                //学生成绩赋值
                for(i = 0; i < n; i ++)
                {
                        scanf("%s%d%d",students[i].name, &students[i].age, &students[i].grade);
                }

                //快速排序
                quicksort(students, 0, n-1);

                //打印输出
                for(i = 0; i < n; i ++)
                {
                        printf("%s %d %d\n",students[i].name, students[i].age, students[i].grade);
                }
        }

        return 0;
}

void quicksort(struct student *A, int begin, int end)
{
        int pivot;

        if(begin < end)
        {
                pivot = partition(A, begin, end);
                quicksort(A, begin, pivot - 1);
                quicksort(A, pivot + 1, end);
        }
}

int partition(struct student *A, int left, int right)
{
        struct student stand = A[left];

        while(left < right)
        {
                while(left < right && (A[right].grade > stand.grade || (A[right].grade == stand.grade && strcmp(A[right].name,stand.name) > 0) || (A[right].grade == stand.grade && strcmp(A[right].name,stand.name) == 0 && A[right].age > stand.age ) ) )
                {
                        right --;
                }
                if(left < right)
                {
                        A[left ++] = A[right];
                }

                while(left < right && (A[left].grade < stand.grade || (A[left].grade == stand.grade && strcmp(A[left].name,stand.name) < 0) || (A[left].grade == stand.grade && strcmp(A[left].name,stand.name) == 0 && A[left].age < stand.age ) ) )
                {
                        left ++;
                }
                if(left < right)
                {
                        A[right --] = A[left];
                }
        }
        A[left] = stand;
        return left;
}