C语言实现单链表操作

SLIST_H

 

#ifndef __SLIST_H__

#define __SLIST_H__

#include<cstdio>

#include<malloc.h>

#include<assert.h>

typedef int ElemType;

typedef struct Node { //定义单链表中的结点信息

  ElemType data; //结点的数据域

  struct Node *next; //结点的指针域

}Node,*PNode;

typedef struct List { //定义单链表的链表信息

  PNode first; //first指向单链表中的第一个结点

  PNode last; //last指向单链表中的最后一个结点

  size_t size; //记录单链表中的结点个数

}List;

void InitList(List *list);//初始化单链表

void push_back(List *list, ElemType x);//在单链表的末尾插入元素

void push_front(List *list, ElemType x);//在单链表的头部插入元素

void show_list(List *list);//打印单链表

void pop_back(List *list);//删除单链表的最后一个元素

void pop_front(List *list);//删除单链表的第一个元素

void insert_val(List *list, ElemType val);//将数据元素插入到单链表中（要求此时单链表中的数据元素顺序排列）

Node* find(List *list, ElemType x);//查找单链表中数据值为x的结点

int length(List *list);//求单链表的长度

void delete_val(List *list, ElemType x);//按值删除单链表中的某个数据元素

void sort(List *list);//对单链表进行排序

void reverse(List *list);//逆置单链表

void clear(List *list);//清除单链表

void destroy(List *list);//摧毁单链表

#endif //__SLIST_H__

 

 

 

SLIST.CPP

 

 

#include"slist.h"

void InitList(List *list) {

  list->first = list->last = (Node*)malloc(sizeof(Node)); //头结点

  assert(list->first != NULL);

  list->first->next = NULL;

  list->size = 0;

}

void push_back(List *list, ElemType x) {

  //step 1：创建一个新的结点

  Node *s = (Node*)malloc(sizeof(Node));

  assert(s != NULL);

  s->data = x;

  s->next = NULL;

  //step 2：将新结点插入单链表的表尾

  list->last->next = s;

  list->last = s;

  //step 3：更新单链表的长度

  list->size++;

}

void push_front(List *list, ElemType x) {

  //step 1：创建一个新的结点

  Node *s = (Node*)malloc(sizeof(Node));

  assert(s != NULL);

  s->data = x;

  s->next = NULL;

  //step 2：将新结点插入单链表的表头

  s->next = list->first->next;

  list->first->next = s;

  //step 3：判断插入的结点是否是单链表的第一个结点，若是更新链表的尾指针

  if (list->size == 0)

    list->last = s;

  //step 4：更新单链表的长度

  list->size++;

}

void show_list(List *list) {

  //step 1：指针p指向单链表的第一个结点

  Node *p = list->first->next;

  //step 2：循环打印结点的信息

  while (p != NULL) {

    printf("%d->", p->data);

    p = p->next;

  }

  printf("Nul.\n");

}

void pop_back(List *list) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：定义指针p使其指向目标结点的前一个结点

  Node *p = list->first;//从头结点开始

  while (p->next != list->last)

    p = p->next;

  //step 3：删除目标结点

  free(list->last);

  list->last = p;

  list->last->next = NULL;

  //step 4：更新单链表的长度

  list->size--;

}

void pop_front(List *list) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：定义指针p使其指向目标结点的前一个结点

  Node *p = list->first->next;

  //step 3：删除目标结点

  list->first->next = p->next;

  free(p);

  //step 4：判断删除的结点是否是单链表的最后一个结点，若是则更新单链表的尾指针

  if (list->size == 1)

    list->last = list->first;

  //step 4：更新单链表的长度

  list->size--;

}

