C语言数据结构之顺序结构，字符串（String）的计算HASHCODE的方法和其他功能

已于 2024-10-12 09:10:10 修改
阅读量283 收藏 4
点赞数 5
分类专栏： 把C语言捡起来 文章标签： 开发语言 c语言 数据结构
于 2024-10-12 09:09:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gwsong52/article/details/142868648
版权

C语言数据结构之顺序结构，字符串（String）的计算HASHCODE的方法和其他功能

继续上一个关于String的操作

判断字符串是否以prefix开头／是否以suffix结尾

  • 是否以suffix结尾函数 string_ends_with
  • 是否以prefix开头函数 string_starts_with

代码如下：

/* if string ends with suffix return 1 else return 0 */
int
string_ends_with (String *st, char *suffix)
{
  int tmp = 1;
  for (int i = st->length - 1, j = strlen (suffix) - 1; j >= 0; j--, i--)
    if (st->elts[i] != suffix[j])
      { tmp = 0; break; }
  return tmp;
}

/* if string starts with prefix return 1 else return 0 */
int
string_starts_with (String *st, char *prefix)
{
  int tmp = 1;
  for (int i = 0, j = 0; j < strlen (prefix); j++, i++)
    if (st->elts[i] != prefix[j])
      { tmp = 0; break; }
  return tmp;
}
  • 测试函数test_string_with代码如下：
/**/
void
test_string_with (void)
{
  String *st = string_new ("<<<Not only a test here!>>>");
  string_info (st);
  if (1 == string_starts_with (st, "<<<"))
    printf ("Starts with <<< !\n");
  if (1 == string_ends_with (st, ">>>"))
    printf ("Ends with >>> !\n");
  string_free (st);
}

编译运行，结果如下：

songvm@ubuntu:~/works/xdn/soo$ gcc string.c -o string
songvm@ubuntu:~/works/xdn/soo$ ./string
<<<Not only a test here!>>>
Page : 4, Length : 27
Starts with <<< !
Ends with >>> !
------------------------------
songvm@ubuntu:~/works/xdn/soo$

字符串取字符索引 INDEXOF 和大小写字母转换

  • 字符串取字符索引函数 string_indexof_char
  • 字符串转小写 string_to_lower_case
  • 字符串转大写 string_to_upper_case

代码如下：

/* get index of char, if not found return -1 */
int
string_indexof_char (String *st, char c)
{
  int idx = -1;
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] == c)
      { idx = i; break; }
  return idx;
}

/* to lower case */
void
string_to_lower_case (String *st)
{
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] >= 'A' && st->elts[i] <= 'Z')
      st->elts[i] = st->elts[i] + 32;
}

/* to upper case */
void
string_to_upper_case (String *st)
{
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] >= 'a' && st->elts[i] <= 'z')
      st->elts[i] = st->elts[i] - 32;
}
  • 测试函数test_string_indexof，test_string_to代码如下：
/**/
void
test_string_indexof (void)
{
  String *st = string_new ("Aha test here!");
  string_info (st);
  printf ("Index of char [e] is %d\n", string_indexof_char (st, 'e'));
  printf ("Index of char [X] is %d\n", string_indexof_char (st, 'X'));
  string_free (st);
}

/**/
void
test_string_to (void)
{
  String *st = string_new ("Not only a test!");
  string_info (st);
  string_to_upper_case (st);
  string_info (st);
  string_to_lower_case (st);
  string_info (st);
  string_free (st);
}

编译运行，结果如下：

songvm@ubuntu:~/works/xdn/soo$ gcc string.c -o string
songvm@ubuntu:~/works/xdn/soo$ ./string 
Aha test here!
Page : 2, Length : 14
Index of char [e] is 5
Index of char [X] is -1
------------------------------
Not only a test!
Page : 3, Length : 16
NOT ONLY A TEST!
Page : 3, Length : 16
not only a test!
Page : 3, Length : 16
------------------------------
songvm@ubuntu:~/works/xdn/soo$

hash算法，求字符串hashcode的算法有很多种，以下罗列了一些，仅供参考

  • powxn 简单的求x的n次方函数
  • java hashcode method : s[0]*31^(n-1) + s[1]*31^(n-2) + … + s[n-1]
  • string_java_hashcode 代码如下：
/* got x pow n */
static long
powxn (long x, int n)
{
  long ln = (long)n;
  long t = 1;
  while (ln)
    {
      t *= (ln % 2 ? x : 1);
      x *= x;
      ln >>= 1;
    }
  return t;
}

