++i、i++、--i、i--详解+【例子】

本文详细介绍了编程中递增(++、++i)和递减(--、i--)操作符的使用,区分了前缀和后缀形式,以及它们在变量赋值时的计算过程。

这些符号是在编程中用于增加或减少变量的值的操作符。
它们通常用于循环或条件语句中,以及其他需要对变量进行递增或递减操作的地方。

  1. ++i:这是一个递增操作符,也称为前缀递增。它的作用是先将变量i的值加1,然后再使用这个新值。换句话说,它会先递增i,然后返回递增后的值。
    计算方式:先将变量i的值加1,然后使用这个新值。因此,++i等价于i = i + 1。
var i = 5;
var result = ++i; // 现在i的值是6,result的值也是6
  1. i++:这是一个递增操作符,也称为后缀递增。它的作用是先使用变量i的当前值,然后再将其加1。换句话说,它会先返回i的当前值,然后再递增i。
    计算方式:先使用变量i当前值,然后将其加1。因此,i++等价于先返回i的当前值,然后再执行i = i + 1。
var i = 5;
var result = i++; // 现在i的值是6,result的值是5
  1. --i:这是一个递减操作符,也称为前缀递减。它的作用是先将变量i的值减1,然后再使用这个新值。换句话说,它会先递减i,然后返回递减后的值。
    计算方式:先将变量i的值减1,然后使用这个新值。因此,--i等价于i = i - 1。
var i = 5;
var result = --i; // 现在i的值是4,result的值也是4
  1. i--:这是一个递减操作符,也称为后缀递减。它的作用是先使用变量i的当前值,然后再将其减1。换句话说,它会先返回i的当前值,然后再递减i。
    计算方式:先使用变量i的当前值,然后将其减1。因此,i--等价于先返回i的当前值,然后再执行i = i - 1。