void insert_val(List *list, ElemType x) {

  //step 1：创建一个新的结点

  Node *s = (Node*)malloc(sizeof(Node));

  assert(s != NULL);

  s->data = x;

  s->next = NULL;

  //step 2：定义指针p使其指向待插入位置的前一个结点

  Node *p = list->first;//从头结点开始

  while (p->next != NULL && p->next->data < s->data)

    p = p->next;

  //step 3：判断结点的待插入位置是否是表尾，若是则更新单链表的尾指针

  if (p->next == NULL)

    list->last = s;

  //step 4：插入结点

  s->next = p->next;

  p->next = s;

  //step 5：更新单链表长度

  list->size++;

}

Node* find(List *list, ElemType x) {

  //step 1：指针p指向单链表的第一个结点

  Node *p = list->first->next;

  //step 2：按照循环顺序查找链表结点

  while (p != NULL && p->data != x)

    p = p->next;

  return p;

}

int length(List *list) {

  return list->size;

}

void delete_val(List *list, ElemType x) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：确定结点在单链表中的位置，并判断其是否存在于单链表中

  Node *p = find(list, x);

  if (p == NULL) {

    printf("要删除的数据不存在！\n");

    return;

  }

  //step 3：判断结点位置是否是表尾

  if (p == list->last)//是表尾

    pop_back(list);

  else {//不是表尾

    Node *q = p->next;

    p->data = q->data;

    p->next = q->next;

    free(q);

    list->size--;

  }

}

void sort(List *list) {

  //step 1：判断单链表中的结点数是否为0或1

  if (list->size == 0 || list->size == 1) return;

  //step 2：将单链表中第一个结点之后的链表部分截出，方便重新按顺序插入链表之中

  Node *s = list->first->next; // 指针s指向单链表的第一个节点

  Node *p = s->next;//q指向s后面的结点

  list->last = s;//单链表的尾指针指向单链表的第一个结点

  list->last->next = NULL;//截断链表

  //step 3：将截出的链表中的结点根据其数据域大小重新插入到原来链表中

  while (p != NULL) {

    s = p;

    p = p->next;

    Node *q = list->first;

    while (q->next != NULL && q->next->data < s->data)

      q = q->next;

    if (q->next == NULL)//判断q此时指向的是否是单链表的最后一个结点，若是则更新链表的尾指针

      list->last = s;

    //将结点重新插入链表

    s->next = q->next;

    q->next = s;

  }

}

void reverse(List *list) {

  //step 1：判断单链表中的结点数是否为0或1

  if (list->size == 0 || list->size == 1) return;

  //step 2：将单链表中第一个结点之后的链表部分截出，然后将截出的链表中的结点按头插法重新插入到原链表中

  Node *p = list->first->next;

  Node *q = p->next;

  list->last = p;

  list->last->next = NULL;

  while (q != NULL) {

    p = q;

    q = q->next;

    p->next = list->first->next;

    list->first->next = p;

  }

}

void clear(List *list) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：释放单链表中的每一个结点

  Node *p = list->first->next;

  while (p != NULL) {

    list->first->next = p->next;

    free(p);

    p = list->first->next;

  }

  //step 3：头指针和尾指针重新都指向头结点

  list->last = list->first;

  //step 4：更新链表长度

  list->size = 0;

}

