代码1

最新推荐文章于 2021-08-01 09:23:27 发布
原创 最新推荐文章于 2021-08-01 09:23:27 发布 · 259 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。 

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

#define true 1
#define false 0
typedef int bool;

typedef struct Node
{
    int val;
    struct Node * next;
}NODE, *PNODE;

//函数声明
void traverse_list(PNODE pHead);
PNODE create_list(void);
bool is_empty(PNODE);
int length_list(PNODE);
bool insert_list(PNODE, int, int);
bool delete_list(PNODE, int, int*);
void sort_list(PNODE);

//对链表元素进行排序
void sort_list(PNODE pHead)
{
    int len = length_list(pHead);
    if (len <= 1)
    {
        printf("链表元素太少，无法执行排序操作");
        return;
    }
    int i, j, temp;
    PNODE p;                    //现在 p 指向的是首节点
    for (i = 0; i<len; i++)
    {
        p = pHead->next;          // 每一次循环执行时，需要从当前首节点向后执行
        for (j = 0; j<len - i - 1; j++)
        {
            if (p->val < p->next->val)
            {
                temp = p->val;
                p->val = p->next->val;
                p->next->val = temp;
            }
            p = p->next;
        }
    }//冒泡排序

}
//删除某个元素
bool delete_list(PNODE pHead, int pos, int* val)
{
    int i = 0;
    PNODE p = pHead;
    while (NULL != p->next && i<pos - 1)
    {
        p = p->next;
        i++;
    }
    if (i>pos - 1 || NULL == p->next)
    {
        return false;
    }
    PNODE r = p->next;  // 用 r 记住后，用来释放内存，防止内存泄露
    *val = p->next->val;
    p->next = p->next->next;
    free(r);
    r = NULL;
    return true;

}

//插入某个元素
bool insert_list(PNODE pHead, int pos, int value)
{

    int i = 0;
    PNODE p = pHead;
    while (NULL != p->next&&i<pos - 1)
    {
        p = p->next;
        i++;
    }
    if (i>pos - 1 || NULL == p->next)
    {
        return false;
    }
    //程序执行到这个地方时，说明已经找到了要插入的位置
    PNODE q = (PNODE)malloc(sizeof(NODE));
    if (NULL == q)
    {
        printf("内存分配失败，程序将退出");
        exit(-1);
    }
    q->val = value;
    q->next = p->next;
    p->next = q;
    return true;

}

//求链表的长度
int length_list(PNODE pHead)
{
    int len = 0;
    PNODE p = pHead;
    while (NULL != p->next)
    {
        len++;
        p = p->next;
    }
    return len;
}
bool is_empty(PNODE pHead)
{
    if (NULL == pHead->next)
    {
        return true;
    }
    else
    {
        return false;
    }
}

//构造链表
PNODE create_list(void)
{
    int len, i, value;
    printf("请输入您要创建的链表中的元素个数 len = ");
    scanf("%d", &len);
    PNODE pHead = (PNODE)malloc(sizeof(NODE));   //   最后需要返回的头指针
    pHead->next = NULL;
    PNODE pTail = pHead;                         // 最开始的时候尾指针指向头指针，因为元素个数为零。

    for (i = 0; i<len; i++)
    {
        PNODE pNew = (PNODE)malloc(sizeof(NODE));   //分配一个新节点
        printf("请输入第%d个元素中的value值 value = ", i + 1);
        scanf("%d", &value);
        pNew->val = value;       //构造新节点的值
        pNew->next = NULL;    // 构造新节点的指针域
        pTail->next = pNew;     // 将新节点挂到尾节点上
        pTail = pNew;              //更新尾节点，新挂上的节点为尾节点
    }

    return pHead;
}
//遍历整个链表，并输出
void traverse_list(PNODE pHead)
{
    PNODE p = pHead->next;
    while (NULL != p)
    {
        printf("%d ", p->val);
        p = p->next;
    }
    printf("\n");
}

