数据表

达内培训时候的亮哥的数据表结构：

#import <Foundation/Foundation.h>

int main(int argc, const char * argv[]) {
    @autoreleasepool {
        //统计一个字符串大写，小写，数字，词的数量
        //a-z 97到122;
        //A-Z 65到90;
        //0-9 48到57;
        //空格 32;
    NSString *tongji = @"asAdf ghDjk l1C234 5CC6789";
        int a = 0,b = 0,c = 0,d = 0;
        for (int i = 0; i < tongji.length; i++)
        {
            unichar aa = [tongji characterAtIndex:i];
            switch (aa)
            {
                case 97 ... 122:
                    a++;
                    break;
                case 65 ... 90:
                    b++;
                    break;
                case 48 ... 57:
                    c++;
                    break;
                case 32:
                    d++;
                    break;
            }
            NSLog(@"%d,%d,%d,%d",a,b,c,d+1);
            }
    }
    return 0;
}

除了char str[100]用scanf输入外的其他都是utf8

269532

//删除链表中等于d的所有元素 
 void remove(const T& d){
int r;
while((r=find(d))!=-1){erase(r);}
   }
};
int main(){
 List list;
 list.insert(1);
 list.insert(2);
 list.insert(3);
 list.insert(4);
 list.travel();
 cout << list.find(1) << endl;
 cout << list.find(4) << endl;
 cout << list.find(2) << endl;
 cout << list.find(100) << endl;
 list.insert(3);
 list.travel();
 list.remove(3);
 list.travel();
 return 0;
}