void destroy(List *list) {

  //step 1：清空单链表

  clear(list);

  //step 2：释放头结点

  free(list->first);

  //step 3：头指针和尾指针都赋值为空

  list->first = list->last = NULL;

main.cpp

 

#include"slist.h"

void main() {

  List mylist;

  InitList(&mylist);

  ElemType item;

  Node *p = NULL;

  int select = 1;

  while (select) {

    printf("*******************************************\n");

    printf("*[1] push_back    [2] push_front  *\n");

    printf("*[3] show_list    [4] pop_back   *\n");

    printf("*[5] pop_front    [6] insert_val  *\n");

    printf("*[7] find       [8] length    *\n");

    printf("*[9] delete_val    [10] sort     *\n");

    printf("*[11] reverse     [12] clear     *\n");

    printf("*[13*] destroy     [0] quit_system  *\n");

    printf("*******************************************\n");

    printf("请选择：>>");

    scanf("%d", &select);

    if (select == 0) break;

    switch (select) {

    case 1:

      printf("请输入要插入的数据（-1结束）:>");

      while (scanf("%d", &item), item != -1) {

        push_back(&mylist, item);

      }

      break;

    case 2:

      printf("请输入要插入的数据（-1结束）:>");

      while (scanf("%d", &item), item != -1) {

        push_front(&mylist, item);

      }

      break;

    case 3:

      show_list(&mylist);

      break;

    case 4:

      pop_back(&mylist);

      break;

    case 5:

      pop_front(&mylist);

      break;

    case 6:

      printf("请输入要插入的数据:>");

      scanf("%d", &item);

      insert_val(&mylist, item);

      break;

    case 7:

      printf("请输入要查找的数据:>");

      scanf("%d", &item);

      p = find(&mylist, item);

      if (p == NULL)

        printf("要查找的数据在单链表中不存在！\n");

      break;

    case 8:

      printf("单链表的长度为%d\n", length(&mylist));

      break;

    case 9:

      printf("请输入要删除的值:>");

      scanf("%d", &item);

      delete_val(&mylist, item);

      break;

    case 10:

      sort(&mylist);

      break;

    case 11:

      reverse(&mylist);

      break;

    case 12:

      clear(&mylist);

      break;

      //case 13:

      //destroy(&mylist);

      //break;

    default:

      printf("选择错误,请重新选择！\n");

      break;

    }

  }

  destroy(&mylist); //程序结束，摧毁链表

}

 

附：单链表优化版本

 

#ifndef __SLIST_H__

#define __SLIST_H__

#include<cstdio>

#include<malloc.h>

#include<assert.h>

typedef int ElemType;

typedef struct Node { //定义单链表中的结点信息

  ElemType data; //结点的数据域

  struct Node *next; //结点的指针域

}Node,*PNode;

typedef struct List { //定义单链表的链表信息

  PNode first; //first指向单链表中的第一个结点

  PNode last; //last指向单链表中的最后一个结点

  size_t size; //记录单链表中的结点个数

}List;

void InitList(List *list);//初始化单链表

void push_back(List *list, ElemType x);//在单链表的末尾插入元素

void push_front(List *list, ElemType x);//在单链表的头部插入元素

void show_list(List *list);//打印单链表

void pop_back(List *list);//删除单链表的最后一个元素

void pop_front(List *list);//删除单链表的第一个元素

void insert_val(List *list, ElemType val);//将数据元素插入到单链表中（要求此时单链表中的数据元素顺序排列）

Node* find(List *list, ElemType x);//查找单链表中数据值为x的结点

int length(List *list);//求单链表的长度

void delete_val(List *list, ElemType x);//按值删除单链表中的某个数据元素

void sort(List *list);//对单链表进行排序

void reverse(List *list);//逆置单链表

void clear(List *list);//清除单链表

void destroy(List *list);//摧毁单链表

//代码优化

Node* CreateNode(ElemType x); //创建一个单链表结点

Node* begin(List *list); //返回单链表的第一个结点

Node* end(List *list); //返回单链表中最后一个结点的下一个结点

void insert(List *list, Node *pos, ElemType x); //在单链表的特定位置（pos）插入新的结点

#endif //__SLIST_H__

slist.cpp

?

#include"slist.h"

void InitList(List *list) {

  list->first = list->last = (Node*)malloc(sizeof(Node)); //头结点

  assert(list->first != NULL);

  list->first->next = NULL;

  list->size = 0;

}

//push_back的优化

void push_back(List *list, ElemType x) {

  insert(list, end(list), x);

}

//push_front的优化

void push_front(List *list, ElemType x) {

  insert(list, begin(list), x);

}

void show_list(List *list) {

  //step 1：指针p指向单链表的第一个结点

  Node *p = list->first->next;

  //step 2：循环打印结点的信息

  while (p != NULL) {

    printf("%d->", p->data);

    p = p->next;

  }

  printf("Nul.\n");

}

void pop_back(List *list) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：定义指针p使其指向目标结点的前一个结点

  Node *p = list->first;//从头结点开始

  while (p->next != list->last)

    p = p->next;

  //step 3：删除目标结点

  free(list->last);

  list->last = p;

  list->last->next = NULL;

  //step 4：更新单链表的长度

  list->size--;

}