var i = 5;
var result = i--; // 现在i的值是4,result的值是5
#include <stdio.h> #include <malloc.h> //注意: //将题目要求定义为子函数,子函数中只能写基本语句完成功能。  //main()函数中可以调用dlinklist.cpp和clinklist.cpp中的函数。 //在main()函数中调用子函数进行测试。 //双链表 typedef  int ElemType; typedef struct Dnode {   ElemType data;                          //数据元素          struct Dnode  * prior, * next;     //指针          int freq;      } DlinkList; void D_CreateListF(DlinkList *&L,ElemType a[],int n) //头插法建双链表 {     DlinkList *s;     L=(DlinkList *)malloc(sizeof(DlinkList));      //创建头结点     L->prior=L->next=NULL;     for (int i=0;i<n;i++)     {             s=(DlinkList *)malloc(sizeof(DlinkList));//创建新结点         s->data=a[i];         s->freq=0;         s->next=L->next;            //将结点s插在原开始结点之前,头结点之后         if (L->next!=NULL) L->next->prior=s;         L->next=s;s->prior=L;     } } void D_DestroyList(DlinkList *&L) {     DlinkList *pre=L,*p=pre->next;     while (p!=NULL)     {         free(pre);         pre=p;         p=pre->next;     }     free(pre); } void D_DispList(DlinkList *L) {     DlinkList *p=L->next;     while (p!=NULL)     {         printf("%d(freq:%d)  ",p->data, p->freq);         p=p->next;     }     printf("\n"); } //1、设有一个双链表h,每个结点中除了有prior、data和next几个域以外,还有一个访问频度域freq,在链表被启用之前,其值均初始化为零。 //每当进行 Locatenode(h,x)运算时,令元素值为x的结点中freq域的值1,并调整表中结点的次序,使其按访问频度的递减次序排列,以便使频繁访问的结点总是靠近表头。 //试写一个符合上述要求的 Locatenode运算的算法。链表中元素值无重复。 void Locatenode(DlinkList *&h, int x) {     DlinkList *p = h->next;          while (p != NULL && p->data != x){         p = p->next;     }          if(p == NULL){          return;      }          p->freq++;          if (p->prior != NULL) {         p->prior->next = p->next;     }     if (p->next != NULL) {         p->next->prior = p->prior;     }          DlinkList *q = h->next;     DlinkList *prev = h;     while (q != NULL && q->freq > p->freq){         prev = q;         q = q->next;     }          p->next = q;     p->prior = prev;     prev->next = p;     if(q != NULL) {         q->prior = p;     } } //循环单链表 typedef struct LNode        //定义单链表结点类型 {     ElemType data;     struct LNode *next; } LinkNode; void CreateListF(LinkNode *&L,ElemType a[],int n) //头插法建立循环单链表 {     LinkNode *s;int i;     L=(LinkNode *)malloc(sizeof(LinkNode));      //创建头结点     L->next=NULL;     for (i=0;i<n;i++)     {             s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点         s->data=a[i];         s->next=L->next;            //将结点s插在原开始结点之前,头结点之后         L->next=s;     }     s=L->next;         if (s != NULL){         while (s->next!=NULL)            //查找尾结点,由s指向它             s=s->next;         s->next=L;     } else {         L->next = L;     } } void CreateListR(LinkNode *&L,ElemType a[],int n) //尾插法建立循环单链表 {     LinkNode *s,*r;int i;     L=(LinkNode *)malloc(sizeof(LinkNode));      //创建头结点     L->next=NULL;     r=L;                    //r始终指向终端结点,开始时指向头结点     for (i=0;i<n;i++)     {             s=(LinkNode *)malloc(sizeof(LinkNode));//创建新结点         s->data=a[i];         r->next=s;            //将结点s插入结点r之后         r=s;     }     r->next=L;                //尾结点next域指向头结点 } void DestroyList(LinkNode *&L) {     LinkNode *p=L,*q=p->next;     while (q!=L)     {         free(p);         p=q;         q=p->next;     }     free(p); } void DispList(LinkNode *L) {     LinkNode *p=L->next;     while (p!=L)     {         printf("%d ",p->data);         p=p->next;     }     printf("\n"); } void Sort(LinkNode *&L){     if (L == NULL || L->next == L) return;          LinkNode *tail = L;     while (tail->next != L) {         tail = tail->next;     }     tail->next = NULL;          LinkNode *head = L->next;     L->next = NULL;     LinkNode* sorted = NULL;          while(head != NULL) {         LinkNode*p = head;         head = head->next;                  if (sorted == NULL || p->data < sorted->data) {             p->next = sorted;             sorted = p;         } else {             LinkNode* temp = sorted;             while (temp->next != NULL && temp->next->data < p->data) {                 temp = temp->next;             }             p->next = temp->next;             temp->next = p;         }     }          L->next = sorted;     LinkNode* newtail = sorted;     while (newtail->next != NULL) {         newtail = newtail->next;     }     newtail->next = L; } //2、有序循环单链表rear中,  中位数的元素值。 ElemType mid_elem(LinkNode *rear) {     if (rear == NULL || rear->next == rear) {         printf("链表为空\n");         return -1;     }          int len = 0;     LinkNode *p = rear->next;     while(p != rear) {         len++;         p = p->next;     }     len++;          LinkNode *mid = rear->next;     for(int i = 0; i < len / 2 - 1; i++) {         mid = mid->next;     }          if(len%2 == 0){         return mid->data;     }else{         LinkNode *next_mid = mid->next;         if (next_mid == rear) next_mid = rear->next;         return (mid->data + next_mid->data) / 2;     } } int main() {     LinkNode *rear;     DlinkList *L;     ElemType a[] = {1, 3, 55, 987, 12, 56, 7, 8};     int n = sizeof(a) / sizeof(a[0]);          //初始化双链表&循环单链表     D_CreateListF(L, a, n);     CreateListF(rear, a, n);          //(1)LocateNode     printf("(1)LocateNode(L,12)\n");     printf("原始链表:");     D_DispList(L);     Locatenode(L, 12);     printf("改后链表:");     D_DispList(L);          //(2)循环链表的中位数     printf("(2)循环链表中位数\n");     printf("排序前的循环链表:");     DispList(rear);     Sort(rear);     printf("排序后的循环链表:");     DispList(rear);     printf("中位数:%d ",mid_elem(rear));          D_DestroyList(L);     DestroyList(rear);              return 0; }修改并完善该程序
最新发布
09-29
以下是一个用 C++ 编写的包含双链表和循环单链表操作的程序,实现了双链表的创建、查找定位及结点排序,循环单链表的创建、排序和求中位数等功能。 ```cpp #include <iostream> // 定义双链表结构体 typedef struct DNode { int data; int freq; struct DNode* prior; struct DNode* next; DNode(int val) : data(val), freq(0), prior(nullptr), next(nullptr) {} } DNode; // 定义循环单链表结构体 typedef struct CNode { int data; struct CNode* next; CNode(int val) : data(val), next(nullptr) {} } CNode; // 双链表的创建 DNode* createDLinkList(int arr[], int n) { DNode* head = new DNode(-1); DNode* p = head; for (int i = 0; i < n; ++i) { DNode* newNode = new DNode(arr[i]); p->next = newNode; newNode->prior = p; p = newNode; } return head; } // 双链表的 Locatenode 运算 DNode* Locatenode(DNode* head, int x) { DNode* p = head->next; while (p != nullptr) { if (p->data == x) { p->freq++; // 按访问频度递减排序 DNode* q = p; while (q->prior != head && q->prior->freq < q->freq) { // 交换 q 和 q->prior 的位置 DNode* prev = q->prior; DNode* next = q->next; DNode* prev_prev = prev->prior; prev_prev->next = q; q->prior = prev_prev; q->next = prev; prev->prior = q; prev->next = next; if (next != nullptr) { next->prior = prev; } } return p; } p = p->next; } return nullptr; } // 循环单链表的创建 CNode* createCLinkList(int arr[], int n) { if (n == 0) return nullptr; CNode* head = new CNode(arr[0]); CNode* p = head; for (int i = 1; i < n; ++i) { CNode* newNode = new CNode(arr[i]); p->next = newNode; p = newNode; } p->next = head; return head; } // 循环单链表的排序(简单冒泡排序) void sortCLinkList(CNode* head) { if (head == nullptr) return; CNode* p, * q; int temp; for (p = head; p->next != head; p = p->next) { for (q = p->next; q != head; q = q->next) { if (p->data > q->data) { temp = p->data; p->data = q->data; q->data = temp; } } } } // 循环单链表求中位数 int mid_elem(CNode* head) { if (head == nullptr) return -1; CNode* slow = head; CNode* fast = head; CNode* prev = nullptr; while (fast->next != head && fast->next->next != head) { prev = slow; slow = slow->next; fast = fast->next->next; } if (fast->next == head) { return slow->data; } else { return (slow->data + slow->next->data) / 2; } } int main() { // 双链表测试 int dArr[] = {1, 2, 3, 4, 5}; DNode* dHead = createDLinkList(dArr, 5); DNode* found = Locatenode(dHead, 3); if (found) { std::cout << "双链表中找到值为 3 的结点,当前访问频度: " << found->freq << std::endl; } // 循环单链表测试 int cArr[] = {5, 3, 1, 4, 2}; CNode* cHead = createCLinkList(cArr, 5); sortCLinkList(cHead); int median = mid_elem(cHead); std::cout << "循环单链表排序后的中位数: " << median << std::endl; return 0; } ``` ### 代码解释 - **双链表部分**: - `createDLinkList` 函数用于创建双链表,通过遍历数组依次插入新节点。 - `Locatenode` 函数用于查找值为 `x` 的节点,找到后将其 `freq` 1 并按频度排序。 - **循环单链表部分**: - `createCLinkList` 函数用于创建循环单链表,最后将尾节点指向头节点。 - `sortCLinkList` 函数使用简单的冒泡排序对循环单链表进行排序。 - `mid_elem` 函数使用快慢指针法求循环单链表的中位数。 ### 代码调用示例 在 `main` 函数中,分别创建了双链表和循环单链表,并调用相应的函数进行测试。 ### 相关问题
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值