数据结构——查找、普通查找、折半查找

  1 #define initSize 100
  2 typedef int DataType;
  3 typedef struct SeqList
  4 {
  5     DataType *data;
  6     int maxSize, n;
  7 };
  8 //普通顺序表上的顺序查找算法
  9 int SeqSearch(SeqList& L, DataType x)
 10 {
 11     int i=0;
 12     while(i<L.n && L.data[i].key ! = x.key)
 13         i++;
 14     return i;
 15 }
 16 
 17 
 18 //普通顺序表上使用监视哨的顺序查找算法
 19 int SeqSearch(SeqList& L, DataType x)
 20 {
 21     L.data[L.n] = x;//将x设置为监视哨
 22     int i=0;
 23     while(L.data[i].key != x.key)//从前向后顺序查找
 24         i++;
 25     return i;
 26 }
 27 
 28 //普通顺序表上的顺序查找的递归算法
 29 int SeqSearch(SeqSearch& L, DataType x, int loc)
 30 {
 31     if(loc >= L.n)//查找失败
 32         return -1;
 33     else if(L.data[loc].key == x.key)//查找成功
 34         retur loc;
 35     else return SeqSearch(L, x, loc+1);//递归查找表的后续部分
 36 }

 39 //有序顺序表上的顺序查找算法
 40 int SeqSearch(SeqList& L, DataType x)
 41 {
 42     for(int i=0; i<L.n; i++)
 43     {
 44         if(L.data[i].key == x.key)//成功，返回查找到的位置
 45             return i;
 46         else if(L.data[i].key > x.key)//不成功，停止查找
 47             break;
 48     }
 49     return -1;//返回-1,失败信息
 50 }
 51 
 52 
 53 //单链表结构定义
 54 typedef int DataType;
 55 typedef struct node//链表结点
 56 {
 57     DataType data;//数据域
 58     struct node *link;//链接指针域
 59 }LinkNode, *LinkList;
 60 //带头结点的单链表，初始化
 61 void initList(LinkList& first)
 62 {
 63     first = new LinkNode;
 64     first->link = NULL;
 65 }
 66 
 67 //普通单链表上的顺序查找算法
 68 LinkNode *SeqSearch(LinkList& L, DataType x)
 69 {
 70     LinkNode *p = L->link;//查找指针p指向首元结点
 71     while(p != NULL && p->data.key != x.key)//循链找含x结点
 72         p=p->link;
 73     return p;
 74 }

 75 
 76 //有序线性链表的顺序查找算法
 77 LinkNode *SeqSearch(LinkList& L, DataType x)
 78 {
 79     LinkNode *p = L->link;//查找p指向首元结点
 80     while(p != NULL && p->data.key <= x.key)//循链找含x结点
 81         p=p->link;
 82     if(p != NULL && p->data.key == x.key)
 83         return p;
 84     else
 85         return NULL;
 86 }

 93 //折半查找法
 94 //有序顺序表上折半查找的非递归算法
 95 int BinarySesrch(SeqList& L, DataType x)
 96 {
 97     int high = L.n-1, low = 0, mid;
 98     while(low <= high)
 99     {
100         mid = (low + high)/2;//中点
101         if(x.key > L.data[mid].key)//大于中点值，右缩查找区间
102             low = mid + 1;
103         else if(x.key <L.data[mid].key)//小于中点值，左缩查找区间
104             high = mid - 1;
105         else
106             return mid + 1;//等于中点值，查找成功
107     }
108     return -1;//查找区间缩为0,查找失败
109 }
110 //有序顺序表上折半查找的递归算法
111 int BinarySesrchRecur(SeqList& L, DataType x, int low, int high)
112 {
113     int mid = -1;
114     if(low <= high)
115     {
116         mid = (low + high)/2;//求中点
117         if(x.key > L.data[mid].key)//大于中点值，右缩查找区间
118             mid = BinarySearchRecur(L, x, mid+1, high);
119         else if(x < L.data[mid].key)//小于中点值，左缩查找区间
120             mid = BinarySearchRecur(L, x, low, mid-1);
121         //等于中点值，继续向下执行
122     }
123     return mid;//返回中点位置(成功)或-1(失败)
124 }