//主函数
int main()
{

    PNODE pHead = create_list();
    traverse_list(pHead);
    if (is_empty(pHead))
    {
        printf("empty\n");
    }
    else
    {
        printf("not empty\n");
    }
    printf("------------------------------------------\n");
    int len = length_list(pHead);
    printf("链表的长度为 %d \n", len);
    printf("------------------------------------------\n");
    int val, pos;
    printf("请输入您要插入的位置 pos = ");
    scanf("%d", &pos);
    printf("请输入您要插入的数据 val = ");
    scanf("%d", &val);
    insert_list(pHead, pos, val);
    printf("------------------------------------------\n");
    printf("插入数据后的链表为\n");
    traverse_list(pHead);
    printf("------------------------------------------\n");
    printf("请输入您要删除的元素的位置为：");
    scanf("%d", &pos);
    while (!delete_list(pHead, pos, &val))
    {
        printf("删除失败，请重新输入要删除元素的位置");
        scanf("%d", &pos);
    }
    printf("删除后的链表遍历为：\n");
    traverse_list(pHead);
    printf("您删除的位置所在处的元素为：%d  \n", val);
    printf("------------------------------------------\n");

    sort_list(pHead);
    printf("排序后的链表输出为：\n");
    traverse_list(pHead);
    return 0;
}