/* java hashcode method */
/* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] */
unsigned int
string_java_hashcode (String *st)
{
  unsigned int h = 0;
  for (int i = 0, j = st->length - 1; i < st->length; i++, j--)
    h = h + st->elts[i] * powxn (31, j); //31 ^ j;
  return h;
}
  • GLIB中的hash算法
/* another hashcode method */
unsigned int
string_mg_hashcode (String *st)
{
  const char *p = st->elts;
  unsigned int h = *p;
  if (h)
    for (p += 1; *p != '\0'; p++)
      h = (h << 5) - h + *p;
  return h;
}
  • ELF 算法
/* ELF */
unsigned int
string_elf_hashcode (String *st)
{
  int hash = 0, x = 0;
  for (int i = 0; i < st->length; i++)
    {
      hash = (hash << 4) + st->elts[i];
      if ((x = hash & 0xF0000000L) != 0)
	  hash ^= (x >> 24);
      hash &= ~x;
    }
  return (hash & 0x7FFFFFFF);
}
  • JS 算法
/* JS */
unsigned int
string_js_hashcode (String *st)
{
  int hash = 1315423911; //not a prime
  for (int i = 0; i < st->length; i++)
    hash ^= ((hash << 5) + (hash >> 2) + st->elts[i]);
  return (hash & 0x7FFFFFFF);
}
  • RS 算法
/* RS */
unsigned int
string_rs_hashcode (String *st)
{
  int b = 378551; //prime
  int a = 63689;  //prime
  int hash = 0;
  for (int i = 0; i < st->length; i++)
    {
      hash = hash * a + st->elts[i];
      a = a * b;
    }
  return (hash & 0x7FFFFFFF);
}
  • PJW 算法
/* PJW */
unsigned int
string_pjw_hashcode (String *st)
{
  int BitsInUnsignedInt = 32;
  int ThreeQuarters = (BitsInUnsignedInt * 3) / 4;
  int OneEighth = BitsInUnsignedInt / 8;
  int HighBits = 0xFFFFFFFF << (BitsInUnsignedInt - OneEighth);
  int hash = 0;
  int test = 0;
  for (int i = 0; i < st->length; i++)
    {
      hash = (hash << OneEighth) + st->elts[i];
      if ((test = hash & HighBits) != 0)
	hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
    }
  return (hash & 0x7FFFFFFF);
}
  • Jenkins 算法
/* Jenkins */
unsigned int
string_jenkins_hashcode (String *st)
{
  unsigned int hash = 0;
  char *str = st->elts;
  for (unsigned int i = 0; i < st->length; str++, i++)
    {
      hash += (*str) + (hash << 10);
      hash ^= (hash >> 6);
    }
  hash += (hash << 3);
  hash ^= (hash >> 11);
  hash += (hash << 15);
  return (hash & 0x7FFFFFFF);
}
  • DJB 算法
/* DJB */
unsigned int
string_djb_hashcode (String *st)
{
  unsigned int hash = 5381;
  char *str = st->elts;
  while (*str)
    hash += (hash << 5) + (*str++);
  return (hash & 0x7FFFFFFF);
}
  • AP 算法
/* AP */
unsigned int
string_ap_hashcode (String *st)
{
  unsigned int hash = 0;
  char *str = st->elts;
  for (int i=0; *str; i++)
    {
      if ((i & 1) == 0)
	hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
      else
	hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
    }
  return (hash & 0x7FFFFFFF);
}
  • 字符串求HASHCODE函数string_hashcode调用以上算法，代码如下：
/* get string hashcode */
unsigned int
string_hashcode (String *st)
{
  //return string_elf_hashcode (st);
  //return string_rs_hashcode (st);
  //return string_js_hashcode (st);
  //return string_pjw_hashcode (st);
  //return string_java_hashcode (st);
  return string_mg_hashcode (st);
  //return string_jenkins_hashcode (st);
  //return string_djb_hashcode (st);
  //return string_ap_hashcode (st);
}
  • 测试函数test_string_hashcode代码如下：
/**/
void
test_string_hashcode (void)
{
  String *st1 = string_new ("www.runoob.com");
  String *st2 = string_new ("Not only a test!");
  String *st3 = string_new ("Also a test");
  String *st4 = string_new ("Other test");
  string_info (st1);
  printf ("Hashcode is %d\n", string_hashcode (st1));
  string_info (st2);
  printf ("Hashcode is %d\n", string_hashcode (st2));
  string_info (st3);
  printf ("Hashcode is %d\n", string_hashcode (st3));
  string_info (st4);
  printf ("Hashcode is %d\n", string_hashcode (st4));
  string_free (st1);
  string_free (st2);
  string_free (st3);
  string_free (st4);
}