void pop_front(List *list) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：定义指针p使其指向目标结点的前一个结点

  Node *p = list->first->next;

  //step 3：删除目标结点

  list->first->next = p->next;

  free(p);

  //step 4：判断删除的结点是否是单链表的最后一个结点，若是则更新单链表的尾指针

  if (list->size == 1)

    list->last = list->first;

  //step 4：更新单链表的长度

  list->size--;

}

//insert_val的优化

void insert_val(List *list, ElemType x) {

  //step 1：创建一个新的结点

  Node *s = CreateNode(x);

  //step 2：定义指针p使其指向待插入位置的前一个结点

  Node *p = list->first;//从头结点开始

  while (p->next != NULL && p->next->data < s->data)

    p = p->next;

  //step 3：判断结点的待插入位置是否是表尾，若是则更新单链表的尾指针

  if (p->next == NULL)

    list->last = s;

  //step 4：插入结点

  s->next = p->next;

  p->next = s;

  //step 5：更新单链表长度

  list->size++;

}

Node* find(List *list, ElemType x) {

  //step 1：指针p指向单链表的第一个结点

  Node *p = list->first->next;

  //step 2：按照循环顺序查找链表结点

  while (p != NULL && p->data != x)

    p = p->next;

  return p;

}

int length(List *list) {

  return list->size;

}

void delete_val(List *list, ElemType x) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：确定结点在单链表中的位置，并判断其是否存在于单链表中

  Node *p = find(list, x);

  if (p == NULL) {

    printf("要删除的数据不存在！\n");

    return;

  }

  //step 3：判断结点位置是否是表尾

  if (p == list->last)//是表尾

    pop_back(list);

  else {//不是表尾

    Node *q = p->next;

    p->data = q->data;

    p->next = q->next;

    free(q);

    list->size--;

  }

}

void sort(List *list) {

  //step 1：判断单链表中的结点数是否为0或1

  if (list->size == 0 || list->size == 1) return;

  //step 2：将单链表中第一个结点之后的链表部分截出，方便重新按顺序插入链表之中

  Node *s = list->first->next; // 指针s指向单链表的第一个节点

  Node *p = s->next;//q指向s后面的结点

  list->last = s;//单链表的尾指针指向单链表的第一个结点

  list->last->next = NULL;//截断链表

  //step 3：将截出的链表中的结点根据其数据域大小重新插入到原来链表中

  while (p != NULL) {

    s = p;

    p = p->next;

    Node *q = list->first;

    while (q->next != NULL && q->next->data < s->data)

      q = q->next;

    if (q->next == NULL)//判断q此时指向的是否是单链表的最后一个结点，若是则更新链表的尾指针

      list->last = s;

    //将结点重新插入链表

    s->next = q->next;

    q->next = s;

  }

}

void reverse(List *list) {

  //step 1：判断单链表中的结点数是否为0或1

  if (list->size == 0 || list->size == 1) return;

  //step 2：将单链表中第一个结点之后的链表部分截出，然后将截出的链表中的结点按头插法重新插入到原链表中

  Node *p = list->first->next;

  Node *q = p->next;

  list->last = p;

  list->last->next = NULL;

  while (q != NULL) {

    p = q;

    q = q->next;

    p->next = list->first->next;

    list->first->next = p;

  }

}