#include <iostream>
using namespace std;
class List{
 typedef int T;
 struct Node{//内部类,节点类
   T data;
   Node* next;
   Node(const T& d):data(d),next(0){}
   ~Node(){
     //cout<<"~Node("<<data<<')'<<endl; 
   }
 };
 Node* head;//成员变量
 int sz;//链表长度
 Node*& getptr(int index){//返回地址本身
   if(index<0||index>sz)throw "out";
   if(index==0) return head;
   Node* p=head;
   for(int i=0;i<index-1;i++)
     p=p->next;
   return p->next;
 }
 public:
  List():head(),sz(){}
  ~List(){
   clear();
  }
  //长度
  int size(){return sz;}  
  //清空所有元素
  void clear(){
   Node* p=head;
   while(p){
     head=p->next;
     delete p;
     p=head;
    }
    head=NULL;
  }
  //插入一个元素
  void insert(const T& d){
   Node* pn=new Node(d);//把数据变节点
   pn->next=head;
   head=pn;
   sz++;
 }
  //打印链表
  void travel(){
   Node* p=head;
   while(p){
     cout<<p->data<<' ';
     p=p->next;
   }
   cout<<endl;
 }
 //向指定的位置插入数据
 bool insert(int index,const T& d){
   if(index<0||index>sz) return false;
   Node* pn=new Node(d);
   Node*& r=getptr(index);
   pn->next=r;
   r=pn;
   sz++;
   return true;
 }
  //删除指定位置元素
 bool erase(int index){
  if(index<0||index>=sz) return false;
  Node*& r=getptr(index);
  Node* q=r;
  r=q->next;
  delete q;
  sz--;
  return true;
 }
 //修改指定位置的值
 bool set(int index,const T& d){
  if(index<0||index>=sz) return false;
  Node*& r=getptr(index);
  r->data=d;
  return true;
 }
 //返回指定位置的元素 
 T& at(int index){
if(index<0||index>=sz) throw "out";
Node*& r = getptr(index);
return r->data;
 }
 //根据数据查找连表中的位置
 int find(const T& d){
Node* p = head;
for(int i=0; i<sz; i++){
if(p->data==d) return i;
p = p->next;
}
return -1;
 }

int main(void)
{
stu *head = NULL;
int cmd;
while (1)
{
helpList();
printf("请出入命令(0-9)：");
scanf("%d",&cmd);
switch (cmd)
{
case 0:
printf("谢谢测试byebye！\n");
if (head)
destroyList(head);
return 0;
case 1:
head = creatList(head);
break;
case 2:
showList(head);
break;
case 3:
serchList(head);
break;
case 4:
head = insertList(head);
break;
case 5:
head = deleteList(head);
break;
case 6:
head = sortList(head);
break;
case 7:
sortList2(head);
break;
case 8:
head = backList(head);
break;
case 9:
head = destroyList(head);
break;
default:
printf("输入有误，请重新输入（0－9）\n");
break;
}
}
return 0;
}

void helpList(void)
{
printf("欢迎进入链表测试:\n");
printf("1: 创建链表\n");
printf("2: 显示链表\n");
printf("3: 查找链表\n");
printf("4: 插入链表节点\n");
printf("5: 删除链表节点\n");
printf("6: 链表排序1\n");
printf("7: 链表排序2\n");
printf("8: 链表逆序\n");
printf("9: 销毁链表\n");
printf("0: 退出\n");
}

stu *deleteList(stu *head)
{
stu *tmp = head;
stu *prev = NULL;
int id;
if (tmp == NULL)
{
printf("链表不存在，请先创建！\n");
return NULL;
}
printf("请输入要删除的学生学号：");
scanf("%d",&id);
while (tmp)
{
if ((tmp->num == id) && (tmp == head))
{
printf("删除的节点为头节点！\n");
head = tmp->next;
free(tmp);
return head;
}
else if((tmp->num==id) && (tmp->next==NULL))
{
printf("删除的节点为尾节点！\n");
prev->next = NULL;
free(tmp);
return head;
}
else
{
if (tmp->num == id)
{
printf("删除节点为中间节点！\n");
prev->next = tmp->next;
free(tmp);
return head;
}
else
{
prev = tmp;
tmp = tmp->next;
}
}
}
printf("走不到这里来！\n");
return head;
}

stu *backList(stu *head)
{
stu *tmp = head;
stu *newhead = head;
if (tmp == NULL)
{
printf("链表不存在，请创建！\n");
return;
}
head = head->next;
tmp->next = NULL;
while (head)
{
tmp = head;
head = head->next;
tmp->next = newhead;
newhead = tmp;
}
printf("链表逆序完成！\n");
showList(newhead);
return newhead;
}

stu *sortList(stu *head)
{
stu *tmp = head;
stu *newhead = head;
if (tmp == NULL)
{
printf("链表不存在，请创建！\n");
return NULL;
}
head = head->next;
newhead->next = NULL;
while (head)
{
tmp = head;
head = head->next;
tmp->next = NULL;
newhead = insertNode(newhead,tmp);
}
printf("链表排序成功！\n");
showList(newhead);
return newhead;
}

stu *insertList(stu *head)
{
stu *tmp = head;
stu *pnew = NULL;
if (tmp == NULL)
{
printf("链表不存在，请先创建！\n");
return NULL;
}
pnew = myMalloc();
if (pnew == NULL)
{
printf("插入节点创建失败！\n");
return head;
}
head = insertNode(head,pnew);
if (head == NULL)
{
printf("插入节点失败！\n");
}
return head;
}

stu *insertNode(stu *head,stu *node)
{
stu *tmp = head;
stu *prev = NULL;
if (tmp == NULL)
{
printf("链表不存在，请创建！\n");
return NULL;
}
while (tmp)
{
if ((tmp->num > node->num) && (tmp == head))
{
printf("插入节点为头节点！\n");
head = node;
node->next = tmp;
return head;
}
else if((tmp->num<node->num) && (tmp->next==NULL))
{
printf("插入节点为尾节点！\n");
tmp->next = node;
return head;
}
else
{
if (tmp->num > node->num)
{
printf("插入节点为中间节点！\n");
prev->next = node;
node->next = tmp;
return head;
}
else
{
prev = tmp;
tmp = tmp->next;
}
}
}
printf("走不到这里来！\n");
return head;
}

void serchList(stu *head)
{
int id;
stu *tmp = head;
if (tmp == NULL)
{
printf("链表不存在，请先创建！\n");
return ;
}
printf("请输入查找的学生学号：");
scanf("%d",&id);
while (tmp)
{
if (tmp->num == id)
{
printf("学号：%d 姓名：%s\n",
tmp->num,tmp->name);
return;
}
tmp = tmp->next;
}
printf("没有找到学号：%d 的学生信息！\n",id);
return;
}

stu *destroyList(stu *head)
{
stu *tmp = head;
if (tmp == NULL)
{
printf("链表不存在，请创建!\n");
return NULL;
}
while (tmp)
{
head = tmp->next;
printf("%s(%d)节点将被释放！\n",
tmp->name,tmp->num);
free(tmp);
tmp = head;
showList(head);
}
printf("链表释放完成！\n");
return NULL;
}

stu *creatList(stu *head)
{
int n;
stu *pnew = NULL;
if (head != NULL)
{
printf("链表已存在，请先销毁再创建\n");
return head;
}
printf("请输入创建链表节点的个数：");
scanf("%d",&n);
head = myMalloc();
if (head == NULL)
{
printf("创建链表头节点失败！\n");
return NULL;
}
pnew = head;
while (--n)
{
pnew->next = myMalloc();
if (pnew->next == NULL)
{
printf("创建节点失败！\n");
return head;
}
pnew = pnew->next;
}
printf("链表创建完成!\n");
return head;
}

//head xingming(num)->xingming(num)->...->NULL
void showList(stu *head)
{
stu *tmp = head;
if (tmp == NULL)
{
printf("链表不存在，请创建！\n");
return;
}
while (tmp)
{
printf("%s(%d)->",tmp->name,tmp->num);
tmp = tmp->next;
}
printf("NULL\n");
}

#include <stdio.h>
#include <stdlib.h>
typedef struct student {
int num;
char name[12];
struct student *next;
} stu;
stu *myMalloc()
{
stu *pnew = NULL;
pnew = (stu *)malloc(sizeof (stu));
if (pnew == NULL)
{
printf("创建节点失败！\n");
return NULL;
}
printf("请输入学生的学号和姓名：");
scanf("%d %s",&pnew->num,pnew->name);
pnew->next = NULL;
return pnew;
}

965556290

//  main.c
//  seqLisd
//  Created by iMac on 14-8-13.
//  Copyright (c) 2014年 ISAK. All rights reserved.
#include <stdio.h>
typedef int DataType;//为int类型取别名
#define LISTSIZE 100//表容量
struct Seqlist{
    DataType data[LISTSIZE];
    int nLength;//表长
};
int listLength(Seqlist *list){//数据结构中值传递用的都是指针，提高效率，降低内存消耗。
    return list->nLength;
}
DataType *getNode(Seqlist *list,int index){
    if (index <0 ||index > list->nLength-1) {//当index等于0或大于表长时，返回值可能是乱码或随机数，也可能是零
        return 0;
    }else{
        return &list->data[index];//返回当前数值的指针，确保唯一性
    }
}
int locateNede(Seqlist *list,DataType x){
    for (int i = 0; i<list->nLength; i++) {
        if (list->data[i] == x) {
            return i;
        }
    }
    return -1;
}

bool insert(Seqlist *list,int index,DataType x){//插入的表，插入的键值，插入数值
    if (list->nLength == LISTSIZE) {
        return false;//如果表满了，不能进行操作，返回false;
    }
    int insertPosition = index;//插入元素的位置
    if (index < 0) {//规范插入位置
        insertPosition = 0;
    }
    if (index > list->nLength-1) {
        insertPosition = list->nLength;
    }
    for (int l = list->nLength-1; l >=insertPosition; l--) {//每个向下移动元素，腾空间插入数据
        list->data[l+1] = list->data[l];//循环让最后一位的键值+1。
    }
    list->data[insertPosition] = x;//插入元素
    list->nLength++;//多了一个元素，表长+1;
    return true;
}
//尾部插入
bool insert(Seqlist *list,DataType x){//函数重载允许函数名相同，但函数的参数类型或个数不能相同
    return insert(list, list->nLength, x);
}
//删除指定位置数字
bool erase(Seqlist *list,int index){
    if (index <0 || index >= list->nLength) {
        return false;
    }else{
        for (int i = 0; i< list->nLength-1; i++) {
            list->data[i] = list->data[i+1];//进行删除，原理是将指定位置的元素用下一个元素覆盖
        }
    }
    list->nLength--;
    return true;
}
//改正指定位置的元素值
bool set(Seqlist* list,int index,DataType x){
    if (index <0|| index>list->nLength) {
        return false;
    }else{
        list->data[index] = x;//重新复制即可
    }
    return true;
}
//遍历表所有元素
void trave(Seqlist* list){
    for (int i = 1; i<list->nLength+1; i++) {
        printf("第%d个元素是：%d\n",i,list->data[i-1]);
    }
}
int main(int argc, const char * argv[])
{
    Seqlist a;

    printf("%d\n",listLength(&a));
    for (int i = 0; i <100; i++) {
        insert(&a, i);
    }
    printf("%d\n",listLength(&a));
    printf("%d\n",locateNede(&a, 80));
    DataType* p = getNode(&a, 40);//获取指定位置的数据
    printf("%d\n",*p);
    erase(&a, 56);
    printf("%d\n",locateNede(&a, 56));
    printf("%d\n",listLength(&a));
    set(&a, 55, 1250212);
    DataType* f = getNode(&a, 55);
    printf("%d\n",*f);
    trave(&a);
}

#define YEAR_FUNC(year, str) do {\
if ((((year)%4==0) && ((year)%100 != 0)) || ((year)%400==0))\
    strcpy((str), "润年");\
else\
    strcpy((str), "平年");\
} while (0)