编译运行，结果如下：

songvm@ubuntu:~/works/xdn/soo$ gcc string.c -o string
songvm@ubuntu:~/works/xdn/soo$ ./string
www.runoob.com
Page : 2, Length : 14
Hashcode is 321005537
Not only a test!
Page : 3, Length : 16
Hashcode is 2443443497
Also a test
Page : 2, Length : 11
Hashcode is 3333693258
Other test
Page : 2, Length : 10
Hashcode is 1753054146
------------------------------
songvm@ubuntu:~/works/xdn/soo$

可以打开string_hashcode函数中的注释来分别调用不同算法查看结果！！！

求HASHCODE在数据结构哈希表中非常重要，涉及到存贮查找的效率问题！！！

string.c 完整代码如下：

/* filename: string.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* compile : gcc string.c -o string
       run : ./string                  */

/* define string page size */
#define SPSIZE 8

/* define String datatype struct _String */
typedef struct _String String;
struct _String {
  char *elts;
  int length;
  int page;
};

/* new string with SPSIZE bytes memory fill 0 */
String *
string_new0 (void)
{
  String *str = (String*) malloc (sizeof(String));
  str->elts = (char*) malloc (SPSIZE * sizeof(char));
  memset (str->elts, 0, SPSIZE);
  str->page = 1; str->length = 0;
  return str;
}

/* new string from char* */
String *
string_new (char *c)
{
  String *str = string_new0 ();
  int len = strlen (c);
  if (len > SPSIZE)
    {
      str->page = len/SPSIZE + 1;
      str->elts = (char*) realloc (str->elts, str->page * SPSIZE);
      memset (str->elts, 0, str->page * SPSIZE);
    }
  for (int i = 0; i < len; i++)
    str->elts[i] = c[i];
  str->length = len;
  return str;
}

/* free the String */
void
string_free (String *str)
{
  free (str->elts);
  free (str);
}

/* append char* to string */
void
string_append (String *st, char *ca)
{
  int len = st->length + strlen (ca);
  if (len > st->page * SPSIZE)
    {
      st->page = len/SPSIZE + 1;
      st->elts = (char*) realloc (st->elts, st->page * SPSIZE);
    }
  for (int i = st->length, j = 0; i < len; i++, j++)
    st->elts[i] = ca[j];
  st->elts[len] = 0;
  st->length = len;
}

/* pre append char* to string */
void
string_prepend (String *st, char *ca)
{
  char *buf, *tmp;
  int len =  strlen (ca);
  int lx = st->length + len;
  if (lx >= st->page * SPSIZE)
    st->page = lx / SPSIZE + 1;
  buf = (char*) malloc (st->page * SPSIZE * sizeof(char));
  memset (buf, 0, st->page * SPSIZE);
  for (int i = 0; i < len; i++)
    buf[i] = ca[i];
  for (int i = len, j = 0; i < lx; i++, j++)
    buf[i] = st->elts[j];
  tmp = st->elts;
  st->length = lx;
  st->elts = buf;
  free (tmp);
}

/* insert char* to string at idx */
void
string_insert (String *st, int idx, char *ca)
{
  char *buf, *tmp;
  int len = strlen (ca);
  int lx = len + st->length;
  if (lx >= st->page * SPSIZE)
      st->page = lx / SPSIZE + 1;
  buf = (char*) malloc (st->page * SPSIZE * sizeof(char));
  memset (buf, 0, st->page * SPSIZE);
  for (int i = 0; i < idx; i++)
    buf[i] = st->elts[i];
  for (int j = idx, k = 0; j < len + idx; j++, k++)
    buf[j] = ca[k];
  for (int i = len + idx, j = idx; i < lx; i++, j++)
    buf[i] = st->elts[j];
  st->length = lx;
  tmp = st->elts;
  st->elts = buf;
  free (tmp);
}

/* erase all at pos to end */
void
string_erase_all (String *st, int pos)
{
  if (pos >= st->length) return; //do nothing
  for (int i = pos; i < st->length; i++)
    st->elts[i] = 0;
  st->length = pos;
}

/* erase section at pos length eq len */
void
string_erase_section (String *st, int pos, int len)
{
  if (pos >= st->length) return; //do nothing
  for (int i = pos; i < pos + len; i++)
    st->elts[i] = 0;
  for (int i = pos + len, j = pos; i < st->length; i++, j++)
    st->elts[j] = st->elts[i];
  for (int i = st->length - len; i < st->length; i++)
    st->elts[i] = 0;
  st->length = st->length - len;
}

