本地部署deepseek-r1:7b模型

本地部署Deepseek

环境：win11 16G内存 NVIDIA GeForce RTX 2060显卡

安装Ollama

Tips:Ollama是一个用方便用户在本地机器上部署和运行大语言模型的工具

ollama官网下载传送门

默认的安装路径为c盘，这边修改为指定路径

修改方式：新增OLLAMA_MODELS的环境变量

验证是否修改成功，黑窗口中输入ollama

出现以上信息就说明安装成功了

拉取模型

结合我自己电脑的显卡，我这边搞个7b的版本

网上找的各种模型需要的显存大小作为参考

拉取7b命令（后续重新进入和重新启动也可以用这个命令）

ollama run deepseek-r1:7b

7b文件大小有4.7G，可能要一会儿

ollama查看模型列表命令

ollama list

ollama查看正在运行的模型命令

ollama ps

停止正在运行的模型命令

ollama stop 模型名称

ollmam删除模型命令

ollama remove 模型名称

安装成功后就可以进行对话了

对话测试：

用Java写一个快速排序的算法

以下是回答的全部内容，感觉还是很快的，条理清晰

>>> 用Java写一个快速排序的算法
<think>
嗯，用户让我用Java写一个快速排序的算法。首先，我得确认用户的需求是什么。他们可能需要一个示例代码来理解如何实现快速排
序。

快速排序是分治算法，所以我要想到递归和选择基准元素的过程。首先，我得选择一个基准元素，通常可以选择数组的第一个元素、
最后一个或者中间那个作为基准。

接下来，我需要写一个partition函数，这个函数的作用是将数组分为两部分，左边小于等于基准，右边大于等于基准。这一步很重
要，因为它确定了左右区间的划分。

然后，递归地对左半部分和右半部分进行排序。这样，整个数组就会被快速排序完成。

在编写代码时，我得考虑参数类型、方法名以及处理边界情况，比如数组为空或者只有一个元素的情况。这些都是避免栈溢出和错误
的重要步骤。

最后，我要测试一下代码的正确性。可以写一个测试类，初始化一个整数数组，调用quickSort方法排序，然后打印结果看看是否正
确。

总之，我需要一步步构建快速排序算法，确保每个部分都清晰明了，并且能够处理各种情况。
</think>

以下是一个使用Java实现快速排序（Quick Sort）的示例代码：

```java
public class QuickSort {
    public static void main(String[] args) {
        int[] array = {12, 11, 13, 5, 6, 7};
        quickSort(array);
        System.out.println("Sorted array: ");
        for (int num : array) {
            System.out.print(num + " ");
        }
    }

    public static void quickSort(int[] array) {
        if (array.length <= 1) {
            return;
        }

        int pivotIndex = array.length / 2; // 选择中间元素作为基准
        int pivot = array[pivotIndex];

        // 分区操作
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            // 找到大于基准的左边界
            while (left <= right && array[left] <= pivot) {
                left++;
            }

            // 找到小于基准的右边界
            while (left <= right && array[right] >= pivot) {
                right--;
            }

            if (left <= right) {
                // 交换元素
                int temp = array[left];
                array[left] = array[right];
                array[right] = temp;
            }
        }

        // 递归排序左半部分和右半部分
        quickSort(array, 0, left - 1);
        quickSort(array, right + 1, array.length - 1);

    }

    public static void quickSort(int[] array, int left, int right) {
        if (left >= right) {
            return;
        }

        // 随机选择基准（可选）
        int pivotIndex = left + (right - left) * Math.random() % (right - left + 1);
        int pivot = array[pivotIndex];

        int i = left;
        int j = right;

        while (i <= j) {
            // 找到第一个大于基准的元素
            while (i <= j && array[i] < pivot) {
                i++;
            }

            // 找到最后一个小于基准的元素
            while (i <= j && array[j] > pivot) {
                j--;
            }

            if (i <= j) {
                int temp = array[i];
                array[i] = array[j];
                array[j] = temp;
            }
        }

        quickSort(array, left, i - 1);
        quickSort(array, j + 1, right);
    }
}
```

### 解释

1. **快速排序算法**：
   - 快速排序是一种分治算法，选择一个基准元素（pivot），将数组划分为两部分：左半部分的元素小于等于基准，右半部分的元素大于等于基准。
   - 使用递归对左右两个子数组进行排序。

2. **代码结构**：
   - `main` 方法初始化一个整数数组，并调用 `quickSort` 方法对其进行排序。
   - `quickSort` 方法有两个版本：一个接受整个数组，另一个接受子区间 `[left, right]`。默认情况下，第一个版本调用后会自动递归排序左右子数组。

3. **分区操作**：
   - 使用两个指针 `i` 和 `j` 分别从左到右和从右到左遍历数组。
   - 确保 `array[i] < pivot`（左指针移动）。
   - 确保 `array[j] > pivot`（右指针移动）。
   - 交换 `array[i]` 和 `array[j]`，直到 `i >= j`。

4. **基准选择**：
   - 基准选择为数组中间元素以减少极端情况的影响，同时也可以随机选择或固定选择最后一个元素作为优化策略。

### 注意事项

- 快速排序的时间复杂度为 \(O(n \log n)\)，平均情况下表现优异。
- 在最坏情况下（如数组已经是有序的），时间复杂度退化为 \(O(n^2)\)。可以通过随机选择基准或使用更高级的分区技巧来优化。
- 对于大规模数据集，可以考虑使用归并排序或其他算法。

希望这个示例代码对您有所帮助！如果有任何问题，欢迎随时提出。

这是他回答一个年终报告是截取的电脑各部件信息