c# 基础习题答案 20240709

一、实现一个冒泡排序函数

using System;

public class Program
{
    public static void Main()
    {
        int[] arr = { 22,11,33 };

        BubbleSort(arr);

        foreach (var item in arr)
        {
            Console.Write(item + " ");
        }
        Console.WriteLine();

    }

    // 冒泡排序函数
    public static void BubbleSort(int[] array)
    {
        for (int i = 0; i < array.Length; i++)
        {
            for (int j = i; j < array.Length; j++)
            {
                if (array[i] < array[j])
                {
                    int temp = array[j];
                    array[j] = array[i];
                    array[i] = temp;
                }
            }
        }
    }
}

二、实现一个二分法函数

   class Program
    {
        static void Main(string[] args)
        {                                         // 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15, 16, 17, 18,                
            Console.WriteLine(TestFun(new int[19] { 1,2,3,4,5,6,7,8,9,9,11,11,11,11,14,15,119,122,133},119));
            Console.ReadLine();
        }

        private static int TestFun(int[] source, int target)
        {
            //数组左边界索引值
            int left = 0;
            //数组的右边界索引值
            int right = source.Length;
            //数组的中位值的索引值
            int mid = 0;

			//在循环中，根据中位值与目标值对比，更新左（右）边界的值，从而缩小检索范围，直到找到目标值。
            while(left <= right)
            {   //每循环一次，中位值索引也要随着左（右）边界的改变而改变
                mid = (left + right) / 2;
                
                if(source[mid].Equals(target))
                {
                    return mid;
                }      //中位值在目标值左边时更新左边界索引
                else if(source[mid] < target)
                {
                    left = mid + 1;
                }    //中位值在目标值右边时更新右边界索引
                else if(source[mid] > target)
                {
                    right = mid - 1;
                }
            }


            return -1;
        }
    }

三、写出继承、封装、多态的定义，并根据定义写出对应代码示例

1. 继承（Inheritance）：

• 继承允许一个类（称为子类或派生类）基于另一个类（称为父类或基类）的定义来构建。子类继承了父类的字段和方法，可以在此基础上添加新的功能或修改现有功能。
• 示例代码：

// 父类
public class Animal
{
    public string Name { get; set; }
    
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

// 子类继承父类
public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof!");
    }
}

// 使用继承后的子类
class Program
{
    static void Main()
    {
        Dog myDog = new Dog();
        myDog.Name = "Buddy";
        myDog.Speak(); // 输出: "Woof!"
    }
}

2. 封装（Encapsulation）：

• 封装是将数据（字段）和操作数据的方法（函数）封装在一个类中的概念。通过使用访问修饰符来限制对类的部分内容的访问，可以控制对象的访问级别和安全性。

• 示例代码：

public class Car
{
    private int _mileage; // Private variable

    public void Drive(int miles)
    {
        _mileage += miles;
    }

    public int GetMileage()
    {
        return _mileage;
    }
}

class Program
{
    static void Main()
    {
        Car myCar = new Car();
        myCar.Drive(100);
        Console.WriteLine(myCar.GetMileage()); // 输出: 100
    }
}

3. 多态（Polymorphism）：

• 多态允许使用同一个方法名在不同的类中产生不同的行为。这提高了代码的灵活性，可以根据不同的对象类型调用相同的方法而表现出不同的行为。
• 示例代码：

public class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("Animal speaks");
    }
}

public class Dog : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Woof!");
    }
}

public class Cat : Animal
{
    public override void Speak()
    {
        Console.WriteLine("Meow!");
    }
}

class Program
{
    static void MakeSound(Animal animal)
    {
        animal.Speak();
    }

    static void Main()
    {
        Animal myDog = new Dog();
        Animal myCat = new Cat();

        MakeSound(myDog); // 输出: "Woof!"
        MakeSound(myCat); // 输出: "Meow!"
    }
}

四、写出函数重载的定义，并根据定义写出对应代码示例

• 函数重载（Function
  Overloading）是指在同一个类中包含多个同名函数，但是这些函数的参数类型、参数个数或顺序不同。这样，可以通过传递不同类型的参数或不同数量的参数来调用同一个函数名，而编译器能够根据传入的参数类型和数量来分辨到底要调用哪个函数。

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }

    public double Add(double a, double b)
    {
        return a + b;
    }

    public int Add(int a, int b, int c)
    {
        return a + b + c;
    }

    public int Add(params int[] numbers)
    {
        int sum = 0;
        foreach (var number in numbers)
        {
            sum += number;
        }
        return sum;
    }
}

class Program
{
    static void Main()
    {
        Calculator calculator = new Calculator();

        int result1 = calculator.Add(1, 2); // 使用第一个Add函数
        double result2 = calculator.Add(1.5, 2.5); // 使用第二个Add函数
        int result3 = calculator.Add(1, 2, 3); // 使用第三个Add函数
        int result4 = calculator.Add(1, 2, 3, 4, 5); // 使用第四个Add函数，使用params特性

        Console.WriteLine($"Result 1: {result1}");
        Console.WriteLine($"Result 2: {result2}");
        Console.WriteLine($"Result 3: {result3}");
        Console.WriteLine($"Result 4: {result4}");
    }
}