/* string trim space tab newline at head and tail */
void
string_trim (String *st)
{
  int start, end;
  char *tmp, *buf;
  buf = (char*) malloc (st->page * SPSIZE * sizeof(char));
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] != ' ' && st->elts[i] != '\t' && st->elts[i] != '\n')
      {	start = i; break; }
  for (int i = st->length - 1; i >=0; i--)
    if (st->elts[i] != ' ' && st->elts[i] != '\t' && st->elts[i] != '\n')
      {	end = i; break; }
  for (int i = start, j = 0; i <= end; i++, j++)
    buf[j] = st->elts[i];
  st->length = end - start + 1;
  tmp = st->elts;
  st->elts = buf;
  free (tmp);
}

/* reverse string */
void
string_reverse (String *st)
{
  for (int i = 0, n = st->length - 1; i < st->length / 2; i++, n--)
    {
      char t = st->elts[i];
      st->elts[i] = st->elts[n];
      st->elts[n] = t;
    }
}

/* get substring from a string */
String*
string_sub (String *st, int pos, int len)
{
  String *tmp = NULL;
  int ln = 0;
  if (pos >= st->length) return tmp;
  if ((pos + len) > st->length)
    ln = st->length;
  else
    ln = pos + len;
  tmp= string_new ("");
  for (int i = pos, j = 0; i < ln; i++, j++)
    tmp->elts[j] = st->elts[i];
  tmp->length = len;
  return tmp;
}

/* test src eq dst if true return 1 else return 0 */
static int
streq (char *src, char *dst)
{
  for (int i = 0; i < strlen (dst); i++)
    if (src[i] != dst[i]) return 0;
  return 1;
}

/* replace src in string to dst */
void
string_replace (String *st, char *src, char *dst)
{
  int i, j, k = -1;
  int ls = strlen (src);
  int ld = strlen (dst);
  char *buf, *tmp = st->elts;
  if (ls > st->length)
    { printf ("Info: String no change!\n"); return; }
  for (i = 0; i < st->length - ls + 1; i++)
    if (1 == streq (&tmp[i], src))
      { k = i; break; }
  if (k == -1) { printf ("Info: String not found!\n"); return; }

  if (ls == ld)
    {
      for (i = 0, j = k; j < k + ls; j++, i++)
	st->elts[j] = dst[i];
    }
  else
    {
      int ln = st->length;
      ln = ln + ld - ls;
      if (ls < ld)
	st->page = ln / SPSIZE + 1;
      buf = (char*) malloc (st->page * SPSIZE * sizeof(char));
      for (i = 0; i < k; i++)
	buf[i] = st->elts[i];
      for (int n = 0; n < ld; n++, i++)
	buf[i] = dst[n];
      for (int n = k + ls; n < st->length; n++, i++)
	buf[i] = st->elts[n];
      st->length = ln;
      tmp = st->elts;
      st->elts = buf;
      free (tmp);
    }
}

/* if string ends with suffix return 1 else return 0 */
int
string_ends_with (String *st, char *suffix)
{
  int tmp = 1;
  for (int i = st->length - 1, j = strlen (suffix) - 1; j >= 0; j--, i--)
    if (st->elts[i] != suffix[j])
      { tmp = 0; break; }
  return tmp;
}

/* if string starts with prefix return 1 else return 0 */
int
string_starts_with (String *st, char *prefix)
{
  int tmp = 1;
  for (int i = 0, j = 0; j < strlen (prefix); j++, i++)
    if (st->elts[i] != prefix[j])
      { tmp = 0; break; }
  return tmp;
}

/* get index of char, if not found return -1 */
int
string_indexof_char (String *st, char c)
{
  int idx = -1;
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] == c)
      { idx = i; break; }
  return idx;
}

/* to lower case */
void
string_to_lower_case (String *st)
{
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] >= 'A' && st->elts[i] <= 'Z')
      st->elts[i] = st->elts[i] + 32;
}

/* to upper case */
void
string_to_upper_case (String *st)
{
  for (int i = 0; i < st->length; i++)
    if (st->elts[i] >= 'a' && st->elts[i] <= 'z')
      st->elts[i] = st->elts[i] - 32;
}

/* got x pow n */
static long
powxn (long x, int n)
{
  long ln = (long)n;
  long t = 1;
  while (ln)
    {
      t *= (ln % 2 ? x : 1);
      x *= x;
      ln >>= 1;
    }
  return t;
}

