常见的线性表的基本运算：
1. InitList（&L）
  构造一个空的线性表L，即表的初始化。
2. DestroyList(&L)
  销毁线性表。
3. ClearList(＆L)
  将L重置为空表。
4. ListEmpty(L)
  若L为空表，则返回 TRUE，否则返回FALSE。
5. ListLength（L）
  求线性表L中的结点个数，即求表长。
6. GetElem(L，i，&e)
  用e返回L中第i数据个元素的值。这里要求1≤i≤ListLength（L）
7. LocateElem(L，e，compare( ))
  返回L中第1个与e满足关系compare( )的数据元素的位序。 不存在，则返回值为0。
8. ListInsert(&L，i，e)
  在L中第i个位置之前插入新的数据元素e，L的长度加1。
9. ListDelete(&L，i，&e)
c语言listinsert函数  删除L的第i个数据元素，并用e返回其值，L的长度减1。


组合基本运算，实现复杂运算：
1. 假设利用两个线性表LA和LB分别表示两个集合A和B(即：线性表中的数据元素即为集合中的成员)，现要求一个新的集合A=AUB。
    [思想]：这就要求对线性表作如下操作：扩大线性表LA，将存在于线性表LB中而不存在于线性表LA中的数据元素插入到线性表LA中去。只要从线性表LB中依次取得每个数据元素，并依值在线性表LA中进行查访，若不存在，则插入之。

    [算法描述如下]：
    vold union ( List &La，List Lb) { //将所有在线性表Lb中但不在La中的数据元素插入到La中 ;
      La_len=ListLength (La)；
      Lb_len=ListLength (Lb)；//求线性表的长度
      for ( i = 1；i<=Lb_len；i++){
        GetElem (Lb，i，e)； //取Lb中第i个数据元素赋给e
        if(!LocateElem (La ， e ， equal))
            ListInsert (La， ++La_len， e)； //La中不存在和e相同的数据元素，则插入
      }
    } //union
    算法 2.1

2. 已知线性表LA和LB中的数据元素按值非递减有序排列，现要求将LA和LB归并为一个新的线性表LC，且LC中的数据元素仍按值非递减有序排列。
    [思想]：
    从上述问题要求可知，LC中的数据元素或是LA中的数据元素，或是LB中的数据元素，则只要先设LC为空表，然后将LA或LB中的元素逐个插入到LC中即可。为使LC中元素按值非递减有序排列，可设两个指针i和j分别指向LA和LB中某个元素，若设i当前所指的元素为a，j当前所指的元素为b，则当前应插入到LC中的元素min(a , b)；显然，指针i和j的初值均为1，在所指元素插入LC之后，在LA或LB中顺序后移。

    [归并算法如算法2.2所示]：
    Void MergeList (List La，List Lb， List & Lc){
    //已知线性表La和Lb中数据元素按值非递减排列。归并La和Lb得到新的线性表Lc，Lc的数据元素也按值非递减排列
      InitList(Lc)；
      i = j = 1；     k = 0；
      La_len = ListLength(La)； Lb_len = ListLehgth(Lb)；
      while((i<=La_len)&&(j<=Lb_len)) //La和Lb均非空{
        GetElem(La，i，ai)；
        GetElem(Lb，j，bj)；
        if (ai <= bj) {Listlnsert(Lc，++k，ai )；++i；}
        else {Listlnsert(Lc， ++k， bj)； ++j； }
        }
      while(i<=La_len){
        GetElem(La，i++，ai)；
        Listlnsert(Lc，++k，ai )；}
      while(j<=Lb_len){
        GetElem(Lb，j++，bj)；
        Listlnsert(Lc，++k，bj)；}
    } // 算法 2.2


单链表上实现的运算：

1. 归并两个单链表的算法。
    void MergeList_L (LinkList &La， LinkList &Lb，LinkList &Lc){
    //已知单链线性表La和Lb的元素按值非递减排列。归并La和Lb得到新的单链线性表Lc，Lc元素也按值非递减排列。
        pa = La—>next； pb =Lb—>next； Lc = pc = La； //用La的头结点作为Lc的头结点
        while (pa && pb) {
            if (pa—>data < pb—>data){ pc—>next = pa；pc = pa；pa = pa—>next； }
            else { pc—>next = pb；pc = pb；pb = pb—>next}
        }
        pc—>next = pa ? pa : pb //插入剩余段
        free(Lb)； //释放Lb的头结点
    } //MerqeList_L
    算法 2.12