五、下面是创建三张数据表并插入数据的SQL语句，以及基于这些数据表的20条基础SQL查询问题。

表1: 员工 (Employees)

-- 创建员工表

CREATE TABLE Employees (
    EmployeeID INT PRIMARY KEY,
    FirstName NVARCHAR(50),
    LastName NVARCHAR(50),
    DepartmentID INT,
    Salary DECIMAL(10, 2),
    HireDate DATE
);

-- 插入员工数据

INSERT INTO Employees VALUES
(1, '张伟', '李', 101, 60000.00, '2020-01-15'),
(2, '王芳', '刘', 102, 75000.00, '2019-05-20'),
(3, '李娜', '张', 101, 55000.00, '2021-03-10'),
(4, '陈杰', '王', 103, 65000.00, '2018-11-28'),
(5, '赵强', '刘', 102, 70000.00, '2020-09-05');

表2: 部门 (Departments)

-- 创建部门表

CREATE TABLE Departments (
    DepartmentID INT PRIMARY KEY,
    DepartmentName NVARCHAR(100),
    Manager NVARCHAR(100)
);

-- 插入部门数据

INSERT INTO Departments VALUES
(101, '人力资源部', '张经理'),
(102, '财务部', '李经理'),
(103, '信息技术部', '王经理');

表3: 订单 (Orders)

-- 创建订单表

CREATE TABLE Orders (
    OrderID INT PRIMARY KEY,
    EmployeeID INT,
    OrderDate DATE,
    TotalAmount DECIMAL(10, 2)
);

-- 插入订单数据

INSERT INTO Orders VALUES
(1, 1, '2023-01-10', 1500.00),
(2, 2, '2023-01-12', 2500.00),
(3, 1, '2023-02-05', 1800.00),
(4, 3, '2023-02-15', 3200.00),
(5, 2, '2023-03-20', 2000.00);

20条基础SQL查询问题

1. 查询所有员工的信息。

SELECT * FROM Employees;

2. 查询所有薪资大于60000的员工。

SELECT * FROM Employees WHERE Salary > 60000.00;

3. 列出所有部门及其经理姓名。

SELECT DepartmentName, Manager FROM Departments;

4. 统计每个部门的员工数量。

SELECT d.DepartmentName, COUNT(e.EmployeeID) AS EmployeeCount
FROM Employees e
JOIN Departments d ON e.DepartmentID = d.DepartmentID
GROUP BY d.DepartmentName;

5. 查询2020年之前入职的员工。

SELECT * FROM Employees WHERE HireDate < '2020-01-01';

6. 计算人力资源部的总薪资预算。

SELECT SUM(Salary) AS TotalSalaryBudget
FROM Employees
WHERE DepartmentID = 101;

7. 查询所有员工中最早和最新的入职日期。

SELECT MIN(HireDate) AS OldestHireDate, MAX(HireDate) AS NewestHireDate
FROM Employees;

8. 按薪资从高到低排序查询所有员工。

SELECT * FROM Employees ORDER BY Salary DESC;

9. 计算所有员工的平均薪资。

SELECT AVG(Salary) AS AverageSalary FROM Employees;

10. 查询2023年1月的所有订单。

SELECT * FROM Orders WHERE OrderDate >= '2023-01-01' AND OrderDate < '2023-02-01';

11. 列出所有下过订单的员工。

SELECT DISTINCT e.FirstName, e.LastName
FROM Employees e
JOIN Orders o ON e.EmployeeID = o.EmployeeID;

12. 查询员工及其对应的部门名称。

SELECT e.FirstName, e.LastName, d.DepartmentName
FROM Employees e
JOIN Departments d ON e.DepartmentID = d.DepartmentID;

13. 统计总订单数量。

SELECT COUNT(*) AS TotalOrders FROM Orders;

14. 查询订单金额最高的订单。

SELECT MAX(TotalAmount) AS HighestOrderAmount FROM Orders;

15. 计算每个订单的平均金额。

SELECT AVG(TotalAmount) AS AverageOrderAmount FROM Orders;

16. 列出所有员工及其下的订单（如果有的话）。

SELECT e.FirstName, e.LastName, o.OrderID, o.TotalAmount
FROM Employees e
LEFT JOIN Orders o ON e.EmployeeID = o.EmployeeID;

17. 查询没有下过订单的员工。

SELECT e.FirstName, e.LastName
FROM Employees e
LEFT JOIN Orders o ON e.EmployeeID = o.EmployeeID
WHERE o.OrderID IS NULL;

18. 计算公司的总薪资支出。

SELECT SUM(Salary) AS TotalSalaryExpense FROM Employees;

19. 查询薪资最高的员工。

SELECT TOP 1 * FROM Employees ORDER BY Salary DESC;

20. 查询2021年入职的员工。

SELECT * FROM Employees WHERE YEAR(HireDate) = 2021;