void clear(List *list) {

  //step 1：判断单链表是否为空

  if (list->size == 0) return;

  //step 2：释放单链表中的每一个结点

  Node *p = list->first->next;

  while (p != NULL) {

    list->first->next = p->next;

    free(p);

    p = list->first->next;

  }

  //step 3：头指针和尾指针重新都指向头结点

  list->last = list->first;

  //step 4：更新链表长度

  list->size = 0;

}

void destroy(List *list) {

  //step 1：清空单链表

  clear(list);

  //step 2：释放头结点

  free(list->first);

  //step 3：头指针和尾指针都赋值为空

  list->first = list->last = NULL;

}

//优化

Node* CreateNode(ElemType x) {

  Node *s = (Node*)malloc(sizeof(Node));

  assert(s != NULL);

  s->data = x;

  s->next = NULL;

  return s;

}

Node* begin(List *list) {

  return list->first->next;

}

Node* end(List *list) {

  return list->last->next;

}

void insert(List *list, Node *pos, ElemType x) {

  //step 1：创建一个新的结点

  Node *s = CreateNode(x);

  //step 2：确定带插入位置

  Node *p = list->first;

  while (p->next != pos)

    p = p->next;

  //step 3：插入结点

  s->next = p->next;

  p->next = s;

  //step 4：判断结点是否插入到链表的表尾，若是则更新单链表的表尾指针

  if (pos == NULL)

    list->last = s;

  //step 5：更新单链表长度

  list->size++;

}

 

main.cpp

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

#include"slist.h"

void main() {

  List mylist;

  InitList(&mylist);

  ElemType item;

  Node *p = NULL;

  int select = 1;

  while (select) {

    printf("*******************************************\n");

    printf("*[1] push_back    [2] push_front  *\n");

    printf("*[3] show_list    [4] pop_back   *\n");

    printf("*[5] pop_front    [6] insert_val  *\n");

    printf("*[7] find       [8] length    *\n");

    printf("*[9] delete_val    [10] sort     *\n");

    printf("*[11] reverse     [12] clear     *\n");

    printf("*[13*] destroy     [0] quit_system  *\n");

    printf("*******************************************\n");

    printf("请选择：>>");

    scanf("%d", &select);

    if (select == 0) break;

    switch (select) {

    case 1:

      printf("请输入要插入的数据（-1结束）:>");

      while (scanf("%d", &item), item != -1) {

        push_back(&mylist, item);

      }

      break;

    case 2:

      printf("请输入要插入的数据（-1结束）:>");

      while (scanf("%d", &item), item != -1) {

        push_front(&mylist, item);

      }

      break;

    case 3:

      show_list(&mylist);

      break;

    case 4:

      pop_back(&mylist);

      break;

    case 5:

      pop_front(&mylist);

      break;

    case 6:

      printf("请输入要插入的数据:>");

      scanf("%d", &item);

      insert_val(&mylist, item);

      break;

    case 7:

      printf("请输入要查找的数据:>");

      scanf("%d", &item);

      p = find(&mylist, item);

      if (p == NULL)

        printf("要查找的数据在单链表中不存在！\n");

      break;

    case 8:

      printf("单链表的长度为%d\n", length(&mylist));

      break;

    case 9:

      printf("请输入要删除的值:>");

      scanf("%d", &item);

      delete_val(&mylist, item);

      break;

    case 10:

      sort(&mylist);

      break;

    case 11:

      reverse(&mylist);

      break;

    case 12:

      clear(&mylist);

      break;

      //case 13:

      //destroy(&mylist);

      //break;

    default:

      printf("选择错误,请重新选择！\n");

      break;

    }

  }

  destroy(&mylist); //程序结束，摧毁链表

}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/383628.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

计算机网络【4】传输层

计算机网络【4】传输层

概述 传输层是只有主机才有的层次 传输层的功能&#xff1a; 传输层提供进程和进程之间的逻辑通信&#xff08;网络层提供主机与主机之间的逻辑通信&#xff09;复用和分用传输层对收到的报文进行差错检测 传输层有两个协议&#xff1a; 面向连接的传输层控制协议TCP&…
阅读更多...
Plotly绘图