/* java hashcode method */
/* s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1] */
unsigned int
string_java_hashcode (String *st)
{
  unsigned int h = 0;
  for (int i = 0, j = st->length - 1; i < st->length; i++, j--)
    h = h + st->elts[i] * powxn (31, j); //31 ^ j;
  return h;
}

/* another hashcode method */
unsigned int
string_mg_hashcode (String *st)
{
  const char *p = st->elts;
  unsigned int h = *p;
  if (h)
    for (p += 1; *p != '\0'; p++)
      h = (h << 5) - h + *p;
  return h;
}

/* ELF */
unsigned int
string_elf_hashcode (String *st)
{
  int hash = 0, x = 0;
  for (int i = 0; i < st->length; i++)
    {
      hash = (hash << 4) + st->elts[i];
      if ((x = hash & 0xF0000000L) != 0)
	  hash ^= (x >> 24);
      hash &= ~x;
    }
  return (hash & 0x7FFFFFFF);
}

/* JS */
unsigned int
string_js_hashcode (String *st)
{
  int hash = 1315423911; //not a prime
  for (int i = 0; i < st->length; i++)
    hash ^= ((hash << 5) + (hash >> 2) + st->elts[i]);
  return (hash & 0x7FFFFFFF);
}

/* RS */
unsigned int
string_rs_hashcode (String *st)
{
  int b = 378551; //prime
  int a = 63689;  //prime
  int hash = 0;
  for (int i = 0; i < st->length; i++)
    {
      hash = hash * a + st->elts[i];
      a = a * b;
    }
  return (hash & 0x7FFFFFFF);
}

/* PJW */
unsigned int
string_pjw_hashcode (String *st)
{
  int BitsInUnsignedInt = 32;
  int ThreeQuarters = (BitsInUnsignedInt * 3) / 4;
  int OneEighth = BitsInUnsignedInt / 8;
  int HighBits = 0xFFFFFFFF << (BitsInUnsignedInt - OneEighth);
  int hash = 0;
  int test = 0;
  for (int i = 0; i < st->length; i++)
    {
      hash = (hash << OneEighth) + st->elts[i];
      if ((test = hash & HighBits) != 0)
	hash = ((hash ^ (test >> ThreeQuarters)) & (~HighBits));
    }
  return (hash & 0x7FFFFFFF);
}

/* Jenkins */
unsigned int
string_jenkins_hashcode (String *st)
{
  unsigned int hash = 0;
  char *str = st->elts;
  for (unsigned int i = 0; i < st->length; str++, i++)
    {
      hash += (*str) + (hash << 10);
      hash ^= (hash >> 6);
    }
  hash += (hash << 3);
  hash ^= (hash >> 11);
  hash += (hash << 15);
  return (hash & 0x7FFFFFFF);
}

/* DJB */
unsigned int
string_djb_hashcode (String *st)
{
  unsigned int hash = 5381;
  char *str = st->elts;
  while (*str)
    hash += (hash << 5) + (*str++);
  return (hash & 0x7FFFFFFF);
}

/* AP */
unsigned int
string_ap_hashcode (String *st)
{
  unsigned int hash = 0;
  char *str = st->elts;
  for (int i=0; *str; i++)
    {
      if ((i & 1) == 0)
	hash ^= ((hash << 7) ^ (*str++) ^ (hash >> 3));
      else
	hash ^= (~((hash << 11) ^ (*str++) ^ (hash >> 5)));
    }
  return (hash & 0x7FFFFFFF);
}

/* get string hashcode */
unsigned int
string_hashcode (String *st)
{
  //return string_elf_hashcode (st);
  //return string_rs_hashcode (st);
  //return string_js_hashcode (st);
  //return string_pjw_hashcode (st);
  //return string_java_hashcode (st);
  return string_mg_hashcode (st);
  //return string_jenkins_hashcode (st);
  //return string_djb_hashcode (st);
  //return string_ap_hashcode (st);
}

/* ------------------------------ */

/* output string infomation for test */
void
string_info (String *st)
{
  printf ("%s\n", st->elts);
  printf ("Page : %d, Length : %d\n", st->page, st->length);
}

/**/
void
test_string_new (void)
{
  String *sta = string_new ("");
  String *stb = string_new ("Not only a test!");
  string_info (sta);
  string_info (stb);
  string_free (sta);
  string_free (stb);
}