////希尔排序
//void prshl(p, n)
//int n;
//double p[];
//{
//  int k, j, i;
//  double t;
//  k = n / 2;
//  while (k > 0)
//  {
//      for (j = k; j <= n - 1; j++)
//      {
//          t = p[j]; i = j - k;
//          while ((i > 0) && (p[i]) > t)
//          {
//              p[i + k] = p[i]; i = i - k;
//
//          }
//          p[i + k] = t;
//      }
//      k = k / 2;
//  }
//  return;
//}
//
////冒泡排序
//main()
//{
//  int a[11];
//  int i, j, k;
//  printf("intput 10 numbers:\n");
//  for (i = 1; i < 11; i++)
//      scanf("%d", &a[i]);
//  printf("\n");
//  for (i = 1; i <= 9;i++)
//  for (j = 1; j <= 10 - i; j++)
//      if (a[j]>a[j + 1])
//      {
//          k = a[j]; a[j] = a[j + 1]; a[j + 1] = k;
//      }
//      printf("the sorted numbers:\n");
//      for (i = 1; i < 11; i++)
//          printf("%d", a[i]);
//}
//直接插入排序
//void docr(float*in, int count)
//{
//  int i, j, x;
//  float temp;
//  for (i = 1; i < count; i++)
//  {
//      for (x = 0; x < i; x++)
//      {
//          if ((*(in + i)) <= (*(in + x)))
//              break;
//      }
//      temp = *(in + i);
//      for (j = i; j>x; j--)
//      {
//          *(in + j) = *(in + j - 1);
//      }
//      *(in + x) = temp;
//  }
//
//}
//二分法插入排序
//void docr(float*in, int count)
//{
//  int i, j, x;
//  int l, r, m;
//  float temp;
//  for (i = 1; i < count; i++)
//  {
//      l = 0;
//      r = i - 1;
//      temp = *(in + i);
//      while (l<=r)
//      {
//          m = (int)((l + r) / 2);
//          if (temp <= (*(in + m)))
//          {
//              r = m - 1;
//          }
//          else
//          {
//              l = m + 1;
//          }
//      }
//      for (j = i; j > l; j--)
//      {
//          *(in + j) = *(in + j - 1);
//      }
//      *(in + l) = temp;
//  }
//}
//
///*--------------------冒泡排序---------------------*/
//void bubleSort(int data[], int n)
//{
//  int i, j, temp;
//  两个for循环，每次取出一个元素跟数组的其他元素比较
//  将最大的元素排到最后。
//  for (j = 0; j<n - 1; j++)
//  {
//      外循环一次，就排好一个数，并放在后面，
//      所以比较前面n-j-1个元素即可
//      for (i = 0; i<n - j - 1; i++)
//      {
//          if (data[i]>data[i + 1]) 
//          {
//              temp = data[i];
//              data[i] = data[i + 1];
//              data[i + 1] = temp;
//          }
//      }
//  }
//}
//
///*--------------------快速排序---------------------*/
//int findPos(int data[], int low, int high) 
//{
//  将小于t的元素赶到t的左边，大于t的元素赶到t的右边
//  int t = data[low];
//  while (low < high) 
//  {
//      while (low < high && data[high] >= t)
//      {
//          high--;
//      }
//      data[low] = data[high];
//      while (low < high && data[low] <= t) 
//      {
//          low++;
//      }
//      data[high] = data[low];
//  }
//  data[low] = t;
//  返回此时t在数组中的位置
//  return low;
//}
//在数组中找一个元素，对大于该元素和小于该元素的两个数组进行再排序
//再对两个数组分为4个数组，再排序，直到最后每组只剩下一个元素为止
//void quickSort(int data[], int low, int high) 
//{
//  if (low > high) 
//  {
//      return;
//  }
//  int pos = findPos(data, low, high);
//  quickSort(data, low, pos - 1);
//  quickSort(data, pos + 1, high);
//}
//
///*--------------------插入排序---------------------*/
//void bInsertSort(int data[], int n) 
//{
//  int low, high, mid;
//  int temp, i, j;
//  for (i = 1; i<n; i++) 
//  {
//      low = 0;
//      把data[i]元素插入到它的前面data[0-(i-1)]中
//      temp = data[i];
//      high = i - 1;
//      该while是折半，缩小data[i]的范围(优化手段)
//      while (low <= high)
//      {
//          mid = (low + high) / 2;
//          if (data[mid] > temp) 
//          {
//              high = mid - 1;
//          }
//          else {
//              low = mid + 1;
//          }
//      }
//      int j = i;
//      让data与已经排序好的数组的各个元素比较，小的放前面
//      while ((j > low) && data[j - 1] > temp) 
//      {
//          data[j] = data[j - 1];
//          --j;
//      }
//      data[low] = temp;
//  }
//}
//
///*--------------------希尔排序---------------------*/
//void shellSort(int * data, int n) 
//{
//  int step, i, j, key;
//  将数组按照step分组，不断二分到每组只剩下一个元素
//  for (step = n / 2; step>0; step /= 2)
//  {
//      将每组中的元素排序，小的在前
//      for (i = step; i<n; i++) 
//      {
//          key = data[i];
//          for (j = i - step; j >= 0 && key<data[j]; j -= step)
//          {
//              data[j + step] = data[j];
//          }
//          和上面的for循环一起，将组中小的元素换到数组的前面
//          data[j + step] = key;
//      }
//  }
//}
//
///*--------------------选择排序---------------------*/
//void selectSort(int data[], int n) 
//{
//  int i, j, mix, temp;
//  每次循环数组，找出最小的元素，放在前面，前面的即为排序好的
//  for (i = 0; i<n - 1; i++) {
//      假设最小元素的下标
//      int mix = i;
//      将上面假设的最小元素与数组比较，交换出最小的元素的下标
//      for (j = i + 1; j<n; j++)
//      {
//          if (data[j] < data[mix]) 
//          {
//              mix = j;
//          }
//      }
//      若数组中真的有比假设的元素还小，就交换
//      if (i != mix) 
//      {
//          temp = data[i];
//          data[i] = data[mix];
//          data[mix] = temp;
//      }
//  }
//}
//
///*--------------------堆排序---------------------*/
//堆排序将数组先组成二叉树，默认从数组的data[1]开始排，data[0]是
//无效数据
//void heapSort(int data[], int n) 
//{
//  int i;
//  先将数组组成一棵完全二叉树
//  从2/n开始，就是从倒数第二排结点往前开始
//  for (i = n / 2; i>0; i--)
//  {
//      heapAdjust(data, i, n);
//  }
//  循环每个结点，将大的结点交换到堆顶
//  for (i = n; i>1; i--) 
//  {
//      swap(data, 1, i);
//      每次交换完都要调整二叉树，将剩下的最大的结点交换到堆顶
//      heapAdjust(data, 1, i - 1);
//  }
//}
//交换函数
//void swap(int data[], int i, int j)
//{
//  int temp;
//  temp = data[i];
//  data[i] = data[j];
//  data[j] = temp;
//}
//void heapAdjust(int data[], int i, int n) 
//{
//  int j, temp;
//  假设第一个结点的元素是最大的
//  temp = data[i];
//  i结点：2*i是i结点的左结点，2*i+1是i结点的右结点
//  把结点元素大的交换到前面
//  for (j = 2 * i; j <= n; j *= 2) {
//      if (j < n && data[j] < data[j + 1])
//      {
//          j++;
//      }
//      if (temp >= data[j]) 
//      {
//          break;
//      }
//      data[i] = data[j];
//      i = j;
//  }
//  data[i] = temp;
//}
//
///*--------------------归并排序---------------------*/
//void mergeSort(int data[], int first, int last) 
//{
//  int mid = 0;
//  将数组不停的二分分组再组合，直到每组只剩一个元素
//  if (first < last) 
//  {
//      mid = (first + last) / 2;
//      mergeSort(data, first, mid);
//      mergeSort(data, mid + 1, last);
//      merge(data, first, mid, last);
//  }
//  return;
//}
//void merge(int data[], int low, int mid, int high) 
//{
//  int i, k;
//  定义一个临时数组存放传进来的无序数组排好序之后的数组
//  int *temp = (int *)malloc((high - low + 1)*sizeof(int));
//  将无序数组分成两个序列
//  int left_low = low;
//  int left_high = mid;
//  int right_low = mid + 1;
//  int right_high = high;
//  将两个序列比较排序，小的排前
//  for (k = 0; left_low <= left_high && right_low <= right_high; k++)
//  {
//      if (data[left_low] <= data[right_low]) 
//      {
//          temp[k] = data[left_low++];
//      }
//      else{
//          temp[k] = data[right_low++];
//      }
//  }
//  左序列如果有剩下元素未排序，加到临时数组的末尾
//  if (left_low <= left_high) 
//  {
//      for (i = left_low; i <= left_high; i++) 
//      {
//          temp[k++] = data[i];
//      }
//  }
//  右序列如果有剩下元素未排序，加到临时数组的末尾
//  if (right_low <= right_high) 
//  {
//      for (i = right_low; i <= right_high; i++)
//      {
//          temp[k++] = data[i];
//      }
//  }
//  将排好序的小分组转移到原数组中
//  for (i = 0; i<high - low + 1; i++)
//  {
//      data[low + i] = temp[i];
//  }
//  free(temp);
//  return;
//}
///*--------------------基数排序---------------------*/
//该函数的作用是找出num的pos位数的数字(比如：23的个位数数字是3)
//int getNumPos(int num, int pos)
//{
//  int i;
//  int temp = 1;
//  for (i = 0; i<pos - 1; i++) 
//  {
//      temp *= 10;
//  }
//  return (num / temp) % 10;
//}
//void radixSort(int data[], int n)
//{
//  int i, j, k, pos, num, index;
//  这几句话是创建一个从0-9(行)× (n+1)(列)的网格，第一列从上往下是0-9,
//  第二列是该行包含的元素个数，默认为0个
//  int *radixArrays[10];
//  for (i = 0; i<10; i++) 
//  {
//      radixArrays[i] = (int *)malloc(sizeof(int)* (n + 1));
//      radixArrays[i][0] = 0;
//  }
//  pos最大为31为数，计算机能承受的最大范围了
//  for (pos = 1; pos <= 31; pos++) 
//  {
//      该for循环是将数组的元素按照位数(pos)的值放进网格内
//      for (i = 0; i<n; i++)
//      {
//          num = getNumPos(data[i], pos);
//          index = ++radixArrays[num][0];
//          radixArrays[num][index] = data[i];
//      }
//      该for循环是将上面的for循环已经按照某个位数(pos)排列好的元素存入数组
//      for (i = 0, j = 0; i<10; i++)
//      {
//          for (k = 1; k <= radixArrays[i][0]; k++) 
//          {
//              data[j++] = radixArrays[i][k];
//          }
//          清空网格，以便给下个位数排列
//          radixArrays[i][0] = 0;
//      }
//  }
//}
//费式搜寻
//#include<stdio.h>
//#include<stdlib.h>
//#include<time.h>
//#define MAX 15
//#define SWAP(x,y){int t;t=x;x=y;y=t;}
//
//void createfib(void);//建立费事数列
//int findx(int, int);//找x值
//int fibsearch(int[], int);//费式搜寻
//void quicksort(int[], int, int);//快速排序
//
//int Fib[MAX] = { -999 };
//
//int main(void)
//
//{
//  int number[MAX] = { 0 };
//  int i,find;
//  srand(time(NULL));
//  for (i = 1; i <= MAX; i++)
//  {
//      number[i] = rand() % 100;
//  }
//  quickSort(number, 1, MAX);
//  printf("数列：");
//  for (i = 1; i <= MAX; i++)
//
//      printf("%d", number[i]);
//  printf("\n输入寻找对象：");
//  scanf("%d", &find);
//  if ((i = fibsearch(number, find)) >= 0)
//      printf("找到数字于索引 %d", i);
//  else
//      printf("\n找不到指定数");
//  printf("\n");
//  return 0;
//  
//
//}
////建立费事数列
//void createfib(void)
//{
//  int i;
//  Fib[0] = 0;
//  Fib[1] = 1;
//  for (i = 2; i < MAX; i++)
//      Fib[i] = Fib[i - 1] + Fib[i - 2];
//}
////找x值
//int findx(int n, int find)
//{
//  int i = 0;
//  while (Fib[i] <= n)
//      i++;
//  i--;
//  return i;
//}
////费式搜寻
//int fibsearch(int number[], int find)
//{
//  int i, x, m;
//  createfib();
//  x = findx(MAX + 1, find);
//  m = MAX - Fib[x];
//  printf("\n=%d,m=%d,Fib[x]=%d\n\n", x, m, Fib[x]);
//  x--;
//  i = x;
//  if (number[i] < find)
//      i += m;
//  while (Fib[x]>0)
//  {
//      if (number[i] < find)
//          i += Fib[--x];
//      else if (number[i]>find)
//          i -= Fib[--x];
//      else
//          return i;
//  }
//  return -1;
//
//
//}
//void qiucksort(int number[], int left, int right)
//{
//  int i, j, k, s;
//  if (left < right)
//  {
//      s = number[(left + right) / 2];
//      i = left - 1;
//      j = right + 1;
//      while (1)
//      {
//          while (number[++i] < s);
//          while (number[--j]>s);
//          if (i>j)
//              break;
//          SWAP(number[i], number[j]);
//      }
//      quickSort(number, left, i - 1);
//      qiucksort(number, j + 1, right);
//  }
//}
//稀疏矩阵
//#include<stdio,h>
//#include<stdlib,h>
//
//int main(void)
//{
//  int num[5][3] = { { 5, 6, 4 }, { 1, 1, 3 }, { 2, 3, 6 }, { 3, 2, 9 }, { 4, 4, 12 } };
//  int i, j, k = 1;
//
//  printf("sparse matrix:\n");
//  for (i = 0; i < 5; i++)
//  {
//      for (j = 0; j < 3; j++)
//      {
//          printf("%4d", num[i][j]);
//      }
//      putchar("\n");
//  }
//  printf("\nmatrix还原：\n");
//  for (i = 0; i < num[0][0]; i++)
//  {
//      for (j = 0; j < num[0][1]; j++)
//      {
//          if (k < num[0][2] && i == num[k][0] && j == num[k][1])
//          {
//              printf("%4d", num[k][2]);
//              k++;
//          }
//          else
//              printf("%4d", 0);
//      }
//      putchar("\n");
//  }
//  return 0;
//}