Plotly绘图

在做Python数据分析实验的时候发现使用Plotly库绘图比较漂亮&#xff0c;在网上找到了一个比较好的教程&#xff0c;这里记录一下&#xff0c;方便以后查找。 传送门
阅读更多...
计算机网络【0】概述

计算机网络【0】概述

计算机网络概念和功能 概念 是一个将分散的、具有独立功能的计算机系统&#xff0c;通过通信设备与线路连接起来&#xff0c;由功能完善的软件实现资源共享和信息传递的系统。 计算机网络是互连的、自治&#xff08;无主从关系&#xff09;的计算机集合。 功能 数据通信&am…
阅读更多...
计算机网络【1】物理层

计算机网络【1】物理层

物理层解决如何在连接各种计算机的传输媒体上传输数据比特流&#xff0c;而不是指具体的传输媒体。 确定与传输媒体接口有关的特性 机械特性&#xff1a;定义物理连接的特性&#xff0c;如规格、接口形状、引线数目、引脚数目、排列电气特性&#xff1a;规定传输二进制位时的电…
阅读更多...
计算机网路【2】数据链路层

计算机网路【2】数据链路层

结点&#xff1a;主机、路由器 链路&#xff1a;两个节点的物理通道 数据链路&#xff1a;逻辑通道&#xff0c;把实现 控制数据传输协议的硬件和软件加到链路上就构成数据链路 帧&#xff1a;链路层的协议数据单元&#xff0c;封装网络层数据报 数据链路层在物理层提供服务的…
阅读更多...
计算机网络【5】应用层

计算机网络【5】应用层

应用层对应用程序的通信提供服务 应用层协议定义&#xff1a; 应用层的功能&#xff1a; 文件传输、访问和管理电子邮件虚拟终端查询服务和远程作业登录 重要协议&#xff1a;FTP、SMTP、POP3、HTTP、DNS 网络应用模型 客户/服务器模型&#xff08;Client/Server&#x…
阅读更多...
操作系统【八】文件管理

操作系统【八】文件管理

文件&#xff1a;一组有意义的信息/数据集合 文件的属性&#xff1a; 文件名&#xff1a;由创建文件的用户决定文件名&#xff0c;主要是为了方便用户找到文件。同一个目录下不允许有重名文件标识符&#xff1a;一个系统内的个文件标识符唯一&#xff0c;对用户来说毫无可读性…
阅读更多...
数据库原理及应用【六】数据库设计

数据库原理及应用【六】数据库设计

数据依赖 函数依赖FD&#xff1a;一个属性或者一组属性的值可以决定另一个属性的值 多值依赖MVD&#xff1a;一个属性或者一组属性的值可以决定另一个属性的值的集合。FD是MVD的特例 符号表示&#xff1a;Name->->Course&#xff0c;课程多值依赖于姓名 连接依赖&#x…
阅读更多...
数据可视化【一】JavaScript学习

数据可视化【一】JavaScript学习

本博客是我学习Curran Kelleher老师数据可视化课程的笔记&#xff0c;感兴趣的小伙伴可以点击这里学习。 three cores of data visualization: analysisdesignconstruction 推荐书籍《visualization analysis & design》 使用https://vizhub.com/进行编程学习&#xff…
阅读更多...
数据库原理及应用【二】数据模型

数据库原理及应用【二】数据模型

层次模型 tree Record and fieldParent-Child relationship(PCR) 每个记录类型只有一个父节点 无法表达多对多信息 采用虚记录解决多对多 网状数据模型 系&#xff1a;主记录->属记录 主记录和属记录都可以有好多个 关系模型 表&#xff1a;table/relation 拥有更高的…
阅读更多...
数据可视化【二】HTML+CSS+SVG+D3

数据可视化【二】HTML+CSS+SVG+D3