/**/
void
test_string_append (void)
{
  String *st = string_new ("Not");
  string_info (st);
  string_append (st, " only");
  string_info (st);
  string_append (st, " a");
  string_info (st);
  string_append (st, " test");
  string_info (st);
  string_append (st, " here!");\
  string_info (st);
  string_free (st);
}

/**/
void
test_string_prepend (void)
{
  String *st = string_new ("AAA");
  string_info (st);
  string_prepend (st, "BBB ");
  string_info (st);
  string_prepend (st, "CCC ");
  string_info (st);
  string_prepend (st, "DDD ");
  string_info (st);
  string_prepend (st, "EEE ");
  string_info (st);
  string_free (st);
}

/**/
void
test_string_insert (void)
{
  String *st = string_new ("AA  AA");
  string_info (st);
  string_insert (st, 3, "BB  BB");
  string_info (st);
  string_insert (st, 6, "CC  CC");
  string_info (st);
  string_insert (st, 9, "DD  DD");
  string_info (st);
  string_insert (st, 12, "EE  EE");
  string_info (st);
  string_free (st);
}

/**/
void
test_string_erase (void)
{
  String *st = string_new ("AAABBBCCCXXXYYYZZZ");
  string_info (st);
  string_erase_all (st, 8);
  string_info (st);
  string_free (st);
  st = string_new ("AAABBBCCCXXXYYYZZZ");
  string_erase_section (st, 8, 7);
  string_info (st);
  string_free (st);
}

/**/
void
test_string_trim (void)
{
  String *sta = string_new ("www.baidu.com");
  String *stb = string_new ("  www.baidu.com");
  String *stc = string_new ("www.baidu.com   ");
  String *std = string_new ("  www.baidu.com   ");
  string_trim (sta);
  string_info (sta);
  string_trim (stb);
  string_info (stb);
  string_trim (stc);
  string_info (stc);
  string_trim (std);
  string_info (std);
  string_free (sta);
  string_free (stb);
  string_free (stc);
  string_free (std);
}

/**/
void
test_string_reverse (void)
{
  String *st = string_new ("ABCDEFGHIJKLMNOPQRSTUVWXYZ0");
  string_info (st);
  string_reverse (st);
  string_info (st);
  string_free (st);
}

/**/
void
test_string_sub (void)
{
  String *tmp;
  String *st = string_new ("Another string object test!");
  string_info (st);
  tmp = string_sub (st, 8, 6);
  if (tmp == NULL)
    printf ("Get substring is NULL!\n");
  else
    {
      string_info (tmp);
      string_free (tmp);
    }
  string_free (st);
}

/**/
void
test_string_replace (void)
{
  String *sa, *st;
  st = string_new ("Not only a test here!");
  string_info (st);
  printf ("--------------\nreplace a to XXXX\n");
  string_replace (st, "a", "XXXX");
  string_info (st);
  printf ("--------------\nreplace XXXX to a\n");
  string_replace (st, "XXXX", "a");
  string_info (st);
  printf ("--------------\n");
  sa = string_new ("Hello [name], good lucky!");
  string_info (sa);
  string_replace (sa, "[name]", "Jack Tomson");
  string_info (sa);
  string_free (sa);
  string_free (st);
}

/**/
void
test_string_with (void)
{
  String *st = string_new ("<<<Not only a test here!>>>");
  string_info (st);
  if (1 == string_starts_with (st, "<<<"))
    printf ("Starts with <<< !\n");
  if (1 == string_ends_with (st, ">>>"))
    printf ("Ends with >>> !\n");
  string_free (st);
}

/**/
void
test_string_indexof (void)
{
  String *st = string_new ("Aha test here!");
  string_info (st);
  printf ("Index of char [e] is %d\n", string_indexof_char (st, 'e'));
  printf ("Index of char [X] is %d\n", string_indexof_char (st, 'X'));
  string_free (st);
}

/**/
void
test_string_to (void)
{
  String *st = string_new ("Not only a test!");
  string_info (st);
  string_to_upper_case (st);
  string_info (st);
  string_to_lower_case (st);
  string_info (st);
  string_free (st);
}

/**/
void
test_string_hashcode (void)
{
  String *st1 = string_new ("www.runoob.com");
  String *st2 = string_new ("Not only a test!");
  String *st3 = string_new ("Also a test");
  String *st4 = string_new ("Other test");
  string_info (st1);
  printf ("Hashcode is %u\n", string_hashcode (st1));
  string_info (st2);
  printf ("Hashcode is %u\n", string_hashcode (st2));
  string_info (st3);
  printf ("Hashcode is %u\n", string_hashcode (st3));
  string_info (st4);
  printf ("Hashcode is %u\n", string_hashcode (st4));
  string_free (st1);
  string_free (st2);
  string_free (st3);
  string_free (st4);
}

