代码改变世界

总结大学一些常见数据结构简单实现(c&c++语言)

2011-07-31 19:28 by 类菌体, ... 阅读, ... 评论, 收藏, 编辑

小引:                                                                                                                                       

      笔者是一个大三本科生,目前在备考研复习,在进行计算机统考复习数据结构当中,所以有时间在看到很久以前学习的数据结构和算法实现的上机操作以及自己平时编写的数据结构代码,一同把它分享到这里来,因为是初学到复习考研这个过程,不免会有错误和不足,所以希望得到园友批评和建议,实现环境是vc6.0,语言是c或者c++,希望得到初学者喜欢,大牛可以飞过 !!!!

 

 

理解算法和程序的关系,掌握顺序表的基本操作                                                                                  

内容:(1) 在一个递增有序的顺序表中插入一个元素,使插入之后仍有序 
(2) 将顺序表L逆置

#include "stdlib.h"
#include
<iostream.h>




typedef
int ElemType;

/* 顺序表定义,书20 */
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
typedef
struct {
ElemType
*elem;
int length;
int listsize;
} SqList;

/* 生成具有n个元素的顺序表 L,类似书P21,算法2_1 */
void Creat_Sq(SqList &L,int n){
L.elem
=new ElemType[LIST_INIT_SIZE];
for(int i=1;i<=n;i++) L.elem[i-1]=2*i;//直接生成
L.length=n;
L.listsize
=LIST_INIT_SIZE;
}

void Increament(SqList &L)
{
//当前存储空间已满,增加分配空间
ElemType *a=new ElemType[L.listsize+ LISTINCREMENT];
for (int i=0;i<L.length;i++) a[i]=L.elem[i];
delete []L.elem;
L.elem
=a;
L.listsize
=L.listsize+ LISTINCREMENT;
}


void ListInsert_Sq(SqList &L, int i,ElemType e) {
//将e插入到顺序表L中第i个元素之前
if(i<1||i>L.length+1) {cout<<"ERROR";exit(-1);}

if (L.length>L.listsize) Increament(L);


ElemType
* q=&(L.elem[i-1]);
for (ElemType* p=&(L.elem[L.length-1]); p>=q;--p) *(p+1)=*p;
*q=e;

++L.length;

}



/* 主函数 */
void main()
{ SqList L;
int i,e,m;
cout
<<"请输入元素个数:"<<endl;
cin
>>m;

/* 生成具有n个元素的顺序表L*/
Creat_Sq( L, m);

/* 显示该顺序表 */
cout
<<"\n该顺序表为: \n"<<endl;
for (i=1;i<=L.length;i++) cout<<""<<L.elem[i-1];

cout
<<endl<<"请输入插入位置及元素:"<<endl;
cin
>>i>>e;

/* 在L中插入元素e , 注意函数调用的格式*/
ListInsert_Sq (L,i,e);

for (i=1;i<=L.length;i++)
cout
<<""<<L.elem[i-1];
cout
<<endl;
/*逆序排*/
cout
<<" 逆序输出"<<endl;
for(i=L.length;i>=1;i--)
cout
<<""<<L.elem[i-1];

}



进一步掌握顺序表的操作                                                                                                             

 内容:(1) 将两个递增有序的顺序表合并为一个递增有序的顺序表,并显示

          (2) 将顺序表L逆置