#include <stdio.h>
#include <string.h>
int main(int argc, const char * argv[])
{
   char str[80] ={0};
    printf("输入字符串、\n");
    scanf("%[^\n]",str);
    printf("你输入的字符串是%s\n,请输入你要删除的字符\n",str);
       setbuf(stdin, NULL);
    int n=0; //= getchar();
    scanf("%d\n",&n);
    printf("你输入的时%d\n",n);
  
    int i = 0;
    for (i=0; i<(strlen(str)-n); i++) {
        str[n]=str[n+1];
        n++;
    }
   // str[strlen(str)]="";
    printf("删除成功了%s\n",str);
    return 0;
} 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(char argv,const *char argc)
{
    char strIP[20] = "";
    char str[20] = ".";
    char a[4][20] = {0};
    int i = -1;
    printf("请输入IP地址：\n");
    scanf("%s", strIP);
    char * p = strtok(strIP,str);
    while(p)
    {
        a[i++] = p;
        p = strtok(NULL,str);
    }    
      return 0;
}

scanf("%s", strIP);
    char * p = strtok(strIP,str);
    while(p)
    {
        a[i++] = p;
        p = strtok(NULL,str);
    }    

void getNum(char *str, int *arr)
{
    char opert[] = "+-*/";
    char *p = NULL;
    //printf("str = %s\n", str);
    p = strtok(str, opert);
    while (p) {
        *(arr++) = atoi(p);
        //printf("%d ", *(arr-1));
        //printf("%s", p);
        //fflush(stdout);
        p = strtok(NULL, opert);
    }
}
void getOpert(char *str, char *arr)
{
    char num[] = "0123456789";
    char *p = strtok(str, num);
    while (p) {
        *(arr++) = *p;
        //printf("%c ", *(arr-1));
        p = strtok(NULL, num);
    }
}