/**/
#define outline() printf ("------------------------------\n")

/**/
int
main (int argc, char *argv[])
{
  //test_string_new (); outline ();
  //test_string_append (); outline ();
  //test_string_prepend (); outline ();
  //test_string_insert (); outline ();
  //test_string_erase (); outline ();
  //test_string_trim (); outline ();
  //test_string_reverse (); outline ();
  //test_string_sub (); outline();
  //test_string_replace (); outline ();
  //test_string_with (); outline ();
  //test_string_indexof (); outline ();
  //test_string_to (); outline ();
  test_string_hashcode (); outline ();
  return 0;
}
/* --):-o-:(-- */

还有一些String的功能未实现，欢迎补充！！！下一步研究其他数据结构！

麻瓜老宋
关注
专栏目录
C语言数据结构之顺序结构，字符串（String）的基本功能
gwsong52的博客
10-11 433
C语言数据结构之顺序结构，字符串（String）的基本功能，追加、删除、替换等。
数据结构实战开发教程（七）字符串类的创建、KMP 子串查找算法、KMP 算法的应用、递归的思想与应用
Exp.Joker
06-25 1014
C++中的原生类型系统是否包含字符串类型？没有，通过标准库。 String.hString.cppstring.hstring.cpp思考：如何在目标字符串中查找是否存在指定的子串？如何在目标字符串S中，查找是否存在子串P ？示例: ABCDABD如何在目标字符串中查 找是否存在指定的子串？string.hstring.cpp第一轮，从主串的首位开始，把主串和模式串的字符逐个比较：显然，主串的首位字符是a，模式串的首位字符是b，两者并不匹配。第二轮，把模式串后移一位，从主串的第二位开始，把主
java常用的数组、字符串、集合操作以及数据结构与算法基本知识
lu93it的博客
09-09 4930
java中常用封装的数组 、字符串、 集合来操作对象，但数据结构中常用的有栈和队列   数与图以及他们之间的排序，查找。         数组声明没有分配内存空间  只有创建或者是初始化时才分配，创建时把数组中的数据类型数据所在的内存空间首地址赋值给数组名，在创建每个对象时，都会给该对象分配地址和它存储的数据 。如变量    int arr[]; int arr[]={1,2,3};  arr=
数据结构与算法之字符串
qq_37400096的博客
09-07 738
字符串常见的操作以及朴素的模式匹配以及KMP算法。
BUAA数据结构大作业2023
weixin_50567399的博客
06-26 2730
BUAA数据结构大作业2023
算法理解（五）数组和字符串
qq_51292909的博客
09-20 1259
数组作为一种基础的数据结构，因其高效的存储和访问方式，在早期计算机科学的发展中迅速占据了重要地位。尽管现代编程语言提供了更高级的数据结构（如链表、集合、哈希表等），但数组依然是许多应用中不可或缺的工具。其连续的内存布局、快速的访问时间使其在科学计算、图像处理和机器学习中依然发挥着重要作用。字符串的发展从早期的简单字符编码到如今支持全球语言的 Unicode 标准，伴随着计算机科学的发展而不断演进。
数据结构-用C语言描述耿国华版总结笔记（上篇）
热门推荐
云瀚的自习室
04-27 1万+
数据结构-----用C语言描述 两年前的考研笔记了，再回首，不忍唏嘘，时间过得真快。 下篇：https://blog.csdn.net/weixin_38244174/article/details/90707831 ...
Redis基本数据结构和底层实现原理
山海里没有故事
09-06 844
Redis基本结构与底层实现
数据结构与算法：链表、树、图、堆、散列表
薛定谔的猫-前端领域
06-30 1326
链表是线性数据结构（数据元素之间存在着“一对一”关系），链表中的每个元素是一个包含数据data和引用字段的对象，引用字段只有next为单向链表，同时又prev和next为双向链表。
数据结构与JAVA集合
ll_0104的博客
04-08 916
在这里插入图片描述 数据结构 1.数据结构有什么用？ 当你用java里面的容器类很爽的时候，你有没有想过是如何实现的呢？ 现实世界的存储我们使用的是工具和建模。每种数据结构都有自己的优点和缺点想想如果google的数据用的是数组进行存储，我们还能方便的查询所有的数据吗？而算法，在这么多的数据中如何做到快速的插入、查找、删除也是在追求更快。 我们的java语言是面向对象的语言，就像是自动挡轿车，C语言面向过程的编程语言类似于手动挡。数据结构就是变速箱 2.常见数据结构 栈、队列、
redis存储图片_最详细的Redis五种数据结构详解（理论+实战），建议收藏。
weixin_39981185的博客
12-01 2024
本文脑图前言Redis是基于c语言编写的开源非关系型内存数据库，可以用作数据库、缓存、消息中间件，这么优秀的东西客定要一点一点的吃透它。关于Redis的文章之前也写过两篇，阅读量和读者的反映都还可以，其中第一篇是Redis的缓存三大问题[]。第二篇是Redis的内存管理和淘汰策略[]。这是关于Redis的第三篇文章，主要讲解Redis的五种数据结构详解，包括这五种的数据结构的底层原理实现。理论肯定...
【java面试经(架构师&设计师)-第1课】java常用数据结构(一)
金和弦的博客
10-08 130
【技术清单】 1、Java支持的基本数据类型有哪些，他们占用的字节大小分别是多少？ 2、char 型变量中能不能存贮一个中文汉字？为什么？ 3、什么是装箱和拆箱？实现的原理是什么？ 4、int 和Integer 有什么区别？字符串的反转及替换？ 5、String与StringBuffer区别？ 6、 ...
JAVA基础（一）——基本数据类型、==与equals、hashcode用法
qq_42540547的博客
11-07 673
JAVA基本数据类型 在生活中，使用的数据有大有小，有整数，也有小数，同时也会使用字母，或者汉字表示特定含义。在Java中根据数据的不同特点，数据也分为不同的类型。 Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存总分配 了不同大小的内存空间。 1.数据类型详细介绍 （1）整数类型（byte、short、int、long） 虽然byte、short、int、long ...
网站建设中常见的网站后台开发语言有哪几种，各自优缺点都是什么？
2301_80154636的博客
09-24 2396
总的来说，每种语言都有其特定的优势和局限，选择哪种语言取决于项目需求、团队技能和预期的维护成本等多种因素。理解这些语言的核心特性和适用场景可以帮助开发者做出更明智的选择，从而有效提升项目的成功率和开发效率。这些语言各有其独特的优缺点，适用于不同的开发场景和需求。市场上常见的网站后台开发语言有。
C/C++进阶(一)--内存管理
Stark的博客
10-03 1559
更多精彩内容.....🎉❤️✨😘​​​​​​座右铭：梦想是一盏明灯，照亮我们前行的路，无论风雨多大，我们都要坚持不懈。在前面，我们学习C语言的时候，我们就提到过内存的概念，介绍了内存的分区以及各个区域负责的事情，并且给出了一些内存函数使用。本节我们主要是学习内存的管理。
关于C语⾔内存函数 memcpy memmove memset memcmp
2301_76838975的博客
10-09 245
/模拟实现memmoveif (dest < source)//dest 在src左边，从前向后拷贝else {//dest 在src右边以及重合，从后向前拷贝return ret;i++)i < 10;结果memset函数的使⽤memset是⽤来设置内存的，将内存中的值以字节为单位设置成想要的内容。
Redis 五种数据类型及底层数据结构详解
fudaihb的博客
10-06 924
Redis 是一个高性能的键值对存储系统，以其丰富的数据结构和超高的访问速度广受欢迎。在 Redis 中，提供了五种基本的数据类型：字符串（String）、哈希（Hash）、列表（List）、集合（Set）以及有序集合（Sorted Set）。这些数据类型的实现依赖于不同的底层数据结构，正是这些底层结构确保了 Redis 的高效性和灵活性。 本文将详细介绍 Redis 中的五种数据类型，并解析每种数据类型对应的底层数据结构，以帮助开发者更好地理解和应用 Redis。
Redis Bitmap 数据结构在权限管理、数据分析以及广告投放中的应用
最新发布
欢迎来到【技术拾光者】，在这里，我们专注分享编程教程、技术趋势、实战案例和优质资源。不定期举办技术问答、专家访谈和职业指导。加入我们，共同探索技术世界，提升技能，拓展职业道路！
10-11 219
Redis 的 Bitmap 是一种高效的位操作数据结构，适用于存储和处理大量布尔值（0 或 1）。本文探讨了 Redis Bitmap 在多个实际应用场景中的使用方法，包括权限管理以及数据分析和广告投放。通过具体的 Java 示例代码，展示了如何利用 Bitmap 提高数据存储和处理的效率。这些示例不仅帮助理解 Bitmap 的基本操作，还展示了其在实际业务中的广泛应用，提供了实用的解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值