HTML、CSS和SVG学习实现代码&#xff1a;https://vizhub.com/Edward-Elric233/89185eb96bc64a9d81777873a0ccd0b9 index.html <!DOCTYPE html> <html><head><title>Shapes with SVG and CSS</title><link rel"stylesheet" href&qu…
阅读更多...
数据可视化【三】基本概念

数据可视化【三】基本概念

Visualization is suitable when there is a need to augment human capabilities rather than replace people with computational decision-making methods. 当可以信赖的智能化的解决方案存在的时候&#xff0c;可视化是不必要的。 当不知道需要分析的问题是什么的时候&…
阅读更多...
数据可视化【四】Bar Chart

数据可视化【四】Bar Chart

Make a Bar Chart Representing a data table in JavaScriptCreating rectangles for each rowUsing linear and band scalesThe margin conventionAdding axes 以下学习内容参考博客&#xff1a;传送门 select()选择所有指定元素的第一个 selectAll()选择指定元素的全部 上…
阅读更多...
数据库原理及应用【三】DBMS+SQL

数据库原理及应用【三】DBMS+SQL

DBMS Query LanguagesInterface and maintaining tools(GUI)APIsClass Library QL 不是图灵完备的&#xff0c;不是一种编程语言。 QL SQL是一种非过程化的查询语言。 DDL数据定义语言&#xff1a;表&#xff0c;视图QL 查询语言DML 数据操纵语言DCL 数据控制语言 Base t…
阅读更多...
数据可视化【五】 Scatter Plot

数据可视化【五】 Scatter Plot

Scatter Plot vizhub上实现的代码&#xff1a; https://vizhub.com/Edward-Elric233/53807a1b35d94329b3689081cd2ea945 https://vizhub.com/Edward-Elric233/b9647d50899a4a0e8e917f913cd0a53a https://vizhub.com/Edward-Elric233/8c6b50cd81a04f048f490f48e4fe6264 由前…
阅读更多...
数据可视化【六】Line Chart Area Chart

数据可视化【六】Line Chart Area Chart

Line Chart vizhub代码&#xff1a; https://vizhub.com/Edward-Elric233/094396fc7a164c828a4a8c2e13045308 实现效果&#xff1a; 这里先使用d3.line()设置每个点的x坐标和y坐标&#xff0c;然后再用这个东西设置path的d属性&#xff0c;就可以得到曲线。 const lineGen…
阅读更多...
数据可视化【七】 更新模式

数据可视化【七】 更新模式

Enter 以下面这个简单的代码进行分析 const svg d3.select(svg); // svg.style(background-color, red); testconst height svg.attr(height); // equals paresFloat() const width svg.attr(width);const makeFruit type >( {type} ); //这种写法好像能够直接得到一个…
阅读更多...
数据可视化【八】根据数据类型选择可视化方式

数据可视化【八】根据数据类型选择可视化方式

Marks:Rows PointsLinesAreas Channels:Columns PositionColorShape
阅读更多...
数据可视化【九】单向数据流交互

数据可视化【九】单向数据流交互

我们使用一下上上篇博客的代码。 例如我们想要当鼠标点击水果的时候会出现黑色的框&#xff0c;再点击一下黑色的框就会消失。 首先&#xff0c;我们应该给组件添加点击事件&#xff1a; fruitBowl.js gruopAll.on(click, d > onClick(d.id));这个on函数第一个参数是事件…
阅读更多...
数据库原理及应用【四】数据库管理系统

数据库原理及应用【四】数据库管理系统

查询优化 数据库管理系统中非常重要的一部分。 代数优化 按照一定的规则将语句变化成关系代数以后进行优化 操作优化 对代数优化后的查询树使用比较好的方法进行查询。 主要是对连接运算进行优化 嵌套循环归并扫描索引优化哈希连接 恢复机制 备份&#xff08;完整备份差…
阅读更多...
最新文章

Copyright @ 2022~2023