//八皇后
//#include<stdio,h>
//#include<stdlib.h>
//#define N 8
//
//int column[N + 1];
//int rup[2 * N + 1];
//int lup[2 * N + 1];
//int queen[N + 1] = { 0 };
//int num;
//
//void backtrack(int);
//
//int main(void)
//{
//
//  int i;
//  num = 0;
//  for (i = 1; i <= N; i++)
//      column[i] = 1;
//
//  for (i = 1; i <= 2 * N; i++)
//      rup[i] = lup[i] = 1;
//
//  backtrack(1);
//
//  return 0;
//
//}
//void showAnswer()
//{
//  int x, y;
//  printf("\n解答%d\n", ++num);
//  for (y = 1; y <= N; y++)
//  {
//      for (x = 1; x <= N; x++)
//      {
//          if (queen[y] == x)
//          {
//              printf("Q");
//          }
//          else
//          {
//              printf(".");
//          }
//      }
//      printf("\n");
//  }
//}
//void backtrack(int i)
//{
//  int j;
//
//  if (i > N)
//  {
//      showAnswer();
//  }
//  else
//  {
//      for (j = 1; j <= N; j++)
//      {
//          if (column[j] == 1 && rup[i + j] == 1 && lup[i - j + N] == 1)
//          {
//              queen[i]=j;
//
//              column[j] = rup[i + j] = lup[i - j + N] = 0;
//              backtrack(i + 1);
//              column[j] = rup[i + j] = lup[i - j + N] = 1;
//          }
//      }
//  }
//}
a.out.h 头文件分析 \linux-1.0\linux\include\linux\a.out.h
GUANYIJUN123的专栏
01-17 1998
#ifndef __A_OUT_GNU_H__ #define __A_OUT_GNU_H__ #define __GNU_EXEC_MACROS__ #ifndef __STRUCT_EXEC_OVERRIDE__ //定义执行文件结构 struct exec { unsigned long a_info; /* Use macros N_MAGIC, etc for access
编写程序描述影视歌三栖艺人 需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。 实现思路及关键代码 1)分析影视歌三栖艺人的特性 a)可以演电影 b)可以演电视剧 c)可以唱歌
码走江湖的博客
09-08 6123
编写程序描述影视歌三栖艺人 需求说明：请使用面向对象的思想，设计自定义类，描述影视歌三梄艺人。 实现思路及关键代码 1)分析影视歌三栖艺人的特性 a)可以演电影 b)可以演电视剧 c)可以唱歌 2)定义多个接口描述特性 a)演电影的接口—–方法：演电影 b)演电视剧的接口—–方法：演电视剧 c)唱歌的接口—–方法：唱歌 3)定义艺人类实现多个接口 程序运行结果如图2所示。 ...
Attention(注意力机制代码)
07-16
`Keras框架-Attention代码1.txt`和`Keras框架-Attention代码2.txt`可能包含实现不同类型的注意力层的示例，例如简单加权注意力(Simple Weighted Attention)和自注意力(Self-Attention)，也称为Transformer注意力。...
软著申请：源代码文件模板，每页五十行，一共六十页
03-13
1. Java语言基础：该源代码文件模板使用Java语言编写，涉及到Java基础知识点，例如变量、数据类型、运算符、控制结构、函数等。 2. 接口和抽象类：在源代码文件模板中，出现了多个接口和抽象类，例如`UpdateBoard`...
Vector-XCP 源代码
07-06
1. XCP协议的C/C++实现：这是核心代码，实现了XCP协议的规范，包括数据包的构建、解析和传输。它可能会包含多个模块，如命令处理、错误检测和链路层接口。 2. 文档：这部分内容详细解释了XCP协议的原理和使用方法，...
【数据分析学习笔记day09】数据分析实战案例：2016美国大选民意调查统计+2016年美国总统大选民意调查数据统计+示例代码1 +示例代码2：
汪雯琦的博客
01-25 2870
文章目录2016年美国总统大选民意调查数据统计：示例代码1 ：示例代码2： 2016年美国总统大选民意调查数据统计： 项目地址：https://www.kaggle.com/fivethirtyeight/2016-election-polls 该数据集包含了2015年11月至2016年11月期间对于2016美国大选的选票数据，共27列数据 示例代码1 ： # loadtxt import...
部分代码1
Enoch的博客
11-01 302
原文的一部分原文 #!/usr/bin/env python #-*- coding:utf-8 -*- #author: Enoch time:2018/10/30 0030 import re import time from collections import Counter t0 = time.clock() ######################################...
找1代码
AndyZZhang的博客
02-07 274
题： 幼儿园水平： 2、依然不怎么好但是通过字符串来实现的代码
数据结构1代码
weixin_41606022的博客
02-04 353
顺序线性表 //include "stdafx.h" using namespace std; #include "iostream" #include "stdlib.h" #include "stdio.h" #define maxSize 10 #pragma region 定义顺序表 typedef struct { int data[maxSize]; int length; }Sq...
程序员常见系统错误代码大全：1到15841
热门推荐
南北极之间
02-19 12万+
程序员常见系统错误代码大全：1到15841 提示：使用浏览器的Ctrl + F键盘组合来搜索错误代码。要么搜索错误消息本身，要么只搜索错误代码，例如“错误代码635”。 系统错误代码大全：1到15841 错误代码1：功能不正确。[ERROR_INVALID_FUNCTION（0x1）] 错误代码2：系统找不到指定的文件。[ERROR_FILE_NOT_FOUND（0...
模拟题1
Android_ElitePerson的博客
04-29 290
&lt;!DOCTYPE html&gt;&lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;&lt;/title&gt; &lt;script src="js/angular.min.js" type="text/javascript" charset=&
C语言基础代码（1）
Cecilia3333的博客
03-26 4万+
C语言是计算机及其相关专业学生必修的语言。我在大一下学期就已经学习了。前段时间，我又将谭浩强编写的C程序设计，也就是我C语言学习的课本看了一遍，“温故而知新”，受益良多。于是就萌发了一个想法，想将C语言学习当中一些基础的代码做一个总结归纳，在总结的过程中不断学习和发现不足，也希望能够对正在学习C语言的朋友们一点帮助。1. 打印100到200之间的素数#include&lt;stdio.h&gt; ...
完整HTML实例网页代码（1）
I心暖存人T的博客
04-21 10万+
要完成一个网页的制作其实本质上是很简单的，本实例适合于初学HTML的同学。该实例里面有设置了css的样式设置，有div的 样式格局，同样的也有js的动画效果，这个实例比较全面，有助于同学的学习。 本实例仅供参考，其他行为自负。 本实例分为四篇来观看。一共有一个HTML文件，三个css样式表，三个js，有16张图片。其中img里面的图片可以自行下载，或用本实例里面的图片。测试项目是建议大家用谷歌...
c语言打印出水花数，四叶玫瑰数，五角星数等等的数字
qq_45610772的博客
09-14 4125
求出0～999999之间的所有“水仙花数”并输出。 “水仙花数”是指一个三位数，其各位数字的立方和确好等于该数本身， 如；153＝13＋53＋3^3?，则153是一个“水仙花数”。 1234=1^4 + 2^4 + 3^4 +4^4 在数论中，水仙花数（Narcissistic number）也称为自恋数、自幂数、 阿姆斯壮数或阿姆斯特朗数（Armstrong number），是指一N位数， 其各...
计算机上出现的错误是什么意思,错误代码1是什么意思
weixin_28782221的博客
08-01 1844
你先看看在开机启动项中是否有，如果有将其删除或禁止。启动项哪些可以关闭(以下几种方法都可以找到自启动项)1、下载金山清理专家，在他的启动项中有程序软件的图标，你可以很方便的将不需要开机启动的程序删除。下载网址：2、全能助手启动项管理专家 1。07在他的启动项中有程序软件的图标，你可以很方便的将不需要开机启动的程序删除，如果需要这个程序开机启动时，软件还有备份可以恢复，即方便又安全试试吧。下载网址：...
SQL Server错误代码解析与参考
2. 错误代码1：功能错误，表明执行的某个功能或操作存在问题。 3. 错误代码2和3：与文件查找和打开有关，可能是文件或路径不存在。 4. 错误代码5：拒绝访问，可能是权限问题，用户无权访问特定资源。 6. 错误代码7：...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值