2. 在带头结点的双链循环线性表中第i个位置之前插入元素e。

    Status ListInsert_DuL (DuLinkList &L, int i, ElemType e){
    //在带头结点的双链循环线性表中第i个位置之前插入元素e，i的合法值为１<= i <= 表长 +１。
        if ( ! (p = GetElemP_DuL(L, i))) //在L中确定第i个元素的位置指针p
            return ERROR; // p = NULL，即第i个元素不存在
        if (! (s = (DuLinkList)malloc( sizeof(DuLNode))) return ERROR;
            s ->data = e;    s ->prior = p->prior; p ->prior ->next = s; s ->next = p; p->prior = s;
        return OK;
    } // ListInsert_DuL;
    算法 2.18

6. 删除带头结点的双链循环线性表L的第i个元素。

    Status ListDelete_DuL(DuLinkList &L，int i，ElemType &e){
    //删除带头结点的双链循环线性表L的第i个元素，i的合法值为1≤i≤表长
        if( !(p=GetElemP_DuL(L，i))) //在L中确定第i个元素的位置指针p
            return ERROR； // p=NULL，即第i个元素不存在
        e=p—>data； p—>prior—>next = p—>next; p—>next—>prior = p—>prior;
        free(p)； return 0K
    } //ListDelete_DuL
定点起始远动圆设计程序
要求:设计一个运动的圆.起点由用户输入!
#include "graphics.h"
#include "stdlib.h"
#include "stdio.h"
#include "dos.h"
int main()
{
    int i,gd=DETECT,gr;
    registerbgidriver(EGAVGA_driver);
    initgraph(&gd,&gr,"c:\\turboc2");
    cleardevice();
    for(i=0;i<300;i+=10)
    {
cleardevice();
circle(50+i,50+i,20);
delay(100); /*延迟100毫秒*/
    }
    getch();
    closegraph();
}_
分享给你的朋友吧：
∙ i贴吧
∙ 新浪微博
∙ 腾讯微博
∙ QQ空间
∙ 人人网
∙ 豆瓣
∙ MSN
对我有帮助
1
回答时间：2008-1-22 20:14 | 我来评论
实验目的和要求：
      编写一个简单的算法解决一个具体的问题并在Ｃ环境中上机实现。
对已学的Ｃ语言设计知识作一回顾。
实验内容：
1.      用C语言编程求解百鸡问题。（两种方法）
2.      编程求解100~1000之间的所有素数。
（1）      用基本穷举法
（2）      用筛法
实验二 几种算法比较
用C语言编程求解百鸡问题
1￥#include <stdio.h>
void main ()
{
int cock,hen;
for (cock = 0; cock <= 20; cock++)
  for (hen =0; hen <= 100/3; hen++)
  if (cock * 5 + hen * 3 + (100 - cock - hen) *1 <= 100)
    printf("cock:%d, hen:%d, chick:%d\n", cock, hen, 100 - cock - hen);
}  #include<stdio.h>
voidchicken_question(intchicken_num,int*k,intg[],intm[],intx[])
...{
  inta,b,c,t;
  t=0;
  for(a=0;a<=chicken_num/5;a++)
    for(b=0;b<=chicken_num/3;b++)
    ...{
      c=100-a-b;
      if((a+b+c)==chicken_num&&(5*a+3*b+c/3==chicken_num)&&(c%3==0))
      ...{
        g[t]=a;
        m[t]=b;
        x[t]=c;
        t++;
      }
    }
  *k=t;
}
2￥ main()
...{
  intn;
  intgongji[50],muji[50],xiaoji[50],num=0;
  inti,*p_num=#
  printf("公鸡5元每只，母鸡3元每只，小鸡3只1元");
  printf("n元买n只鸡,请输入n的值：");
  scanf("%d",&n);
  chicken_question(n,p_num,gongji,muji,xiaoji);
  for(i=0;i<num;i++)
  ...{
    printf("%d%d%d
",gongji[i],muji[i],xiaoji[i]);
  }
}
3￥ void main()
{  int x,y,z,j=0;
   printf("Folleing are possible plans to buy 100 fowls with 100 Yuan.\\n");
    for(x=0;x<=20;x++)             
        for(y=0;y<=33;y++)                     z=100-x-y;   
            if(z%3==0&&5*x+3*y+z/3==100)                 printf("%2d:cock=%2d hen=%2d chicken=%2d\\n",++j,x,y,z); }*运行结果
Follwing are possible plans to buy 100 fowls with 100 Yuan.
    1:cock=0 hen=25 chicken=75
    2:cock=4 hen=18 chicken=78
    3:cock=8 hen=11 chicken=81
    4:cock=12 hen=4 chicken=84     
编程求解100~1000之间的所有素数。
#include<iostream.h>
#include<math.h>
bool isPrime(int n)
{
int s,i;
//cout<<"请输入一个大于二的正整数：";
//cin>>n;
s=(int)sqrt(n);
for(i=2;i<=s;i++)
    if(n%i==0)  return false;
    return true;//cout<<"该数是素数！";
                      //else    cout<<"概数不是素数！";     
}
void main()
{
int m;
for(m=100;m<=999;m++)
if(isPrime(m))
    cout<<m<<"\t";
}
2****
实验目的和要求：
      （1）学习工程中常用的几种算法设计方法
（2）通过上机实践来比较这几种算法之间的区别和联系
实验内容：
1.      输出自然数1~n。分别用for循环和递归算法实现。
2.      求n！。分别用for循环和递归算法实现。
3.      用二分法求解方程的根，方程式为f(x)=x3-5x2+16x-80。使用减半递 推方法完成。
实验三 线性表的初始化、插入运算
实验目的和要求：
      （1）学习线性表的顺序存储结构
（2）学会建立线性表
（3）学会线性表顺序存储结构下的插入运算
实验内容：
1.      初始化一个空的线性表，并输入指定元素，然后输出。
实验用例：D=｛13，29，5，7，81，23，92，36，24，10｝
2.      在第一题的基础上自定义一个函数insert，该函数用来实现在指定的元素前插入给定的元素（例如：在81前插入101）。注意上溢的发生。
3.      试写出在顺序存储结构下逆转线性表的算法。（可选）
提示：新建一个线性表，从原表按相反顺序复制。
实验四 线性表的删除运算
实验目的和要求：
      （1）掌握线性表中顺序表的结构
（2）学会线性表顺序存储结构下的删除运算
实验内容：
1.      在实验三的源程序中增加一个函数dellist（），用来实现顺序存储结构下线性表的删除算法（例如：删除指定元素81）。
实验用例：D=｛13，29，5，7，81，23，92，36，24，10｝
2.      用菜单实现在源程序中调用线性表删除算法的功能。
实验五 线性单链表的初始化、插入算法
实验目的和要求：
      （1）学会建立单链表
（2）学会在单链表中实现数据的插入
实验内容：
  用C语言编程，建立一个单链表。
要求完成，初始化函数的编写、输入函数的编写、输出函数的编写、插入指定元素函数的编写。
实验六 线性单链表的删除运算
实验目的和要求：
      （1）掌握线性单链表的结构
（2）学会在单链表中实现数据的删除
实验内容：   
1. 在实验五的基础上，增加一个自定义函数del（），该函数实现在一个单链表中删除指定的元素。
  2.  在主函数中编写菜单，实现插入元素和删除元素的调用。
#include<iostream>   
using namespace std; 
template <class T>
class list;
template <class T>
class node
{
friend list<T>;
private:
T data;
node<T>* next;
public:
node<T>():data(0),next(NULL){};
~node<T>(){}
T getData(){return data;}
node<T>* getNext(){return next;}
};
template <class T>
class list
{
private:
node<T> *head;
public:
list(){head=new node<T>;}
~list();
int insert(T&);
int remove(T&);
node<T>* find(T&);
void print();
void sort();
};
template <class T>
int list<T>::insert(T& x)
{
node<T> *p=new node<T>;
p->data=x;
if(!p) return 0;
p->next=head->next;
head->next=p;
return 1;
}
template<class T>
int list<T>::remove(T& x)
{
node<T>* p=find(x);
if(!p) return 0;
node<T> *q=p->next;

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。