void showNumAndOpert(int *numArr, char *opertArr)
{
    for (int n = 0; n < strlen(opertArr)+1; n++) {
        printf("%d ", numArr[n]);
    }
    printf("\n");
    fflush(stdout);
    for (int n = 0; n < strlen(opertArr); n++) {
        printf("%c ", opertArr[n]);
    }
    printf("\n");
    fflush(stdout);
}
int mulAndDivCalculate(int *numArr, char *opertArr)
{
    for (int i = 0; i < strlen(opertArr); i++) {
        if (opertArr[i] == '*' || opertArr[i] == '/' || opertArr[i] == '%')
        {
            switch (opertArr[i]) {
                case '*':
                    numArr[i] *= numArr[i+1];
                    removeAElementFromNumArr(numArr, (int)(strlen(opertArr)+1), i+1);
                    removeAElementFromOpertArr(opertArr, i);
                   // showNumAndOpert(numArr, opertArr);
                    return 1;
                case '/':
                    numArr[i] /= numArr[i+1];
                    removeAElementFromNumArr(numArr, (int)(strlen(opertArr)+1), i+1);
                    removeAElementFromOpertArr(opertArr, i);
                   // showNumAndOpert(numArr, opertArr);
                    return 1;
                case '%':
                    numArr[i] %= numArr[i+1];
                    removeAElementFromNumArr(numArr, (int)(strlen(opertArr)+1), i+1);
                    removeAElementFromOpertArr(opertArr, i);
                   // showNumAndOpert(numArr, opertArr);
                    return 1;
                default:
                    break;
            }
        }
    }
    return 0;
}
int addAndSubCalculate(int *numArr, char *opertArr)
{
    for (int i = 0; i < strlen(opertArr); i++) {
        if (opertArr[i] == '+' || opertArr[i] == '-')
        {
            switch (opertArr[i]) {
                case '+':
                    numArr[i] += numArr[i+1];
                    removeAElementFromNumArr(numArr, (int)(strlen(opertArr)+1), i+1);
                    removeAElementFromOpertArr(opertArr, i);
                   // showNumAndOpert(numArr, opertArr);
                    return 1;
                case '-':
                    numArr[i] -= numArr[i+1];
                    removeAElementFromNumArr(numArr, (int)(strlen(opertArr)+1), i+1);
                    removeAElementFromOpertArr(opertArr, i);
                   // showNumAndOpert(numArr, opertArr);
                    return 1;
                default:
                    break;
            }
        }
    }
    return 0;
}