以下代码为:把两个递增有序的单链表归并为一个递增有序的链表,辅助空间为O(1
#include
<iostream>
usingnamespace std;
typedef
int ElemType;
typedef
struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode
*LinkList;
void CreatList(LinkList &L,int n)
{
LinkList p,q;
L
=new LNode;
L
->next=NULL;
q
=L;
cout
<<"请从小到大输入链表的元素:";
for(int i=1;i<=n;i++)
{
p
=new LNode;
cin
>>p->data;
p
->next=q->next;
q
->next=p;
q
=q->next;
}
cout
<<"所创建得的递增有序链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void CreatC(LinkList &A,LinkList &B,LinkList &C,int n)
{
LinkList p,q,t;
p
=A->next;
q
=B->next;
C
=t=A;
while(p&&q)
{
if(p->data<=q->data)
{
t
->next=p;
t
=p;
p
=p->next;
}
else
{
t
->next=q;
t
=q;
q
=q->next;
}
}
t
->next=p?p:q;
delete B;
cout
<<"合并后的递增有序链表为:";
p
=C->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void main()
{
LinkList A,B,C;
int n,m,k;
cout
<<"请输入链表***A***的长度:";
cin
>>n;
CreatList(A,n);
cout
<<"请输入链表***B***的长度:";
cin
>>m;
CreatList(B,m);
k
=m+n;
CreatC(A,B,C,k);
}

掌握链表的基本操作                                                                                                                   

内容:(1) 建立一个单链表,并写一个函数来显示链表中的元素
       (2)在一个单链表中查找元素X,找到,显示其序号,否则显示”未找到”

#include<iostream>
usingnamespace std;
typedef
int ElemType;

typedef
struct LNode
{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode
*LinkList;

void InitList_L(LinkList &L)
{
L
=new LNode;
L
->next=NULL;
}

void CreateList_L(LinkList &L,int n)
{
InitList_L(L);
for(int i=n;i>0;--i)
{
LNode
*p=new LNode;
cin
>>p->data;
p
->next=L->next;
L
->next=p;
}
}

void print(LinkList L)
{
LNode
*p=new LNode;
p
=L->next;
while(p)
{
cout
<<p->data<<"";
p
=p->next;
}

}

void Find(LinkList L,ElemType a)
{
int i=1,j=0;
LNode
*p=new LNode;
p
=L->next;
while(p)
{
if(p->data==a)
{
cout
<<"您要查找的数据 "<<a<<" 在单链表中为 "<<i<<" 号元素!\n";
j
++;
}
i
++;
p
=p->next;
}
if(j==0)
cout
<<"您要查找的数据不在单链表中!\n";
}

void main()
{
int n;
ElemType a;
LinkList L;
cout
<<"请输入您要输入的单链表的数据个数n:\n";
cin
>>n;
cout
<<"请输入(逆序输入)您要输入的数据:\n";
CreateList_L(L,n);
cout
<<"依次输出链表中的数据为:\n";
print(L);
cout
<<"\n";
cout
<<"请输入您要查找的数据a:\n";
cin
>>a;
Find(L,a);
}

 通过实验理解栈和队列的应用                                                                                                   

    内容:(1)   用栈实现数制转换

          (2)   输入一个算术表达式,其中含有( 、[ 两种括号,判断括号是否匹配

#include<iostream>
usingnamespace std;

#define SElemType int
#define Stack_Init_Size 20
#define Stack_Increment 10

typedef
struct{
SElemType
*elem;
int top;
int stacksize;
int incrementsize;
}SqStack;

void InitStack(SqStack &s){ //初始化栈
s.elem=new SElemType[Stack_Init_Size];
s.top
=-1;
s.stacksize
=Stack_Init_Size;
s.incrementsize
=Stack_Increment;
}

void StackIncrement(SqStack &s){ //增加栈长度
SElemType *a;
a
=new SElemType[s.stacksize+s.incrementsize];
for(int i=0;i<=s.top;i++)
a[i]
=s.elem[i];
delete []s.elem;
s.elem
=a;
s.stacksize
=s.stacksize+s.incrementsize;
}

void Push_stack(SqStack &s,SElemType x){ //入栈
if(s.top==(s.incrementsize-1))
StackIncrement(s);
s.elem[
++s.top]=x;
}

void Get_num(int&a){ //输入十进制数
cout<<"请输入十进制数"<<endl;
cin
>>a;
}

void change(SqStack &s,int x){ //十进制转化为二进制,并用栈储存
while (x!=1){
Push_stack(s,x
%2);
x
=x/2;
}
Push_stack(s,x);
}

void Output(SqStack &s){ //十进制数以二进制形式输出
cout<<"转为二进制:"<<endl;
for(int a=s.top;a>=0;a--)
cout
<<s.elem[a];
cout
<<endl;
}

void main (){
SqStack ss;
InitStack(ss);
int s;
Get_num(s);
change(ss,s);
Output(ss);
}
#include
<iostream>
usingnamespace std;

#define SElemType char
#define Stack_Init_Size 20
#define Stack_Increment 10

typedef
struct{
SElemType
*elem;
int top;
int stacksize;
int incrementsize;
}SqStack;

void InitStack(SqStack &s){ //用于初始化栈
s.elem=new SElemType[Stack_Init_Size];
s.top
=-1;
s.stacksize
=Stack_Init_Size;
s.incrementsize
=Stack_Increment;
}

void StackIncrement(SqStack &s){ //用于增加栈长
SElemType *a;
a
=new SElemType[s.stacksize+s.incrementsize];
for(int i=0;i<=s.top;i++)
a[i]
=s.elem[i];
delete []s.elem;
s.elem
=a;
s.stacksize
=s.stacksize+s.incrementsize;
}

void Push_stack(SqStack &s,SElemType x){ //入栈
if(s.top==(s.incrementsize-1))
StackIncrement(s);
s.elem[
++s.top]=x;
}

void Pop_Stack(SqStack &s){ //出栈
s.top--;
}

void Get_C(char x[]){ //获取表达式,用数组存放
cout<<"请输入表达式(以等号结束):"<<endl;
for(int i =0;;i++){
cin
>>x[i];
if(x[i]=='=')
break;
}
}

void match(SqStack &s,char x[]){ //进行括号的匹配判断
int n=1; //辅助量,用于判断括号的顺序性是否为真
for(int i=0;;i++){
if(x[i]=='(')
Push_stack(s,
'a');
if(x[i]=='[')
Push_stack(s,
'b');
if(x[i]==')'){
if(s.elem[s.top]=='a')
Pop_Stack(s);
else
{n
=0;break;}
}
if(x[i]==']'){
if(s.elem[s.top]=='b')
Pop_Stack(s);
else
{n
=0;break;}
}
if(x[i]=='=')
break;
}
if((n==1)&&(s.top==-1)) //若判断括号的顺序性为真,在判断是否一一匹配
cout<<"括号相匹配"<<endl;
else
cerr
<<"括号不匹配"<<endl;
}

void main (){
SqStack ss;
char x[10];
InitStack(ss);
Get_C(x);
match(ss,x);
}

  通过实验理解栈和队列的应用 (没有完成)                                                                                    

    内容:(1)   输入一字符串,利用栈和队列判断是否是回文
    (2)编写递归函数,求正整数N的阶乘N!;    再编写函数,用栈实现求N的阶乘,体会栈与递归的关系

#include<iostream>
usingnamespace std;

#define SElemType char
#define Stack_Init_Size 20
#define Stack_Increment 10

typedef
struct{
SElemType
*elem;
int top;
int stacksize;
int incrementsize;
}SqStack;

void InitStack(SqStack &s){ //用于初始化栈
s.elem=new SElemType[Stack_Init_Size];
s.top
=-1;
s.stacksize
=Stack_Init_Size;
s.incrementsize
=Stack_Increment;
}

void StackIncrement(SqStack &s){ //用于增加栈长
SElemType *a;
a
=new SElemType[s.stacksize+s.incrementsize];
for(int i=0;i<=s.top;i++)
a[i]
=s.elem[i];
delete []s.elem;
s.elem
=a;
s.stacksize
=s.stacksize+s.incrementsize;
}

void Push_stack(SqStack &s,SElemType x){ //入栈
if(s.top==(s.incrementsize-1))
StackIncrement(s);
s.elem[
++s.top]=x;
}

void Pop_Stack(SqStack &s){ //出栈
s.top--;
}

void Get_C(char x[],int&y){ //获取表达式,用数组存放
cout<<"请输入表达式(以#结束):"<<endl;
for(int i =0;;i++){
{cin
>>x[i];y++;}
if(x[i]=='#')
break;
}
}

void Judgment(SqStack &s,char x[],int y){
int i;
for(i=0;i<(y-2)/2.0;i++)
Push_stack(s,x[i]);
if((y-1)%2==0) ;
else
i
=i+1;
for(;i<y;i++)
{
if(x[i]==s.elem[s.top]) Pop_Stack(s);}
if(s.top==-1)
cout
<<"回文!"<<endl;
else
cout
<<"非回文!"<<endl;
}


void main (){
SqStack ss;
char x[20];
int y=0;
InitStack(ss);
Get_C(x,y);
Judgment(ss,x,y);
}

  通过实验理解二叉树的存储和操作                                                                                           

内容:  (1)建立二叉树的二叉链表存储,并对它进行中序遍历
         (2)求二叉树的结点数
         (3)求高度

#include"iostream.h"
typedef
char TElemType;
typedef
struct BiTNode
{
TElemType data;
struct BiTNode *lchild;
struct BiTNode *rchild;
}BiTNode;
typedef BiTNode
*BiTree;
void CreateBiTree_Rec(BiTree &T)
{
TElemType ch;
cin
>>ch;
if(ch=='#')
T
=NULL;
else
{
T
=new BiTNode;
T
->data=ch;
CreateBiTree_Rec(T
->lchild);
CreateBiTree_Rec(T
->rchild);
}
}
void InOrder_Rec(BiTree T)
{
if(T)
{

InOrder_Rec(T
->lchild); cout<<T->data;
InOrder_Rec(T
->rchild);
}
}
int Leafs_Rec(BiTree T)
{
int l_Leafs,r_Leafs;
staticint i=0;
if(T==NULL)
return0;
else
{
i
++;
l_Leafs
=Leafs_Rec(T->lchild);
r_Leafs
=Leafs_Rec(T->rchild);
}
return i;
}
int Leafs_Rec1(BiTree T)
{
int l_Leafs,r_Leafs;
if(T==NULL)
return0;
else
{
if((T->lchild==NULL)&&(T->rchild==NULL))
return1;
else
{
l_Leafs
=Leafs_Rec1(T->lchild);
r_Leafs
=Leafs_Rec1(T->rchild);
return (l_Leafs+r_Leafs);
}

}
}
int BiTreeDepth_Rec(BiTree T)
{
int depth_l,depth_r;
if(!T)
return0;
else
{
depth_l
=BiTreeDepth_Rec(T->lchild);
depth_r
=BiTreeDepth_Rec(T->rchild);
if(depth_l>=depth_r)
return (depth_l+1);
else
return (depth_r+1);
}
}
void main()
{
BiTree T;
cout
<<"请按要求(前序序列建立)输入您所要输入的字符串:\n";
CreateBiTree_Rec(T);
cout
<<"中序递归遍历输出为:\n";
InOrder_Rec(T);
cout
<<endl;
cout
<<"该二叉树的结点数目为:"<<Leafs_Rec(T)<<endl;
cout
<<"该二叉树的叶子结点数目为:"<<Leafs_Rec1(T)<<endl;
cout
<<"该二叉树的深度为:"<<BiTreeDepth_Rec(T)<<endl;
}

通过实验理解图的存储和搜索算法                                                                                                  

内容:1。建立一个无向图的邻接表存储

2。对该图进行深度优先搜索,按顺序输出所访问的

#include<iostream.h>
#define MAX_VERTEX_NUM 20
typedef
char VertexType;
typedef
enum{FALSE,TRUE}Boolean;
Boolean visited[MAX_VERTEX_NUM];
typedef
struct EdgeNode //表结点
{
int adjvex;
struct EdgeNode *nextedge;
}EdgeNode;
typedef
struct VerNode //头结点
{
VertexType vex;
EdgeNode
*firstedge;
}VerNode,AdjList[MAX_VERTEX_NUM];
typedef
struct
{
AdjList vertices;
int vexnum,edgenum;
}ALGraph;
int LocateVex_ALG(ALGraph G,VertexType x) //确定x在G中的位置
{
int k=-1;
for(k=0;(k<G.vexnum)&&(G.vertices[k].vex!=x);++k);
return k;
}
void CreateNDG_ALG(ALGraph &G) //构造图的邻接表
{
int i,j,k;
VertexType v1,v2;
cout
<<"请输入图的顶点数和边数:\n";
cin
>>G.vexnum>>G.edgenum;
cout
<<"请输入顶点的内容:\n";
for(i=0;i<G.vexnum;++i)
{
cin
>>G.vertices[i].vex;
G.vertices[i].firstedge
=NULL;
}
cout
<<"请依次输入每条边的初始和终点的顶点内容:\n";
for(k=0;k<G.edgenum;++k)
{
cin
>>v1>>v2;
i
=LocateVex_ALG(G,v1);
j
=LocateVex_ALG(G,v2);
EdgeNode
*p=new EdgeNode;
p
->adjvex=j;
p
->nextedge=G.vertices[i].firstedge;
G.vertices[i].firstedge
=p;
}
}
void DFS(ALGraph G,int v)
{
int w;
EdgeNode
*p;
visited[v]
=TRUE;
cout
<<G.vertices[v].vex<<""; //输出顶点数据
for(p=G.vertices[v].firstedge;p;p=p->nextedge)
{
w
=p->adjvex;
if(!visited[w])
DFS(G,w);
}
}
void DFSTraverse(ALGraph G)
{
int v;
for(v=0;v<G.vexnum;++v)
visited[v]
=FALSE;
cout
<<"按深度优先遍历顺序依次输出顶点为:\n";
for(v=0;v<G.vexnum;++v)
if(!visited[v])
DFS(G,v);
cout
<<endl;
}
void main()
{
ALGraph G;
CreateNDG_ALG(G);
//由邻接表构造无向图
DFSTraverse(G); //按深度优先遍历顺序遍历该无向图
}

 

通过实验理解图的存储和搜索算法                                                                                                  

内容:1。构造图的邻接矩阵

    2。对该图广度优先遍历

#include<iostream.h>
#define MAX_VERTEX_NUM 20
#define QUEUE_INIT_SIZE 100
typedef
enum{DG,DN,UDG,UDN}GraphKind;
typedef
char VertexType;
typedef
int EdgeType;
typedef
enum{FALSE,TRUE}Boolean;
Boolean visited[MAX_VERTEX_NUM];
typedef
char QElemType;
typedef
struct
{
QElemType
*elem;
char front;
char rear;
char queuesize;
}SqQueue;
typedef
struct
{
VertexType vexs[MAX_VERTEX_NUM];
EdgeType edges[MAX_VERTEX_NUM][MAX_VERTEX_NUM];
int vexnum,edgenum;
}MGraph;
void InitQueue_Sq(SqQueue &Q) //队列
{
Q.elem
=new QElemType[QUEUE_INIT_SIZE];
Q.front
=Q.rear=0;
Q.queuesize
=QUEUE_INIT_SIZE;
}
void EnQueue_Sq(SqQueue &Q,QElemType e)
{
if(((Q.rear+1)%Q.queuesize)==Q.front)
Q.elem[Q.rear]
=e;
Q.rear
=(Q.rear+1)%Q.queuesize;
}
QElemType DeQueue_Sq(SqQueue
&Q)
{
QElemType e;
e
=Q.elem[Q.front];
Q.front
=(Q.front+1)%Q.queuesize;
return e;
}
int LocateVex_MG(MGraph G,VertexType x) //构造图的邻接矩阵
{
int k=-1;
for(k=0;(k<G.vexnum)&&(G.vexs[k]!=x);++k);
return k;
}
void CreatUDG_MG(MGraph &G)
{
int i=0,j=0,k=0;
VertexType v1,v2;
cout
<<"请输入图(无向图)的顶点数和边数:\n";
cin
>>G.vexnum>>G.edgenum;
cout
<<"请输入顶点的内容:\n";
for(i=0;i<G.vexnum;++i)
cin
>>G.vexs[i];
for(i=0;i<G.vexnum;++i)
for(j=0;j<G.vexnum;++j)
G.edges[i][j]
=0;
cout
<<"请依次输入每条边的初始和终点:\n";
for(k=0;k<G.edgenum;++k)
{
cin
>>v1>>v2;
i
=LocateVex_MG(G,v1);
j
=LocateVex_MG(G,v2);
while((i<0)||(i>(G.vexnum-1))||(j<0)||(j>(G.vexnum-1)))
{
cout
<<"编码超出范围,请重新输入:\n";
cin
>>v1>>v2;
i
=LocateVex_MG(G,v1);
j
=LocateVex_MG(G,v2);
}
G.edges[j][i]
=G.edges[i][j];
}
}
void BFSTraverse(MGraph G) //广度优先遍历
{
SqQueue Q;
int v;
for(v=0;v<G.vexnum;++v)
visited[v]
=FALSE;
InitQueue_Sq(Q);
cout
<<"按广度优先遍历顺序顶点依次输出为:\n";
for(v=0;v<G.vexnum;++v)
if(!visited[v])
{
visited[v]
=TRUE;
cout
<<G.vexs[v]<<"";
EnQueue_Sq(Q,v);
while(Q.front!=Q.rear)
{
DeQueue_Sq(Q);
for(int w=0;w<G.vexnum;w++)
if(G.edges[v][w]&&(!visited[w]))
{
visited[w]
=TRUE;
cout
<<G.vexs[w]<<"";
EnQueue_Sq(Q,w);
}
}
}
cout
<<endl;
}
void main()
{
MGraph G;
CreatUDG_MG(G);
BFSTraverse(G);
}

  

掌握基本的排序方法                                                                                                                     

上机内容:给定一组整数,分别 用直接插入排序、冒泡排序方法进行排序 ,输出排序后的结果

#include<iostream.h>
#define MAXSIZE 20 //假设文件长度 ,即待排序记录数目
typedef
int KeyType; // 假设的关键字类型
typedef int InfoType;
typedef
struct { //记录定义

KeyType key;
//关键字型
InfoType otherinfo; //其他数据项,InfoType依赖于具体应用
}RedType; //记录类型
typedef struct { //顺序表定义

RedType r[MAXSIZE
+1]; //r[0]闲置或用来做小兵
int length; //顺序表长度

}SqList;
//顺序表类型

void input(SqList &l)
{
cout
<<"请输入各元素"<<endl;
for(int i=1;i<=l.length;i++)
{
cin
>>l.r[i].key;
}
}
void Insertsort(SqList &L){ //对顺序表进行直接插入排序


int i,j;
for(i=2;i<=L.length;i++) //外循环
if(L.r[i].key<L.r[i-1].key) { //将L.r[i]插入有序子表

L.r[
0]=L.r[i];
for(j=i-1;L.r[0].key<L.r[j].key;j--) //内循环
L.r[j+1]=L.r[j]; //记录后移
L.r[j+1]=L.r[0];

}
//end if

}
//Insertsort
void Bubblesord(SqList &L)
{
int i,j;
bool tag=0;
for( i=1;(tag==0)&&(i<=L.length);++i)
{
tag
=1;
for(j=L.length-1;j>=i;--j)
if(L.r[j+1].key<L.r[j].key)
{
L.r[
0]=L.r[j+1];L.r[j+1]=L.r[j];L.r[j]=L.r[0];tag=0;
}
//end if
}//end for
}//Bubblesord
int main()
{
SqList L;
int i,m;
cout
<<"请输入元素个数:"<<endl;
cin
>>m;
L.length
=m;
input(L);
/* 显示该顺序表 */
cout
<<"\n该顺序表为"<<endl;
for(i=1;i<=L.length;i++)
cout
<<L.r[i].key<<"";
cout
<<endl;
/* 进行直接插入排序 */
Insertsort(L);
cout
<<"直接插入法排序"<<endl;
for(i=1;i<=L.length;i++)
cout
<<L.r[i].key<<"";
cout
<<endl;
/* 进行冒泡排序 */
Bubblesord(L);
cout
<<"进行冒泡排序"<<endl;
for(i=1;i<=L.length;i++)
cout
<<L.r[i].key<<"";
cout
<<endl;
return0;
}


   理解静态查找操作方法                                                                                                        

 内容:(1) 建立一个静态查找表 (可只输入数据的关键字项) 。
         (2) 分别用顺序查找和用折半查找方法查找给定关键字。

       (3)分别统计在两种查找方法中的比较次数。

#include<iostream.h>
typedef
int KeyType;
typedef
int InfoType;


typedef
struct{
KeyType
*k;
int length;
}SSTable;

void Initlist_SSTable(SSTable &ST){
ST.length
=6;
ST.k
=new KeyType[ST.length+1];
cout
<<"请输入6个关键字:"<<endl;
for(int i=1;i<=ST.length;i++)
cin
>>ST.k[i];
}

int Search_Seq(SSTable ST,KeyType k, int&n){
ST.k[
0]=k;
for(int i=ST.length;ST.k[i]!=k;--i)
++n;
return i;
}


int Search_Bin(SSTable ST,KeyType k,int&n){
int low=0;
int high=ST.length;
while(low<=high){
int mid=(low+high)/2;
if(k==ST.k[mid])
return mid;
elseif(k<ST.k[mid])
high
=mid-1;
else low=mid+1;

}
return0;
}
void main(){
SSTable ST;
Initlist_SSTable(ST);
KeyType k;

int n=0;
cout
<<"请输入需要查找的关键字:"<<endl;
cin
>>k;
cout
<<"顺序查找"<<endl;

if(Search_Seq(ST,k,n)==0)
cout
<<"没有该元素。"<<endl;
else cout<<k<<endl;
cout
<<"关键字在第 "<<Search_Seq(ST,k,n)<<" 位置。"<<endl;
cout
<<"查找比较次数为:"<<n-1<<endl;

cout
<<"折半查找"<<endl;
if(Search_Bin(ST,k,n)==0)
cout
<<"没有该元素。"<<endl;
else cout<<k<<endl;
cout
<<"关键字在第 "<<Search_Bin(ST,k,n)<<" 位置。"<<endl;
cout
<<"查找比较次数为:"<<n-1<<endl;
}

  排序                                                                                                                                    

#include<iostream.h>
#define MAXSIZE 20 //假设文件长度 ,即待排序记录数目
typedef
int KeyType; // 假设的关键字类型
typedef int InfoType;
typedef
struct { //记录定义

KeyType key;
//关键字型
InfoType otherinfo; //其他数据项,InfoType依赖于具体应用
}RedType; //记录类型
typedef struct { //顺序表定义

RedType r[MAXSIZE
+1]; //r[0]闲置或用来做小兵
int length; //顺序表长度

}SqList;
//顺序表类型

void input(SqList &L) //输入顺序表
{
cout
<<"请输入各元素"<<endl;
for(int i=1;i<=L.length;i++)
{
cin
>>L.r[i].key;
}
}
void Insertsort(SqList &L){ //对顺序表进行直接插入排序


int i,j;
for(i=2;i<=L.length;i++) //外循环
if(L.r[i].key<L.r[i-1].key) { //将L.r[i]插入有序子表

L.r[
0]=L.r[i];
for(j=i-1;L.r[0].key<L.r[j].key;j--) //内循环
L.r[j+1]=L.r[j]; //记录后移
L.r[j+1]=L.r[0];

}
//end if

}
//Insertsort
void Bubblesord(SqList &L)
{
int i,j;
bool tag=0;
for( i=1;(tag==0)&&(i<=L.length);++i)
{
tag
=1;
for(j=L.length-1;j>=i;--j)
if(L.r[j+1].key<L.r[j].key)
{
L.r[
0]=L.r[j+1];L.r[j+1]=L.r[j];L.r[j]=L.r[0];tag=0;
}
//end if
}//end for
}//Bubblesord
int main()
{
SqList L;
int i,m;
cout
<<"请输入元素个数:"<<endl;
cin
>>m;
L.length
=m;
input(L);
/* 显示该顺序表 */
cout
<<"该顺序表为"<<endl;
for(i=1;i<=L.length;i++)
cout
<<L.r[i].key<<"";
cout
<<endl;
/* 进行直接插入排序 */
Insertsort(L);
cout
<<"直接插入法排序"<<endl;
for(i=1;i<=L.length;i++)
cout
<<L.r[i].key<<"";
cout
<<endl;
/* 进行冒泡排序 */
Bubblesord(L);
cout
<<"进行冒泡排序"<<endl;
for(i=1;i<=L.length;i++)
cout
<<L.r[i].key<<"";
cout
<<endl;
return0;
}


冒泡、直插、快速比较算法,数据不是随即产生,手动输入的你可以做一个参考                                                                    

//这个是对 冒泡、直插、快速的比较算法。数据不是随即产生的,是手动输入的,你可以做一个参考! 代码如下: 

#include
<stdio.h>
#include
<stdlib.h>
#define MAX 100
void disparr();
int a[MAX],n,m;
void creatarr()
{
int i=0;
printf(
"建立原始数序\n");
printf(
"\t 元素个数:");
scanf(
"%d",&n);
while (i<n)
{
printf(
"\t 第%d个元素值:",i+1);
scanf(
"%d",&a[i]);
i
++;
}
}

int cmp(int lval, int rval,int order)
{
if (order==1)
{
if (lval<rval) return (1);
elsereturn (0); }
else
{
if(lval>rval) return (1);
elsereturn (0); }
}
void BubbleSort(int r[], int q, int w, int order)
{
int i=q ,j=w , k, swap;
for (i=q ; i<w ; i++)
{ swap
=0;
for (j=q ; j<=w-q ; j++ )
if(cmp(r[j+1], r[j], order))
{ k
=r[j+1];
r[j
+1]=r[j];
r[j]
=k;
swap
=1;
}
if (!swap) return;
}
printf(
"\n");
if (q<i) BubbleSort (r, q,i-1, order);
if (i<w) BubbleSort (r,j+1,w,order);
}
void insertsort(int x[],int l,int r,int order)
{
int i=l,j=r,temp;
for (i=1;i<=r;i++)
{ temp
=x[i];
j
=i-1;
while (j>0&& cmp(temp, x[j], order))
{ x[j
+1]=x[j];
j
--; }
x[j
+1]=temp;
}
printf(
"\n");
if (l<i) BubbleSort (x, l,i-1, order);
if (i<r) BubbleSort (x,j+1,r,order);
}
void quicksort(int x[],int l,int r,int order)
{
int i=l,j=r,temp;
temp
=x[l];
while (i<j)
{
while (i<j && cmp (temp, x[j],order)) j--;
if (i<j)
{ x[i]
=x[j]; i++; }
while (i<j && cmp (x[i], temp, order)) i++;
if (i<j)
{ x[j]
=x[i]; j--; }
}
x[i]
=temp;
if (l<i) quicksort (x, l,i-1, order);
if (i<r) quicksort (x,j+1,r,order);
}
void disparr()
{
int i;
for (i=0;i<n;i++)
printf(
"%d ",a[i]);
printf(
"\n\n");}
void main()
{
int m;
m
=1;
creatarr(a);
printf(
"\n 原来的次序:");
disparr();
while(m)
{printf(
"*********************************************************************\n");
printf(
"0:退出 1:重新输入 2:直接插入排序 3:冒泡排序 4:快速排序 \n ");
printf(
"**********************************************************************\n");
scanf(
"%d",&m);
switch(m)
{
case0:
exit(
-1);
case1:
creatarr(a);
printf(
"\n 原来的次序:");
disparr();
break;
case2:
printf(
"直接插入排序:\n");
printf(
"从小到大排序:\n");
insertsort(a,
0,n-2,1);
printf(
"排序结果:");
disparr();
printf(
"从大到小排序:\n");
insertsort(a,
0,n-2,0);
printf(
"排序结果:");
disparr();
break;
case3:
printf(
"冒泡排序法:\n");
printf(
"从小到大排序:\n");
BubbleSort(a,
0,n-2,1);
printf(
"排序结果:");
disparr();
printf(
"从大到小排序:\n");
BubbleSort(a,
0,n-2,0);
printf(
"排序结果:");
disparr();
break;
case4:
printf(
"快速排序法:\n");
printf(
"从小到大排序:\n");
quicksort(a,
0,n-1,1);
printf(
"排序结果:");
disparr();
printf(
"从大到小排序:\n");
quicksort(a,
0,n-1,0);
printf(
"排序结果:");
disparr();
break;
}
}
}

用系统计时器算时间复杂度                                                                                                         

//用系统计时器算时间复杂度。

#include
<stdio.h>
#include
<stdlib.h>
#include
<string.h>
#include
<time.h>
#define LIST_INIT_SIZE 50000
int bj1,yd1,n;
clock_t start_t,end_t;
typedef
struct
{
int key;
}ElemType;
typedef
struct
{
ElemType
*elem;
int length;
}SqList;
void addlist(SqList &L)
{
int i;
a: printf(
"请输入你要输入的个数:");
scanf(
"%d",&n);
if(n>50000)
{
printf(
"超出范围重新输入!!!\n");
goto a;
}
L.elem
=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
if(!L.elem)exit(0);
L.length
=0;
for(i=1;i<n+1;i++)
{
b: L.elem[i].key
=rand();
if(L.elem[i].key>30000)goto b;
++L.length;
}
}
void SelectSort(SqList &L)//选择
{
start_t
=clock();
int i,j,k,bj=0,yd=0;
for(i=1;i<L.length;i++)
{
k
=i;
for(j=i+1;j<L.length;j++)
{
bj
++;
if(L.elem[j].key<L.elem[k].key)k=j;
}
if(i!=k)
{
L.elem[
0].key=L.elem[i].key;
L.elem[i].key
=L.elem[k].key;
L.elem[k].key
=L.elem[0].key;
yd
+=3;
}
}
end_t
=clock();
printf(
"比较次数为 %d移动次数为 %d\n",bj,yd);
printf(
"排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void qipao(SqList &L)//起泡
{
start_t
=clock();
int i=1,j,bj=0,yd=0;
while(i<L.length)
{
for(j=1;j<L.length;j++)
{
bj
++;
if(L.elem[j].key>L.elem[j+1].key)
{
L.elem[
0].key=L.elem[j].key;
L.elem[j].key
=L.elem[j+1].key;
L.elem[j
+1].key=L.elem[0].key;
yd
+=3;
}
}
i
++;
}
end_t
=clock();
printf(
"比较次数为 %d移动次数为 %d\n",bj,yd);
printf(
"排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void InsertSort(SqList &L)//直接插入
{
start_t
=clock();
int i,j,yd=0,bj=0;
for(i=2;i<=L.length;i++)
{
if(L.elem[i].key<L.elem[i-1].key)
{
L.elem[
0].key=L.elem[i].key;
yd
++;
j
=i-1;
bj
++;
while(L.elem[0].key<L.elem[j].key)
{
L.elem[j
+1].key=L.elem[j].key;
j
--;
yd
++;
bj
++;
}
L.elem[j
+1].key=L.elem[0].key;
yd
++;
}
}
end_t
=clock();
printf(
"比较次数为 %d移动次数为 %d\n",bj,yd);
printf(
"排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void xier(SqList &L)//希尔
{
start_t
=clock();
int i,d=L.length/2,j,w=0,k,yd=0,bj=0;
while(w<d)
{
w
=1;
for(i=w;i<L.length;i=i+d)
{
k
=i;
for(j=i+d;j<L.length;j=j+d)
{
if(L.elem[i].key>L.elem[j].key)
{
k
=j;
bj
++;
}
}
if(i!=k)
{
L.elem[
0].key=L.elem[i].key;
L.elem[i].key
=L.elem[k].key;
L.elem[k].key
=L.elem[0].key;
yd
+=3;
}
w
++;
}
d
=d/2;
w
=1;
}
end_t
=clock();
printf(
"比较次数为 %d移动次数为 %d\n",bj,yd);
printf(
"排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}


void BeforeSort()
{
yd1
=0,bj1=0;
}
void display(int m,int n)
{
printf(
"比较次数为 %d移动次数为 %d\n",m,n);
}
int Partition(SqList &L,int low,int high)//快速排序
{
int pivotkey;
L.elem[
0]=L.elem[low];
yd1
++;
pivotkey
=L.elem[low].key;
while (low<high)
{
yd1
++;
while(low<high&&L.elem[high].key>=pivotkey)
--high;
L.elem[low]
=L.elem[high];
bj1
++;
yd1
++;
while (low<high&&L.elem[low].key<=pivotkey)
++low;
L.elem[high]
=L.elem[low];
bj1
++;
yd1
++;
}
L.elem[low]
=L.elem[0];
yd1
++;
return low;
}
void QSort(SqList &L,int low,int high)
{
int pivotloc;
if(low<high)
{
pivotloc
=Partition(L,low,high);
QSort(L,low,pivotloc
-1);
QSort(L,pivotloc
+1,high);
}
}
void QuickSort(SqList &L)
{
start_t
=clock();
BeforeSort();
QSort(L,
1,L.length);
display(yd1,bj1);
end_t
=clock();
printf(
"排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}
void Merge(ElemType R[],ElemType R1[],int low,int m,int high)//归并
{
int i=low, j=m+1, k=low;
while(i<=m&&j<=high)
{
if(R[i].key<=R[j].key)
{
bj1
++;
R1[k]
=R[i];
yd1
++;
i
++;
k
++;
}
else
{
bj1
++;
R1[k]
=R[j];
yd1
++;
j
++;
k
++;
}
}
while(i<=m)
{
R1[k]
=R[i];
yd1
++;
i
++;
k
++;
}
while(j<=high)
{
R1[k]
=R[j];
yd1
++;
j
++;
k
++;
}
}
void MergePass(ElemType R[],ElemType R1[],int length, int n)
{
int i=0,j;
while(i+2*length-1<n)
{
Merge(R,R1,i,i
+length-1,i+2*length-1);
i
=i+2*length;
}
if(i+length-1<n-1)
Merge(R,R1,i,i
+length-1,n-1);
else
for(j=i;j<n;j++)
R1[j]
=R[j];
}
void MSort(ElemType R[],ElemType R1[],int n)
{
int length=1;
while (length<n)
{
MergePass(R,R1,length,n);
length
=2*length;
MergePass(R1,R,length,n);
length
=2*length;
}
}
void MergeSort(SqList &L)
{
start_t
=clock();
BeforeSort();
MSort(L.elem,L.elem,L.length);
display(yd1,bj1);
end_t
=clock();
printf(
"排序用时为 %f\n",float(end_t-start_t)/CLK_TCK);
}

void main()
{
SqList L;
addlist(L);
printf(
"起泡排序: \n");
qipao(L);
addlist(L);
printf(
"直插排序: \n");
InsertSort(L);
addlist(L);
printf(
"选择排序: \n");
SelectSort(L);
addlist(L);
printf(
"希尔排序: \n");
xier(L);
addlist(L);
printf(
"快速排续: \n");
QuickSort(L);
addlist(L);
printf(
"归并排序: \n");
MergeSort(L);
}

下面附加一下基本的顺序表和链表的操作                                                                                       

/* 设一个递增有序顺序表L,将x插入L中,使L仍有序。*/
#include
<iostream>
usingnamespace std;
#define INITSIZE 100
typedef
int ElemType;

typedef
struct{
ElemType
*elem;
int initsize;
int length;
}SqList;

void CreatSL(SqList &L,int n)
{

L.elem
=new ElemType[INITSIZE];
L.initsize
=INITSIZE;
L.length
=n;
cout
<<"请按从小到大输入顺序表的元素:"<<endl;

for(int i=0;i<L.length;i++)
cin
>>L.elem[i];
cout
<<"所创建的递增有序的顺序表为:"<<endl;


for(int j=0;j<L.length;j++)
cout
<<L.elem[j]<<"";
cout
<<endl;
}
void Insert(SqList L,ElemType e)
{
int i=0;
while((i<L.length)&&(L.elem[i]<=e)) i++;
if(i<L.length)
{
for(int j=L.length;j>i;j--)//用法一
L.elem[j]=L.elem[j-1];
L.elem[i]
=e;
/*//用法二
for(int j=L.length-1;j>i-1;j--)
L.elem[j+1]=L.elem[j];
L.elem[i]=e;
*/
}
else L.elem[L.length]=e;
L.length
=L.length+1;
cout
<<"插入后的顺序表为:"<<endl;
for(int k=0;k<L.length;k++)
{
cout
<<L.elem[k]<<"";
}
cout
<<endl;
}

void main()
{

int n;
ElemType e;
SqList L;
cout
<<"请输入顺序表的元素个数:";
cout
<<endl;
cin
>>n;

CreatSL(L,n);
cout
<<"请输入要插入的元素:";
cin
>>e;
Insert(L,e);
}

  

/* 设一个递减有序顺序表L,将x插入L中,使L仍有序。*/
#include
<iostream>
usingnamespace std;
#define INITSIZE 100
typedef
int ElemType;
typedef
struct{
ElemType
*elem;
int initsize;
int length;
}SqList;
void CreatSL(SqList &L,int n)
{
L.elem
=new ElemType[INITSIZE];
L.initsize
=INITSIZE;
L.length
=n;
cout
<<"请按从大到小输入顺序表的元素:";
for(int i=0;i<L.length;i++)
cin
>>L.elem[i];
cout
<<"所创建的递减有序的顺序表为:";
for(int j=0;j<L.length;j++)
cout
<<L.elem[j]<<"";
cout
<<endl;
}
void Insert(SqList L,ElemType e)
{
int i=0;
while((i<L.length)&&(L.elem[i]>=e)) i++;
if(i<L.length)
{
for(int j=L.length;j>i;j--)//用法一
L.elem[j]=L.elem[j-1];
L.elem[i]
=e;
/*//用法二
for(int j=L.length-1;j>i-1;j--)
L.elem[j+1]=L.elem[j];
L.elem[i]=e;
*/
}
else L.elem[L.length]=e;
L.length
=L.length+1;
cout
<<"插入后的顺序表为:";
for(int k=0;k<L.length;k++)
{
cout
<<L.elem[k]<<"";
}
cout
<<endl;
}
void main()
{
int n;
ElemType e;
SqList L;
cout
<<"请输入顺序表的元素个数:";
cin
>>n;
CreatSL(L,n);
cout
<<"请输入要插入的元素:";
cin
>>e;
Insert(L,e);
}

  

/*2.11 ①设A和B是两个递增有序的单链表,把他们归并成一个递减有序的单链表C,②并要求辅助空间为O(1)。
(这道题处于极度变态的边沿中,让我怀疑它还是题目吗,还是题目有误。我个人认为,条件①和条件②,不能同时达成,要把两个递增的有序表合并成一个递减的有序链表则辅助空间就不可能为O(1)。辅助空间要为O(1)的话就只能合并成递增的有序表,这纯属我个人研究结果,要是哪位做得出来两个条件都符合的话,记得告诉我一下啊!)
以下代码为:把两个递增有序的链表归并为一个递减有序链表
*/
#include
<iostream>
usingnamespace std;
typedef
int ElemType;
typedef
struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode
*LinkList;
void CreatList(LinkList &L,int n) //创立链表
{
LinkList p,q;
L
=new LNode;
L
->next=NULL;
q
=L;
cout
<<"请从小到大输入链表的元素:";
for(int i=1;i<=n;i++)
{
p
=new LNode;
cin
>>p->data;
p
->next=q->next;
q
->next=p;
q
=q->next;
}
cout
<<"所创建得的递增有序链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void CreatC(LinkList &A,LinkList &B,LinkList &C,int n) //合并链表
{
C
=new LNode;
C
->next=NULL;
LinkList p,q,t;
p
=A->next;
q
=B->next;
while(p&&q)
{
t
=new LNode;
if(p->data<=q->data)
{
t
->data=p->data;
p
=p->next;
}
else
{
t
->data=q->data;
q
=q->next;

}
t
->next=C->next;
C
->next=t;
}
while(p)
{
t
=new LNode;
t
->data=p->data;
t
->next=C->next;
C
->next=t;
p
=p->next;
}
while(q)
{
t
=new LNode;
t
->data=q->data;
t
->next=C->next;
C
->next=t;
q
=q->next;
}
cout
<<"合并后的递减有序链表为:";
p
=C->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void main()
{
LinkList A,B,C;
int n,m,k;
cout
<<"请输入链表***A***的长度:";
cin
>>n;
CreatList(A,n);
cout
<<"请输入链表***B***的长度:";
cin
>>m;
CreatList(B,m);
k
=m+n;
CreatC(A,B,C,k);
}

  

/* 2.11 ①设A和B是两个递增有序的单链表,把他们归并成一个递减有序的单链表C,②并要求辅助空间为O(1)。
(这道题处于极度变态的边沿中,让我怀疑它还是题目吗,还是题目有误。我个人认为,条件①和条件②,不能同时达成,要把两个递增的有序表合并成一个递减的有序链表则辅助空间就不可能为O(1)。辅助空间要为O(1)的话就只能合并成递增的有序表,这纯属我个人研究结果,要是哪位做得出来两个条件都符合的话,记得告诉我一下啊!)
*/
//以下代码为:把两个递增有序的单链表归并为一个递增有序的链表,辅助空间为O(1)
#include<iostream>
usingnamespace std;
typedef
int ElemType;
typedef
struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode
*LinkList;
void CreatList(LinkList &L,int n) //创立链表
{
LinkList p,q;
L
=new LNode;
L
->next=NULL;
q
=L;
cout
<<"请从小到大输入链表的元素:";
for(int i=1;i<=n;i++)
{
p
=new LNode;
cin
>>p->data;
p
->next=q->next;
q
->next=p;
q
=q->next;
}
cout
<<"所创建得的递增有序链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void CreatC(LinkList &A,LinkList &B,LinkList &C,int n) //合并链表
{
LinkList p,q,t;
p
=A->next;
q
=B->next;
C
=t=A;
while(p&&q)
{
if(p->data<=q->data)
{
t
->next=p;
t
=p;
p
=p->next;
}
else
{
t
->next=q;
t
=q;
q
=q->next;
}
}
t
->next=p?p:q;
delete B;
cout
<<"合并后的递增有序链表为:";
p
=C->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}

void main()
{
LinkList A,B,C;
int n,m,k;
cout
<<"请输入链表***A***的长度:";
cin
>>n;
CreatList(A,n);
cout
<<"请输入链表***B***的长度:";
cin
>>m;
CreatList(B,m);
k
=m+n;
CreatC(A,B,C,k);
}

  

/* 2.12 设L是递增有序单链表,删除其中大于min且小于max的元素结点,并释放结点空间。
(有点部分和上次那份上机题的那道C卷的不一样,用法简单一点,大家看一下)
*/

#include
<iostream>
usingnamespace std;
typedef
int ElemType;
typedef
struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode
*LinkList;
void CreatList(LinkList &L,int n)
{
LinkList p,q;
L
=new LNode;
L
->next=NULL;
q
=L;
cout
<<"请从小到大输入链表的元素:\n";
for(int i=1;i<=n;i++)
{
p
=new LNode;
cin
>>p->data;
p
->next=q->next;
q
->next=p;
q
=q->next;
}
cout
<<"所创建得的递增有序链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void Find(LinkList &L,ElemType min,ElemType max,int n)
{
LinkList p,t;
p
=L;
while(p->next)
{
if((p->next->data>min)&&(p->next->data<max))
{
t
=p->next;
p
->next=t->next;
delete t;
n
--;
}
else
{
p
=p->next;
}
}
cout
<<"操作后的递增有序链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void main()
{
LinkList L;
int n;
ElemType min,max;
cout
<<"请输入链表的长度:";
cin
>>n;
CreatList(L,n);
cout
<<"请输入min的值:";
cin
>>min;
cout
<<"请输入max的值:";
cin
>>max;
Find(L,min,max,n);
}

  

/* 2.13 将单链表中值重复的结点删除,使所得的单链表中各结点值均不同。*/
#include
<iostream>
usingnamespace std;
typedef
int ElemType;
typedef
struct LNode{
ElemType data;
struct LNode *next;
}LNode;
typedef LNode
* LinkList;
void CreatLN(LinkList &L,int n)
{
L
=new LNode;
L
->next=NULL;
LinkList p,q;
q
=L;
cout
<<"请输入链表元素:";
for(int i=1;i<=n;i++)
{
p
=new LNode;
cin
>>p->data;
p
->next=q->next;
q
->next=p;
q
=q->next;
}
cout
<<"创建的单链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void delet(LinkList &L,int n)
{
LinkList p,q,t,w;
p
=L->next;
while(p)
{
t
=p;
q
=p->next;
while(q)
{
if(p->data!=q->data) {q=q->next;t=t->next;}
else
{
w
=q;
t
->next=q->next;
q
=t->next;
delete w;
n
--;
}
}
p
=p->next;
}
cout
<<"删除相同结点后的单链表为:";
p
=L->next;
for(int j=1;j<=n;j++)
{
cout
<<p->data<<"";
p
=p->next;
}
cout
<<endl;
}
void main()
{
LinkList L;
int n;
cout
<<"请输入链表的元素个数:";
cin
>>n;
CreatLN(L,n);
delet(L,n);
}

  

/*
建立一个数据为整数的单链表L,然后将该链表中的数据域值最小的那个结点移到链表的最前端
第一步:建立一个单链表
第2: 显示该单链表
第3: 查找链表中数据域最小的值,并将它移到到链表的最前端
第4: 显示该单链表

*/

#include
<iostream>
usingnamespace std;

#define LIST_INIT_SIZE 100 //存储空间初始分配量
#define LIST_INCREMENT 10 //存储空间增补量
/*线性表方法类*/
typedef
int ElemType;
typedef
struct LNode{
ElemType data;
//
struct LNode *next; //
}LNode;

typedef LNode
*LinkList; //

void InitList_L(LinkList &L,int n){
//构造空单链表L
LinkList p;
L
=new LNode; L->next=NULL;
cout
<<"请输入您要输入的数据(逆序):\n";
for(int i=0;i<n;++i){
p
=new LNode;
cin
>>p->data;
p
->next=L->next;
L
->next=p;
}
}
//InitList_L

void PrintList(LinkList L){
LinkList p;
cout
<<"你输入的数据输出为:\n";
p
=L->next;
while(p)
{
cout
<<p->data<<"";
p
=p->next;
}
}

void FindList(LinkList L)
{
LinkList o,p,q;
p
=L->next;
o
=L->next;
int n=p->data;
while(p)
{
if(n>p->data)
{
n
=p->data;
q
=p;
}
p
=p->next;
}
cout
<<"\n链表中最小的结点数据域值为:\n";
cout
<<n<<endl;
cout
<<"链表中最小的结点移到链表的最前端链表输出为:\n";
cout
<<n<<"";
while(o)
{
if(o->data==n)
{
LNode
*q=o;o=q->next;
delete q;
}
else
{
cout
<<o->data<<"";
o
=o->next;
}
}

}


void main(){
int n;
LinkList L;
cout
<<"请输入链表中元素的个数:\n";
cin
>>n;
InitList_L(L,n);
PrintList(L);
FindList(L);
cout
<<endl;
}

附加:常用数据结构                                                                                   

 

数组 (Array)                                                                                                                         

  在程序设计中,为了处理方便, 把具有相同类型的若干变量按有序的形式组织起来。这些按序排列的同类数据元素的集合称为数组。在C语言中,
数组属于构造数据类型。一个数组可以分解为多个数组元素,这些数组元素可以是基本数据类型或是构造类型。因此按数组元素的类型不同,数组又可分为数值数组、字符数组、指针数组、结构数组等各种类别。

栈 (Stack)                                                                                                                            

  是只能在某一端插入和删除的特殊线性表。它按照后进先出的原则存储数据,先进入的数据被压入栈底,最后的数据在栈顶,需要读数据的时候从栈顶开始弹出数据(最后一个数据被第一个读出来)。
队列 (Queue)                                                                                                                          

  一种特殊的线性表,它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作。进行插入操作的端称为队尾,进行删除操作的端称为队头。队列中没有元素时,称为空队列。

链表 (Linked List)                                                                                                                   

  是一种物理存储单元上非连续、非顺序的存储结构,数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点(链表中每一个元素称为结点)组成,结点可以在运行时动态生成。每个结点包括两个部分:一个是存储数据元素的数据域,另一个是存储下一个结点地址的指针域。
树 (Tree)                                                                                                                               

  是包含n(n>0)个结点的有穷集合K,且在K中定义了一个关系N,N满足 以下条件:
  (1)有且仅有一个结点
k0,他对于关系N来说没有前驱,称K0为树的根结点。简称为根(root)。 

(2)除K0外,k中的每个结点,对于关系N来说有且仅有一个前驱。
  (3)K中各结点,对关系N来说可以有m个后继(m>=0)。
图 (Graph)                                                                                                                            

  图是由结点的有穷集合V和边的集合E组成。其中,为了与树形结构加以区别,在图结构中常常将结点称为顶点,边是顶点的有序偶对,若两个顶点之间存在一条边,就表示这两个顶点具有相邻关系。
堆 (Heap)                                                                                                                             

  在计算机科学中,堆是一种特殊的树形数据结构,每个结点都有一个值。通常我们所说的堆的数据结构,是指二叉堆。堆的特点是根结点的值最小(或最大),且根结点的两个子树也是一个堆。
散列表 (Hash)                                                                                                                       

若结构中存在关键字和K相等的记录,则必定在f(K)的存储位置上。由此,不需比较便可直接取得所查记录。称这个对应关系f为散列函数(Hash function),按这个思想建立的表为

 

后记                                                                                                                                       

具体我就不调试结果出来了,要想知道结果怎么样,还得大家自己回去按照代码编程一遍,编写不对或者有其他问题可以留言交流,谢谢大家了!!!

 

参考:                                                                                                                                    

        严蔚敏,吴伟民编著图书 ---《数据结构与算法》 

        百度百科——数据结构

 

 

作者:类菌体
出处:http://www.cnblogs.com/bacteroid/archive/2011/07/31/2122910.html
关于作者:在校学生
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接
如有问题,可以通过303323670@qq.com 联系我,非常感谢。