1． 有两张非递增有序的线性表A，B，采用顺序存储结构，两张表合并用c表存，要求C为非递减有序的，然后删除C表中值相同的多余元素。
#include<iostream>
using namespace std;
#define MAXSIZE 100
#define OVERFLOW -1
#define ERROR 0
#define OK 1
typedef int Status;
typedef int ElemType;
//顺序存储
typedef struct
{
ElemType *elem;
int length;
}sqlist;
sqlist la,lb,lc;
sqlist InitList()
{
sqlist L;
L.elem=new ElemType[MAXSIZE];
if(!L.elem) exit(OVERFLOW);
L.length=0;
return L;
}
sqlist ListInsert(sqlist &L,int i,ElemType e)
{
if(L.length==MAXSIZE) exit(OVERFLOW);
L.elem[i]=e;
++L.length;
return L;
}
sqlist Listsort(sqlist &L)
{
int i,j;
for(i=0;i<L.length/2;i++)
{
j=L.elem[i];
L.elem[i]=L.elem[L.length-i-1];
L.elem[L.length-i-1]=j;
}
return L;
}
sqlist ListDelete(sqlist &L)
{int i = 0, j = 0, k = 0;
if(L.length > 0)
{
for(i = 0; i < L.length; ++i) //删除相同元素，
{
for(j=i+1;j<L.length;j++)
{
if(L.elem[i]==L.elem[j])//从第一个开始，和第二个以及之后的比较，
{
for(k=j;k<L.length;k++)
{
L.elem[k]=L.elem[k+1];
}
L.length--; //每删除一个元素长度减一
j--;
}
}
}
}
return L;
}
void printlist(sqlist &L)
{
for(int i=0;i<=L.length-1;i++)
{
cout<<L.elem[i]<<" ";
}
}
sqlist addlist(sqlist *la, sqlist *lb, sqlist *lc)
{
int i = 0, j = 0, k = 0;
while(i < la->length && j < lb->length)
{
if(la->elem[i] <= lb->elem[j])
{
lc->elem[k] = lb->elem[j];
j++;
k++;
}
else
{
lc->elem[k] = la->elem[i];
i++;
k++;
}
}
while(i < la->length)
{
lc->elem[k] = la->elem[i];
k++;
i++;
}
while(j < lb->length)
{
lc->elem[k] = lb->elem[j];
k++;
j++;
}
lc->length = k;
return *lc;
}
int main()
{
int num,num1;
int p,t;
la = InitList();
lb = InitList();
lc = InitList();
cout<<"请输入链表a的长度：";
cin>>num;//输入la的长度
cout<<endl;
for(int i=0;i<=num-1;i++)
{
cin>>p;
ListInsert(la,i,p);
}
cout<<endl;
cout<<"请输入链表b的长度：";
cin>>num1;//输入lb的长度
cout<<endl;
for(int i=0;i<=num1-1;i++)
{cin>>t;
ListInsert(lb,i,t);
}
cout<<"链表a："<<endl;
printlist(la);
cout<<endl;
cout<<"链表b："<<endl;
printlist(lb);
cout<<endl;
addlist(&la, &lb, &lc);
cout<<"合并后的c链表："<<endl;
printlist(lc);
cout<<endl;
ListDelete(lc);
cout<<"删除相同多余元素后的c链表："<<endl;
printlist(lc);
cout<<endl;
Listsort(lc);
cout<<"排完序后的c链表："<<endl;
printlist(lc);
return 0;
}
2． 有两张非递减有序的线性表A，B，采用链式存储结构，两张表合并用c表示，要求C为非递增有序的，然后删除C表中值相同的多余元素。
#include<iostream>
using namespace std;
typedef int ElemType;
//链式存储
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode,*LinkList;
LinkList InitList(LinkList &L)
{
L=new LNode;
L->next=NULL;
return L;
}
LinkList ListInsert(LinkList &L,ElemType e)
{LinkList p;
InitList(p);
p=L;
while(p->next!=NULL)
{
p=p->next;
}
LinkList s;
s=new LNode;
s->data=e;
s->next=p->next;
p->next=s;
return L;
}
void CreateList(LinkList &L,int n)
{
LNode *q = L;
int i;
cout<<"请输入链表的数据"<<endl;
for(i=0;i<n;i++)
{
LinkList p;
p=new LNode;
cin>>p->data;
p->next=q->next;q->next=p;
}
}
LinkList AddList(LinkList &la,LinkList &lb,LinkList &lc,int n)
{
int i;
LinkList pa;
LinkList pb;
LinkList pc;
pa=new LNode;
pb=new LNode;
pa=la;
pb=lb;
pa=pa->next;
pb=pb->next;
for(i=0;i<=n+1;i++)
{
if(pa&&pb){
if(pa->data>pb->data)
{
pc=new LNode;
InitList(pc);
pc->data=pa->data;
pa=pa->next;
pc->next=lc->next;lc->next=pc;
}
else if(pa->data<pb->data)
{
pc=new LNode;
InitList(pc);
pc->data=pb->data;
pb=pb->next;
pc->next=lc->next;lc->next=pc;
}
else if(pa->data=pb->data)
{
pc=new LNode;
InitList(pc);
pc->data=pa->data;
pa=pa->next;
pb=pb->next;
pc->next=lc->next;lc->next=pc;
}
}
else if(pa&&!pb)
{
pc=new LNode;
InitList(pc);
pc->data=pa->data;
pa=pa->next;
pc->next=lc->next;lc->next=pc;
}
else if(pb&&!pa)
{
pc=new LNode;
InitList(pc);
pc->data=pb->data;
pb=pb->next;
pc->next=lc->next;lc->next=pc;
}
}
return lc;
}
void printList(LinkList &L)
{
LNode *q = L->next;
while(q){
cout<<q->data<<" ";
q=q->next;}
cout<<endl;
}
void sortList(LinkList &L)
{
int a[100];
int k=0,w=0;
LNode *q = L->next;
while(q)
{
a[k]=q->data;
q=q->next;
k++;
}
for(w=k-1;w>=0;w--)
{
cout<<a[w]<<" ";
}
}
int main(){
LinkList la,lb,lc;
InitList(la);
InitList(lb);
InitList(lc);
int n,m;
cout<<"请输入链表A的长度"<<endl;
cin>>n;
CreateList(la,n);
cout<<"请输入链表B的长度"<<endl;
cin>>m;
CreateList(lb,m);
int n1=n+m;
AddList(la,lb,lc,n1);
sortList(lc);
}
3. 约瑟夫问题：编号为1，2，..n的n个人按顺时针方向围坐一圈，每人持有一个密码（正整数）。一开始任选一个正整数作为报数上限值m，从第一个人开始按顺时针方向自1开始顺序报数，报到m时停止报数。报m的人出列，将他的密码作为新的m值，从他在顺时针方向上的下一个人开始重新从1报数，如此下去，直至所有人全部出列为止。试设计一个程序求出出列顺序。
提示：本题采用循环链表实现，结点数据域包含num，psw，功能初始化循环链表，插入数据，删除结点（重点）。主函数调用。
#include<iostream>
using namespace std;
typedef struct Node
{
int num;
int password;
struct Node *next;
}CircleNode,*CircleList;
CircleList InitList(CircleList &L)
{
L=new CircleNode;
L->next=L;
return L;
}
CircleList ListInsert(CircleList &L,int n)
{
int i;
int s;
CircleList q=L;
for(i=1;i<=n;i++)
{
CircleList p;
InitList(p);
p->num=i;
cout<<"第"<<i<<"人"<<"输入密码："<<endl;
cin>>s;
p->password=s;
q->next=p;
q=q->next;
}
q->next=L;
return L;
}
void printList(CircleList L,int n)
{
cout<<"约瑟夫环的人数以及对应密码分别是："<<endl;
int i;
CircleList w=L;
for(i=1;i<=n;i++)
{
cout<<"第"<<w->next->num<<"个人，密码"<<w->next->password<<endl;
w=w->next;
}
}
void Knockout(CircleList L,int n,int m)
{
CircleNode *cur=L;
CircleNode *prev=L;
int i;
while(n--)
{
for(i=1;i<=m;)
{
if(cur->next!=L)
{
prev=cur;
cur=cur->next;
}
else
{
prev=L;
cur=L->next;
}
++i;
}
cout<<"出列的人是第"<<cur->num<<"个人，密码是"<<cur->password<<endl;
m=cur->password;
prev->next=cur->next;
free(cur);
//free函数的作用是释放当前指针指向的内存块单元的空间.free完之后指针仍然指向原来的堆地址，即仍然可以继续使用，
// free只是释放了malloc等所申请的内存，并不改变指针的值，指向的下一个节点没变
//也就是说malloc申请的内存单元,经过free(cur)以后
//这片内存单元就空闲了出来给其他地方使用了.
//但是要注意:经过free以后,cur还是指向有实际的地址的,但是这个指针
//所指向的位置是空闲的,所以这个cur指针也没有作用了,被称为"悬空指针".
//类似C++里面的DELETE指令.
}
}int main()
{
int n,m;
CircleList L;
InitList(L);
cout<<"请输入约瑟夫环的人数：";
cin>>n;
cout<<"请输入m值：";
cin>>m;
ListInsert(L,n);
printList(L,n);
Knockout(L,n,m);
return 0;
}
free（）函数的理解：
内核通过一个红黑树来记录了空闲的内存，malloc就是从树中查找一块大小适合的内存并把地址给你，然后把这个节点从树中摘除，避免被别人分配到产生冲突。这个内存现在归你一个人用了。
free函数是把你的这个内存重新放回到红黑树中，让别人可以申请到这个内存。从逻辑上来说，你现在不能在使用这个内存了，因为它已经不属于你。但是系统的实现上目前没有做到，所以你还是能访问这个地址。
另外，系统也不会帮你覆盖内存中的数据，因为做这一个操作浪费时间，没有必要。
打一个简单的比方。你租了一套房子，后来租期到了，房子回到房东手里，或者又转租给别人。但是你拿着原来的钥匙还是能进入那套房子，虽然这个是不合法的。
感谢论坛分享：http://bbs.csdn.net/topics/390121909