int calculate(int *numArr, char *opertArr)
{
    //showNumAndOpert(numArr, opertArr);
    while (mulAndDivCalculate(numArr, opertArr));
    //showNumAndOpert(numArr, opertArr);
    while (addAndSubCalculate(numArr, opertArr));
    //showNumAndOpert(numArr, opertArr);
    return numArr[0];
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <assert.h>
#define LEN 1000
int isStrOK(char *str);
void getNum(char *str, int *arr);
void getOpert(char *str, char *arr);
int calculate(int *numArr, char *opertArr);
int main(int argc, const char * argv[])
{
    char str[LEN] = "+3*2+6/3-9"; // "-3*2+6/3-9"
    char tmp_str[LEN] = "";
    int numArr[20] = {0};
    char opertArr[10] = "";
    if (isStrOK(str)) {
        printf("str = %s\n", str);
        fflush(stdout);
        strcpy(tmp_str, str);
        memset(opertArr, '\0', 10*sizeof(char));
        getNum(str, numArr);
        strcpy(str, tmp_str);
        getOpert(str, opertArr);
        printf("Res: %d\n", calculate(numArr, opertArr));
    }
    return 0;
}
void removeAElementFromNumArr(int *numArr, int len, int i)
{
    for (int n = i; n < len-1; n++) {
        numArr[n] = numArr[n+1];
    }
    numArr[len-1] = 0;
}
void removeAElementFromOpertArr(char *opertArr, int i)
{
    //printf("Src: %s\n", opertArr);
    for (int n = i; n < strlen(opertArr)-1; n++) {
        opertArr[n] = opertArr[n+1];
    }
    opertArr[strlen(opertArr)-1] = '\0';
    //printf("Res: %s\n", opertArr);
}
int isStrOK(char *str)
{
    int i = 0;
    for (i = 0; i < strlen(str); i++) {
        if ((str[i]>='0'&&str[i]<='9') || (str[i]=='+') || (str[i]=='-') || (str[i]=='*') || (str[i]=='/') || (str[i]=='%')) {
            continue;
        } else {
            break;
        }
    }
    if (i == strlen(str)) {
        if (str[0] == '%') {
            return 0;
        } else if (str[0] == '-') {
            for (int n = (int)strlen(str); n > 0; n--) {
                str[n] = str[n-1];
            }
            str[0] = '0';
        } else if (str[0] == '+') {
            removeAElementFromOpertArr(str, 0);
        }
        return 1;
    }
    return 0;
}